Ability to use named typeorm connections

examples/typeorm/index.ts

@@ -16,6 +16,7 @@ import { AddressInfo } from "net";
 
 export function connect(logging: boolean = false) {
   return createConnection({
+    name: "test",
     type: "sqlite",
     database: ":memory:",
     entities: [path.resolve(__dirname, "entities", "*.{js,ts}")],
@@ -25,22 +26,22 @@ export function connect(logging: boolean = false) {
 }
 
 export async function seed() {
-  const company = await getRepository(Company).save(new Company({}));
+  const company = await getRepository(Company, 'test').save(new Company({}));
 
-  const desk1 = await getRepository(Desk).save(new Desk({ company }));
-  const desk2 = await getRepository(Desk).save(new Desk({ company }));
+  const desk1 = await getRepository(Desk, 'test').save(new Desk({ company }));
+  const desk2 = await getRepository(Desk, 'test').save(new Desk({ company }));
 
-  const chair1 = await getRepository(Chair).save(
+  const chair1 = await getRepository(Chair, 'test').save(
     new Chair({ company, desk: desk1 })
   );
 
-  const cert1 = await getRepository(Cert).save(new Cert({}));
-  const cert2 = await getRepository(Cert).save(new Cert({}));
+  const cert1 = await getRepository(Cert, 'test').save(new Cert({}));
+  const cert2 = await getRepository(Cert, 'test').save(new Cert({}));
 
-  const employee1 = await getRepository(Employee).save(
+  const employee1 = await getRepository(Employee, 'test').save(
     new Employee({ company, desk: desk1, certs: [cert1, cert2] })
   );
-  const employee2 = await getRepository(Employee).save(
+  const employee2 = await getRepository(Employee, 'test').save(
     new Employee({ company, certs: [cert1] })
   );
 }
@@ -67,12 +68,17 @@ export async function listen(
         typeormGetConnection: getConnection,
       }),
     ],
+    context: ({ req, res }: any) => ({
+      req,
+      res,
+      typeormConnectionName: () => Promise.resolve('test'),
+    })
   });
 
   apollo.applyMiddleware({ app, cors: false });
 
   const server = http.createServer(app);
-  await promisify(server.listen).apply(server, [port]);
+  await promisify(server.listen).apply(server, [port] as any);
 
   return {
     port: (server.address() as AddressInfo).port,
@@ -84,7 +90,7 @@ if (require.main === module) {
   (async () => {
     await connect();
     await seed();
-    const { port } = await listen(3000, typeormResolvers);
+    const { port } = await listen(3001, typeormResolvers);
     console.log(`Listening on port ${port}`);
   })();
 }

examples/typeorm/resolvers/CertResolver.ts

@@ -1,11 +1,11 @@
-import { Resolver, Query } from "type-graphql";
+import { Resolver, Query, Ctx } from "type-graphql";
 import { getRepository } from "typeorm";
 import { Cert } from "../entities/Cert";
 
 @Resolver((of) => Cert)
 export default class CertResolver {
   @Query((returns) => [Cert])
-  async certs(): Promise<Cert[]> {
-    return getRepository(Cert).find();
+  async certs(@Ctx() ctx: { typeormConnectionName: () => Promise<string>; }): Promise<Cert[]> {
+    return getRepository(Cert, await ctx.typeormConnectionName()).find();
   }
 }

examples/typeorm/resolvers/CompanyResolver.ts

@@ -1,4 +1,4 @@
-import { Resolver, Query, FieldResolver, Root } from "type-graphql";
+import { Resolver, Query, FieldResolver, Root, Ctx } from "type-graphql";
 import { getRepository, In } from "typeorm";
 import DataLoader from "dataloader";
 import { groupBy } from "lodash";
@@ -9,13 +9,13 @@ import { Chair } from "../entities/Chair";
 @Resolver((of) => Company)
 export default class CompanyResolver {
   @Query((returns) => [Company])
-  async companies(): Promise<Company[]> {
-    return getRepository(Company).find();
+  async companies(@Ctx() ctx: { typeormConnectionName: () => Promise<string>; }): Promise<Company[]> {
+    return getRepository(Company, await ctx.typeormConnectionName()).find();
   }
 
   @FieldResolver()
-  @Loader<string, Chair[]>(async (ids) => {
-    const chairs = await getRepository(Chair).find({
+  @Loader<string, Chair[]>(async (ids, ctx) => {
+    const chairs = await getRepository(Chair, await ctx.context.typeormConnectionName()).find({
       where: { company: { id: In([...ids]) } },
     });
     const chairsById = groupBy(chairs, "companyId");

examples/typeorm/resolvers/DeskResolver.ts

@@ -1,11 +1,11 @@
-import { Resolver, Query } from "type-graphql";
+import { Resolver, Query, Ctx } from "type-graphql";
 import { getRepository } from "typeorm";
 import { Desk } from "../entities/Desk";
 
 @Resolver((of) => Desk)
 export default class DeskResolver {
   @Query((returns) => [Desk])
-  async desks(): Promise<Desk[]> {
-    return getRepository(Desk).find();
+  async desks(@Ctx() ctx: { typeormConnectionName: () => Promise<string>; }): Promise<Desk[]> {
+    return getRepository(Desk, await ctx.typeormConnectionName()).find();
   }
 }

examples/typeorm/resolvers/EmployeeResolver.ts

@@ -1,11 +1,11 @@
-import { Resolver, Query } from "type-graphql";
+import { Resolver, Query, Ctx } from "type-graphql";
 import { getRepository } from "typeorm";
 import { Employee } from "../entities/Employee";
 
 @Resolver((of) => Employee)
 export default class EmployeeResolver {
   @Query((returns) => [Employee])
-  async employees(): Promise<Employee[]> {
-    return getRepository(Employee).find();
+  async employees(@Ctx() ctx: { typeormConnectionName: () => Promise<string>; }): Promise<Employee[]> {
+    return getRepository(Employee, await ctx.typeormConnectionName()).find();
   }
 }

package.json

@@ -1,14 +1,14 @@
 {
-  "name": "type-graphql-dataloader",
+  "name": "type-graphql-dataloader-nxt",
   "description": "A utility to use DataLoader with TypeGraphQL without fuss",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "author": {
     "name": "Kazuaki Tanida",
     "url": "https://github.com/slaypni"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/slaypni/type-graphql-dataloader.git"
+    "url": "https://github.com/malisetti/type-graphql-dataloader.git"
   },
   "keywords": [
     "typescript",

src/decorators/typeorm/TypeormLoader.ts

@@ -47,8 +47,9 @@ function TypeormLoaderImpl<V>(
       if (tgdContext.typeormGetConnection == null) {
         throw Error("typeormGetConnection is not set");
       }
+      const connName = tgdContext.typeormConnectionName ? await tgdContext.typeormConnectionName() : 'default';
       const relation = tgdContext
-        .typeormGetConnection()
+        .typeormGetConnection(connName)
         .getMetadata(target.constructor)
         .findRelationWithPropertyPath(propertyKey.toString());
 
@@ -85,7 +86,7 @@ function TypeormLoaderImpl<V>(
 }
 
 async function handler<V>(
-  { requestId, typeormGetConnection }: TgdContext,
+  { requestId, typeormGetConnection, typeormConnectionName }: TgdContext,
   relation: RelationMetadata,
   columns: ColumnMetadata[],
   newDataloader: (connection: Connection) => DataLoader<any, V>,
@@ -105,7 +106,8 @@ async function handler<V>(
   const serviceId = `tgd-typeorm#${relation.entityMetadata.tableName}#${relation.propertyName}`;
   const container = Container.of(requestId);
   if (!container.has(serviceId)) {
-    container.set(serviceId, newDataloader(typeormGetConnection()));
+    const connName = typeormConnectionName ? await typeormConnectionName() : 'default'
+    container.set(serviceId, newDataloader(typeormGetConnection(connName)));
   }
 
   return callback(container.get<DataLoader<any, any>>(serviceId), columns);

src/plugins/apollo-server/ApolloServerLoaderPlugin.ts

@@ -4,7 +4,7 @@ import { v4 as uuidv4 } from "uuid";
 import { TgdContext } from "#/types/TgdContext";
 
 interface ApolloServerLoaderPluginOption {
-  typeormGetConnection?: () => Connection;
+  typeormGetConnection?: (connName: string) => Connection;
 }
 
 const ApolloServerLoaderPlugin = (option?: ApolloServerLoaderPluginOption) => ({
@@ -14,6 +14,7 @@ const ApolloServerLoaderPlugin = (option?: ApolloServerLoaderPluginOption) => ({
         _tgdContext: {
           requestId: uuidv4(),
           typeormGetConnection: option?.typeormGetConnection,
+          typeormConnectionName: requestContext.context.typeormConnectionName,
         } as TgdContext,
       });
     },

src/types/TgdContext.ts

@@ -2,5 +2,6 @@ import type { Connection } from "typeorm";
 
 export interface TgdContext {
   requestId: string;
-  typeormGetConnection?: () => Connection;
+  typeormGetConnection?: (connName?: string) => Connection;
+  typeormConnectionName?: () => Promise<string>;
 }

tests/typeorm.ts

@@ -14,7 +14,7 @@ let endpoint: string;
 const seed = async () => {
   const [company, company2] = await Promise.all(
     [{ name: "company1" }, { name: "company2" }].map((v) =>
-      getRepository(Company).save(new Company(v))
+      getRepository(Company, "test").save(new Company(v))
     )
   );
 
@@ -23,19 +23,19 @@ const seed = async () => {
       { name: "desk1", company },
       { name: "desk2", company },
       { name: "desk3", company },
-    ].map((v) => getRepository(Desk).save(new Desk(v)))
+    ].map((v) => getRepository(Desk, "test").save(new Desk(v)))
   );
 
   const [chair1] = await Promise.all(
     [
       { name: "chair1", company, desk: desk1 },
       { name: "chair2", company: company2 },
-    ].map((v) => getRepository(Chair).save(new Chair(v)))
+    ].map((v) => getRepository(Chair, "test").save(new Chair(v)))
   );
 
   const [cert1, cert2, cert3] = await Promise.all(
     [{ name: "cert1" }, { name: "cert2" }, { name: "cert3" }].map((v) =>
-      getRepository(Cert).save(new Cert(v))
+      getRepository(Cert, "test").save(new Cert(v))
     )
   );
 
@@ -44,7 +44,7 @@ const seed = async () => {
       { name: "employee1", company, desk: desk1, certs: [cert1, cert2] },
       { name: "employee2", company, desk: desk2, certs: [cert1] },
       { name: "employee3", company, certs: [] },
-    ].map((v) => getRepository(Employee).save(new Employee(v)))
+    ].map((v) => getRepository(Employee, "test").save(new Employee(v)))
   );
 };
 
@@ -58,7 +58,7 @@ beforeAll(async () => {
 
 afterAll(async () => {
   await close();
-  await getConnection().close();
+  await getConnection("test").close();
 });
 
 const objectTypes = {
@@ -121,7 +121,7 @@ const verify = async <Entity extends ObjectLiteral>(
         const getSelfEntity = async () =>
           (await getRepository(
             objectTypes[obj.__typename as typename]
-          ).findOneOrFail({
+          , "test").findOneOrFail({
             where: { name: obj.name },
             relations: [k],
           })) as any;
@@ -192,7 +192,7 @@ test("verify query companies", async () => {
     }
   `;
   const data = await request(endpoint, query);
-  await verify(data.companies, await getRepository(Company).find());
+  await verify(data.companies, await getRepository(Company, "test").find());
 });
 
 test("verify query employees", async () => {
@@ -221,7 +221,7 @@ test("verify query employees", async () => {
     }
   `;
   const data = await request(endpoint, query);
-  await verify(data.employees, await getRepository(Employee).find());
+  await verify(data.employees, await getRepository(Employee, "test").find());
 });
 
 test("verify query certs", async () => {
@@ -238,7 +238,7 @@ test("verify query certs", async () => {
     }
   `;
   const data = await request(endpoint, query);
-  await verify(data.certs, await getRepository(Cert).find());
+  await verify(data.certs, await getRepository(Cert, "test").find());
 });
 
 test("verify query desks", async () => {
@@ -271,5 +271,5 @@ test("verify query desks", async () => {
     }
   `;
   const data = await request(endpoint, query);
-  await verify(data.desks, await getRepository(Desk).find());
+  await verify(data.desks, await getRepository(Desk, "test").find());
 });