change vscode debug config, add subscriptions support, add auto select tables pk in loaders, add peer deps

Author: t.kosminov

.vscode/launch.json

@@ -5,13 +5,25 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "type": "pwa-node",
+      "type": "node",
       "request": "launch",
-      "name": "Launch Program",
-      "skipFiles": [
-        "<node_internals>/**"
+      "name": "debug",
+      "cwd": "${workspaceFolder}",
+      "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/ts-node",
+      "args": [
+        "${workspaceFolder}/src/main.ts",
+        "--runInBand",
+        "--no-cache",
       ],
-      "program": "${workspaceFolder}/src/main.ts"
+      "runtimeArgs": [
+        "--files",
+        "-r",
+        "${workspaceFolder}/node_modules/tsconfig-paths/register"
+      ],
+      "env": {
+        "NODE_ENV": "development",
+        "TS_NODE_PROJECT": "${workspaceFolder}/tsconfig.json"
+      },
     }
   ]
 }

README.md

@@ -48,18 +48,21 @@ import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
 ...
 import { Request } from 'express';
 import { DataSource } from 'typeorm';
+import { setDataSource } from 'nestjs-graphql-easy' // <-- ADD
 
 @Injectable()
 export class GraphqlOptions implements GqlOptionsFactory {
-  constructor(private readonly dataSource: DataSource) {} // <-- ADD
+  constructor(private readonly dataSource: DataSource) { // <-- ADD
+    setDataSource(this.dataSource); // <-- ADD
+  }
 
   public createGqlOptions(): Promise<ApolloDriverConfig> | ApolloDriverConfig {
     return {
       ...
       driver: ApolloDriver,
       context: ({ req }: { req: Request }) => ({
         req,
-        data_source: this.dataSource, // <-- ADD
+        data_source: this.dataSource, // <-- DEPRECATED. But this will still work if no subscriptions are used
       }),
       ...
     };

lib/error/index.ts

@@ -20,3 +20,19 @@ export const bad_request = (data?: IErrData) => {
 
   return err;
 };
+
+export const invalid_data_source = (data?: IErrData) => {
+  const err = new HttpException(
+    {
+      status: 500,
+      error: data?.msg || 'INVALID_DATA_SOURCE',
+    },
+    500
+  );
+
+  if (data?.raise) {
+    throw err;
+  }
+
+  return err;
+};

lib/loader/decorator.loader.ts

@@ -9,7 +9,8 @@ import { underscore } from '../helper';
 import { IFilterValue, IParsedFilter, parseFilter } from '../filter/parser.filter';
 import { IOrderValue, IParsedOrder, parseOrder } from '../order/parser.order';
 import { IPaginationValue, IParsedPagination, parsePagination } from '../pagination/parser.pagination';
-import { getTableColumns, getTableForeignKeys } from '../store';
+import { getTableColumns, getTableForeignKeys, getTablePrimaryKeys } from '../store';
+import { invalid_data_source } from '../error';
 
 import { manyToOneLoader } from './many-to-one.loader';
 import { oneToManyLoader } from './one-to-many.loader';
@@ -44,6 +45,12 @@ export interface IPrivateLoaderData extends ILoaderData {
   entity_manager?: EntityManager;
 }
 
+let data_source: DataSource = null;
+
+export function setDataSource(ds: DataSource) {
+  data_source = ds;
+}
+
 export const Loader = createParamDecorator((data: ILoaderData, ctx: ExecutionContext) => {
   const args = ctx.getArgs();
 
@@ -89,16 +96,27 @@ export const Loader = createParamDecorator((data: ILoaderData, ctx: ExecutionCon
   const selected_fields = recursiveSelectedFields(_data, info.fieldNodes, info.fragments);
   const entity_table_columns = getTableColumns(entity_class_name);
   const entity_table_foreign_keys = getTableForeignKeys(entity_class_name);
+  const entity_table_primary_keys = getTablePrimaryKeys(entity_class_name);
 
   const selected_columns = new Set(Array.from(selected_fields).filter((field) => entity_table_columns.has(field)));
 
   entity_table_foreign_keys.forEach((fk) => {
     selected_columns.add(fk);
   });
 
+  entity_table_primary_keys.forEach((pk) => {
+    selected_columns.add(pk);
+  });
+
   if (!_data.entity_manager) {
     if (!gctx['entity_manager']) {
-      gctx['entity_manager'] = gctx.data_source.createEntityManager();
+      if (data_source) {
+        gctx['entity_manager'] = data_source.createEntityManager();
+      } else if (gctx?.data_source) {
+        gctx['entity_manager'] = gctx.data_source.createEntityManager();
+      } else {
+        invalid_data_source({ raise: true });
+      }
     }
 
     _data.entity_manager = gctx['entity_manager'];

lib/loader/index.ts

@@ -1 +1 @@
-export { Loader, ELoaderType, ILoaderData } from './decorator.loader';
+export { Loader, ELoaderType, ILoaderData, setDataSource } from './decorator.loader';

lib/store/index.ts

@@ -9,4 +9,5 @@ export {
   PrimaryGeneratedColumn,
   getTableColumns,
   getTableForeignKeys,
+  getTablePrimaryKeys,
 } from './typeorm';

lib/store/typeorm.ts

@@ -40,6 +40,11 @@ export const table_columns: Map<string, Set<string>> = new Map();
  */
 export const table_foreign_keys: Map<string, Set<string>> = new Map();
 
+/**
+ * Map<entity_class_name, Set<entity_column_name>>
+ */
+export const table_primary_keys: Map<string, Set<string>> = new Map();
+
 export function getTableColumns(entity_class_name: string) {
   if (table_columns.has(entity_class_name)) {
     return table_columns.get(entity_class_name);
@@ -80,6 +85,28 @@ export function getTableForeignKeys(entity_class_name: string) {
   return table_foreign_keys.get(entity_class_name) || new Set();
 }
 
+export function getTablePrimaryKeys(entity_class_name: string) {
+  if (table_primary_keys.has(entity_class_name)) {
+    return table_primary_keys.get(entity_class_name);
+  }
+
+  const typeormArgs = getMetadataArgsStorage();
+
+  typeormArgs.columns.forEach((col) => {
+    if (col.options?.primary) {
+      if (!table_primary_keys.has(col.target['name'])) {
+        table_primary_keys.set(col.target['name'], new Set([]));
+      }
+
+      const fks = table_primary_keys.get(col.target['name']);
+
+      fks.add(col.propertyName);
+    }
+  });
+
+  return table_primary_keys.get(entity_class_name) || new Set();
+}
+
 export function PolymorphicColumn(): PropertyDecorator {
   return (prototype: any, property_key: string) => {
     if (!table_foreign_keys.has(prototype['constructor']['name'])) {