@smartive/graphql-magic 9.1.2 → 10.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartive/graphql-magic",
-  "version": "9.1.2",
+  "version": "10.0.0",
   "description": "",
   "source": "src/index.ts",
   "type": "module",
@@ -13,16 +13,17 @@
   "sideEffecs": false,
   "scripts": {
     "bootstrap": "npm ci && npm run generate",
-    "generate": "npm run generate:index-files",
+    "generate": "npm run generate:index-files && npm run build:bin && npm run generate:gqm-stuff && npm run generate:setup-migration",
     "generate:index-files": "cti create ./src --excludes bin --withoutbackup",
+    "generate:gqm-stuff": "npx gqm generate",
+    "generate:setup-migration": "npm run build:bin && npx gqm generate-migration setup 20230912185644",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
     "deps": "docker-compose up",
     "test": "npm run lint && npm run test:all && npm run build",
-    "test:all": "jest tests --no-cache --no-watchman",
-    "test:unit": "jest tests/unit --no-cache --no-watchman",
-    "test:api": "jest tests/api --no-cache --no-watchman",
-    "generate-migration": "esbuild tests/utils/generate-migration.ts --bundle --platform=node --outdir=tmp --out-extension:.js=.cjs --format=cjs --packages=external && node tmp/generate-migration.cjs",
+    "test:all": "jest tests --no-cache --no-watchman --setupFiles dotenv/config",
+    "test:unit": "jest tests/unit --no-cache --no-watchman --setupFiles dotenv/config",
+    "test:api": "jest tests/api --no-cache --no-watchman --setupFiles dotenv/config",
     "clean": "del-cli dist/**",
     "prebuild": "npm run clean",
     "build": "npm run build:esm && npm run build:cjs && npm run build:bin",
@@ -35,7 +36,7 @@
   },
   "overrides": {
     "graphql": "$graphql",
-    "rollup": "3.29.3"
+    "rollup": "3.29.4"
   },
   "browserslist": "> 0.25%, not dead",
   "publishConfig": {
@@ -62,16 +63,17 @@
     "uuid": "^9.0.0"
   },
   "devDependencies": {
-    "@smartive/eslint-config": "3.2.0",
+    "@smartive/eslint-config": "3.3.0",
     "@smartive/prettier-config": "3.1.2",
-    "@types/jest": "29.5.5",
-    "@types/lodash": "4.14.199",
-    "@types/luxon": "3.3.2",
-    "@types/uuid": "9.0.4",
+    "@types/jest": "29.5.6",
+    "@types/lodash": "4.14.200",
+    "@types/luxon": "3.3.3",
+    "@types/pg": "8.10.2",
+    "@types/uuid": "9.0.6",
     "create-ts-index": "1.14.0",
     "del-cli": "5.1.0",
-    "esbuild": "0.19.3",
-    "eslint": "8.50.0",
+    "esbuild": "0.19.5",
+    "eslint": "8.52.0",
     "graphql-request": "6.1.0",
     "jest": "29.7.0",
     "mock-knex": "0.4.12",

package/src/api/execute.ts

@@ -12,7 +12,7 @@ export const execute = async ({
   additionalResolvers?: IResolvers<any, any>;
   body: any;
 } & Omit<Context, 'document'>) => {
-  const document = generate(ctx.rawModels);
+  const document = generate(ctx.models);
 
   const generatedResolvers = getResolvers(ctx.models);
 

package/src/bin/gqm/gqm.ts

@@ -40,12 +40,13 @@ program
   .command('generate')
   .description('Generate all the things')
   .action(async () => {
-    const rawModels = await parseModels();
+    const models = await parseModels();
     const generatedFolderPath = await getSetting('generatedFolderPath');
-    writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(rawModels));
-    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(rawModels));
-    writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(rawModels));
-    writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(rawModels));
+    const gqlModule = await getSetting('gqlModule');
+    writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(models));
+    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models, gqlModule));
+    writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models));
+    writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(models));
     await generateGraphqlApiTypes();
     await generateGraphqlClientTypes();
   });
@@ -54,45 +55,44 @@ program
   .command('generate-models')
   .description('Generate models.json')
   .action(async () => {
-    const rawModels = await parseModels();
-    const generatedFolderPath = await getSetting('generatedFolderPath');
-    writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
+    await parseModels();
   });
 
 program
   .command('generate-schema')
   .description('Generate schema')
   .action(async () => {
-    const rawModels = await parseModels();
+    const models = await parseModels();
     const generatedFolderPath = await getSetting('generatedFolderPath');
-    writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(rawModels));
+    writeToFile(`${generatedFolderPath}/schema.graphql`, printSchemaFromModels(models));
   });
 
 program
   .command('generate-mutation-queries')
   .description('Generate mutation-queries')
   .action(async () => {
-    const rawModels = await parseModels();
+    const models = await parseModels();
     const generatedFolderPath = await getSetting('generatedFolderPath');
-    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(rawModels));
+    const gqlModule = await getSetting('gqlModule');
+    writeToFile(`${generatedFolderPath}/client/mutations.ts`, generateMutations(models, gqlModule));
   });
 
 program
   .command('generate-db-types')
   .description('Generate DB types')
   .action(async () => {
-    const rawModels = await parseModels();
+    const models = await parseModels();
     const generatedFolderPath = await getSetting('generatedFolderPath');
-    writeToFile(`${generatedFolderPath}/db/index.ts`, generateMutations(rawModels));
+    writeToFile(`${generatedFolderPath}/db/index.ts`, generateDBModels(models));
   });
 
 program
   .command('generate-knex-types')
   .description('Generate Knex types')
   .action(async () => {
-    const rawModels = await parseModels();
+    const models = await parseModels();
     const generatedFolderPath = await getSetting('generatedFolderPath');
-    writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(rawModels));
+    writeToFile(`${generatedFolderPath}/db/knex.ts`, generateKnexTables(models));
   });
 
 program
@@ -110,14 +110,16 @@ program
   });
 
 program
-  .command('generate-migration')
+  .command('generate-migration [<name>] [<date>]')
   .description('Generate Migration')
-  .action(async () => {
+  .action(async (name, date) => {
     const git = simpleGit();
 
-    let name = process.argv[process.argv.indexOf('gqm') + 1] || (await git.branch()).current.split('/').pop();
+    if (!name) {
+      name = (await git.branch()).current.split('/').pop();
+    }
 
-    if (name && ['staging', 'production'].includes(name)) {
+    if (!name || ['main', 'staging', 'production'].includes(name)) {
       name = await readLine('Migration name:');
     }
 
@@ -125,10 +127,10 @@ program
     const db = knex(knexfile);
 
     try {
-      const rawModels = await parseModels();
-      const migrations = await new MigrationGenerator(db, rawModels).generate();
+      const models = await parseModels();
+      const migrations = await new MigrationGenerator(db, models).generate();
 
-      writeToFile(`migrations/${getMigrationDate()}_${name}.ts`, migrations);
+      writeToFile(`migrations/${date || getMigrationDate()}_${name}.ts`, migrations);
     } finally {
       await db.destroy();
     }

package/src/bin/gqm/parse-models.ts

@@ -1,5 +1,5 @@
 import { IndentationText, Project } from 'ts-morph';
-import { RawModels } from '../..';
+import { Models } from '../..';
 import { getSetting, writeToFile } from './settings';
 import { staticEval } from './static-eval';
 import { findDeclarationInFile } from './utils';
@@ -13,12 +13,12 @@ export const parseModels = async () => {
   const modelsPath = await getSetting('modelsPath');
   const sourceFile = project.addSourceFileAtPath(modelsPath);
 
-  const modelsDeclaration = findDeclarationInFile(sourceFile, 'rawModels');
+  const modelsDeclaration = findDeclarationInFile(sourceFile, 'models');
 
-  const rawModels = staticEval(modelsDeclaration, {});
+  const models = staticEval(modelsDeclaration, {}) as Models;
 
   const generatedFolderPath = await getSetting('generatedFolderPath');
-  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(rawModels, null, 2));
+  writeToFile(`${generatedFolderPath}/models.json`, JSON.stringify(models.definitions, null, 2));
 
-  return rawModels as RawModels;
+  return models;
 };

package/src/bin/gqm/settings.ts

@@ -30,6 +30,9 @@ const DEFAULTS = {
       ensureDirectoryExists(path);
     },
   },
+  gqlModule: {
+    defaultValue: '@smartive/graphql-magic',
+  },
 };
 
 type Settings = {
@@ -45,8 +48,10 @@ const initSetting = async (name: string) => {
 
 const initSettings = async () => {
   const settings: Settings = {} as Settings;
-  for (const name of Object.keys(DEFAULTS)) {
-    settings[name] = await initSetting(name);
+  for (const [name, config] of Object.entries(DEFAULTS)) {
+    if ('queston' in config) {
+      settings[name] = await initSetting(name);
+    }
   }
   saveSettings(settings);
 };
@@ -65,8 +70,12 @@ export const getSettings = async (): Promise<Settings> => {
 export const getSetting = async (name: keyof Settings): Promise<string> => {
   const settings = await getSettings();
   if (!(name in settings)) {
-    settings[name] = await initSetting(name);
-    saveSettings(settings);
+    if ('question' in DEFAULTS[name]) {
+      settings[name] = await initSetting(name);
+      saveSettings(settings);
+    } else {
+      return DEFAULTS[name].defaultValue;
+    }
   }
   return settings[name];
 };

package/src/bin/gqm/static-eval.ts

@@ -11,6 +11,7 @@ import {
   TemplateExpression,
   TemplateTail,
 } from 'ts-morph';
+import { Models } from '../../models/models';
 import { Visitor, visit } from './visitor';
 
 export const staticEval = (node: Node | undefined, context: Dictionary<unknown>) =>
@@ -54,6 +55,8 @@ const VISITOR: Visitor<unknown, Dictionary<unknown>> = {
         return process;
       case 'Symbol':
         return Symbol;
+      case 'Models':
+        return Models;
     }
     const definitionNodes = node.getDefinitionNodes();
     if (!definitionNodes.length) {
@@ -204,4 +207,6 @@ const VISITOR: Visitor<unknown, Dictionary<unknown>> = {
   },
   [SyntaxKind.NoSubstitutionTemplateLiteral]: (node) => node.getLiteralValue(),
   [SyntaxKind.NullKeyword]: () => null,
+  [SyntaxKind.NewExpression]: (node, context) =>
+    new (staticEval(node.getExpression(), context))(...node.getArguments().map((arg) => staticEval(arg, context))),
 };

package/src/bin/gqm/templates.ts

@@ -1,7 +1,7 @@
 export const EMPTY_MODELS = `
-import { RawModels, getModels } from '@smartive/graphql-magic';
+import { RawModels, Models } from '@smartive/graphql-magic';
 
-export const rawModels: RawModels = [
+const rawModels: RawModels = [
   {
     kind: 'entity',
     name: 'User',
@@ -9,10 +9,23 @@ export const rawModels: RawModels = [
   },
 ]
 
-export const models = getModels(rawModels);
+export const models = new Models(rawModels);
 `;
 
 export const KNEXFILE = `
+import { DateTime } from 'luxon';
+import { types } from 'pg';
+
+const dateOids = { date: 1082, timestamptz: 1184, timestamp: 1114 };
+for (const oid of Object.values(dateOids)) {
+  types.setTypeParser(oid, (val) => DateTime.fromSQL(val));
+}
+
+const numberOids = { int8: 20, float8: 701, numeric: 1700 };
+for (const oid of Object.values(numberOids)) {
+  types.setTypeParser(oid, Number);
+}
+
 const config = {
   client: 'postgresql',
   connection: {
@@ -21,6 +34,13 @@ const config = {
     user: process.env.DATABASE_USER,
     password: process.env.DATABASE_PASSWORD,
   },
+  migrations: {
+    tableName: 'knex_migrations',
+  },
+  pool: {
+    min: 0,
+    max: 30,
+  },
 } as const;
 
 export default config;

package/src/client/mutations.ts

@@ -1,12 +1,12 @@
 import upperCase from 'lodash/upperCase';
-import { isEntityModel } from '..';
-import { RawModels } from '../models/models';
+import { isRootModel, not } from '..';
+import { Models } from '../models/models';
 
 const constantCase = (str: string) => upperCase(str).replace(/ /g, '_');
 
-export const generateMutations = (models: RawModels) => {
+export const generateMutations = (models: Models, gqmModule = '@smartive/graphql-magic') => {
   const parts: string[] = [];
-  for (const { name, creatable, updatable, deletable } of models.filter(isEntityModel)) {
+  for (const { name, creatable, updatable, deletable } of models.entities.filter(not(isRootModel))) {
     if (creatable) {
       parts.push(
         `export const CREATE_${constantCase(
@@ -29,8 +29,14 @@ export const generateMutations = (models: RawModels) => {
           name
         )} = gql\`\n  mutation Delete${name}Mutation($id: ID!) {\n    delete${name}(where: { id: $id })\n  }\n\`;`
       );
+
+      parts.push(
+        `export const RESTORE_${constantCase(
+          name
+        )} = gql\`\n  mutation Restore${name}Mutation($id: ID!) {\n    restore${name}(where: { id: $id })\n  }\n\`;`
+      );
     }
   }
 
-  return `import { gql } from "@smartive/graphql-magic";\n\n${parts.join('\n\n')}`;
+  return `import { gql } from "${gqmModule}";\n\n${parts.join('\n\n')}`;
 };

package/src/client/queries.ts

@@ -1,23 +1,20 @@
 import upperFirst from 'lodash/upperFirst';
-import { ModelField } from '..';
-import { Model, Models, Relation, ReverseRelation } from '../models/models';
+import { ManyToManyRelation } from '..';
+import { EntityModel, Model, Models, Relation } from '../models/models';
 import {
   actionableRelations,
   and,
-  getModelPlural,
-  getModelPluralField,
   isQueriableBy,
   isRelation,
   isSimpleField,
   isToOneRelation,
   isUpdatableBy,
   not,
-  summonByName,
   typeToField,
 } from '../models/utils';
 
 export const getUpdateEntityQuery = (
-  model: Model,
+  model: EntityModel,
   role: any,
   fields?: string[] | undefined,
   additionalFields = ''
@@ -38,8 +35,7 @@ export const getUpdateEntityQuery = (
 }`;
 
 export const getEditEntityRelationsQuery = (
-  models: Models,
-  model: Model,
+  model: EntityModel,
   action: 'create' | 'update' | 'filter',
   fields?: string[],
   ignoreFields?: string[],
@@ -53,21 +49,19 @@ export const getEditEntityRelationsQuery = (
     !!relations.length &&
     `query ${upperFirst(action)}${model.name}Relations {
       ${relations
-        .map(({ name, type }) => {
-          const model = summonByName(models, type);
-
+        .map((relation) => {
           let filters = '';
-          if (model.displayField) {
-            const displayField = model.fieldsByName[model.displayField];
+          if (relation.targetModel.displayField) {
+            const displayField = relation.targetModel.fieldsByName[relation.targetModel.displayField];
             if (displayField.orderable) {
-              filters = `(orderBy: [{ ${model.displayField}: ASC }])`;
+              filters = `(orderBy: [{ ${relation.targetModel.displayField}: ASC }])`;
             }
           }
 
-          return `${name}: ${getModelPluralField(model)}${filters} {
+          return `${relation.name}: ${relation.targetModel.pluralField}${filters} {
             id
-            display: ${model.displayField || 'id'}
-            ${additionalFields[name] || ''}
+            display: ${relation.targetModel.displayField || 'id'}
+            ${additionalFields[relation.name] || ''}
           }`;
         })
         .join(' ')}
@@ -75,48 +69,20 @@ export const getEditEntityRelationsQuery = (
   );
 };
 
-export const getManyToManyRelations = (model: Model, fields?: string[], ignoreFields?: string[]) => {
-  const manyToManyRelations: [ReverseRelation, Relation][] = [];
-  for (const field of model.reverseRelations) {
-    if ((fields && !fields.includes(field.name)) || (ignoreFields && ignoreFields.includes(field.name))) {
-      continue;
-    }
-
-    const relation = field.model.relations.find(
-      (relation) => !relation.field.generated && relation.field.name !== field.field.name
-    );
-    if (!relation) {
-      continue;
-    }
-
-    const inapplicableFields = field.model.fields.filter(
-      (otherField) => !otherField.generated && ![field.field.name, relation.field.name].includes(otherField.name)
-    );
-    if (inapplicableFields.length) {
-      continue;
-    }
-
-    manyToManyRelations.push([field, relation]);
-  }
-  return manyToManyRelations;
-};
-
-export const getManyToManyRelation = (model: Model, name: string) => getManyToManyRelations(model, [name])[0];
-
 export const getManyToManyRelationsQuery = (
   model: Model,
   action: 'create' | 'update',
-  manyToManyRelations: [ReverseRelation, Relation][]
+  manyToManyRelations: ManyToManyRelation[]
 ) =>
   !!manyToManyRelations.length &&
   (action === 'update'
     ? `query Update${model.name}ManyToManyRelations($id: ID!) {
             ${typeToField(model.name)}(where: { id: $id }) {
               ${manyToManyRelations
-                .map(([reverseRelation, { field }]) => {
-                  return `${reverseRelation.name} {
+                .map((relation) => {
+                  return `${relation.name} {
                     id
-                    ${field.name} {
+                    ${relation.relationToTarget.name} {
                       id
                     }
                   }`;
@@ -124,20 +90,20 @@ export const getManyToManyRelationsQuery = (
                 .join(' ')}
             }
             ${manyToManyRelations
-              .map(([reverseRelation, { model }]) => {
-                return `${reverseRelation.name}: ${getModelPluralField(model)} {
+              .map((relation) => {
+                return `${relation.name}: ${relation.targetModel.pluralField} {
                   id
-                  ${model.displayField || ''}
+                  ${relation.targetModel.displayField || ''}
                 }`;
               })
               .join(' ')}
           }`
     : `query Create${model.name}ManyToManyRelations {
             ${manyToManyRelations
-              .map(([reverseRelation, { model }]) => {
-                return `${reverseRelation.name}: ${getModelPluralField(model)} {
+              .map((relation) => {
+                return `${relation.name}: ${relation.targetModel.pluralField} {
                   id
-                  ${model.displayField || ''}
+                  ${relation.targetModel.displayField || ''}
                 }`;
               })
               .join(' ')}
@@ -174,28 +140,28 @@ export const getMutationQuery = (model: Model, action: 'create' | 'update' | 'de
         }
         `;
 
-export const displayField = (model: Model) => `
+export const displayField = (model: EntityModel) => `
 ${model.displayField ? `display: ${model.displayField}` : ''}
 `;
 
 export const getEntityListQuery = (
-  model: Model,
+  model: EntityModel,
   role: string,
   additionalFields = '',
   root?: {
-    model: Model;
+    model: EntityModel;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     entity: any;
     reverseRelationName: string;
   }
-) => `query ${getModelPlural(model)}List(
+) => `query ${model.plural}List(
   ${root ? '$id: ID!,' : ''}
   $limit: Int!,
   $where: ${model.name}Where!,
   ${model.fields.some(({ searchable }) => searchable) ? '$search: String,' : ''}
 ) {
   ${root ? `root: ${typeToField(root.model.name)}(where: { id: $id }) {` : ''}
-    data: ${root ? root.reverseRelationName : getModelPluralField(model)}(limit: $limit, where: $where, ${
+    data: ${root ? root.reverseRelationName : model.pluralField}(limit: $limit, where: $where, ${
   model.fields.some(({ searchable }) => searchable) ? ', search: $search' : ''
 }) {
       ${displayField(model)}
@@ -209,12 +175,11 @@ export type VisibleRelationsByRole = Record<string, Record<string, string[]>>;
 
 export const isVisibleRelation = (visibleRelationsByRole: VisibleRelationsByRole, modelName: string, role: string) => {
   const whitelist = visibleRelationsByRole[role]?.[modelName];
-  return ({ name }: ModelField) => (whitelist ? whitelist.includes(name) : true);
+  return (relation: Relation) => (whitelist ? whitelist.includes(relation.name) : true);
 };
 
 export const getEntityQuery = (
-  models: Models,
-  model: Model,
+  model: EntityModel,
   role: string,
   visibleRelationsByRole: VisibleRelationsByRole,
   typesWithSubRelations: string[]
@@ -223,42 +188,40 @@ export const getEntityQuery = (
     ${displayField(model)}
     ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
     ${queryRelations(
-      models,
-      model.fields.filter(isRelation).filter(isVisibleRelation(visibleRelationsByRole, model.name, role)),
+      model.models,
+      model.relations.filter(isVisibleRelation(visibleRelationsByRole, model.name, role)),
       role,
       typesWithSubRelations
     )}
     ${queryRelations(
-      models,
-      model.reverseRelations.filter(and(isToOneRelation, isVisibleRelation(visibleRelationsByRole, model.name, role))),
+      model.models,
+      model.reverseRelations.filter(
+        (reverseRelation) =>
+          isToOneRelation(reverseRelation.field) &&
+          isVisibleRelation(visibleRelationsByRole, model.name, role)(reverseRelation)
+      ),
       role,
       typesWithSubRelations
     )}
   }
 }`;
 
-export const getFindEntityQuery = (model: Model, role: string) => `query Find${model.name}($where: ${
+export const getFindEntityQuery = (model: EntityModel, role: string) => `query Find${model.name}($where: ${
   model.name
 }Where!, $orderBy: [${model.name}OrderBy!]) {
-  data: ${getModelPluralField(model)}(limit: 1, where: $where, orderBy: $orderBy) {
+  data: ${model.pluralField}(limit: 1, where: $where, orderBy: $orderBy) {
     ${model.fields.filter(and(isSimpleField, isQueriableBy(role))).map(({ name }) => name)}
   }
 }`;
 
-export const queryRelations = (
-  models: Models,
-  relations: { name: string; type: string }[],
-  role: string,
-  typesWithSubRelations: string[]
-) =>
+export const queryRelations = (models: Models, relations: Relation[], role: string, typesWithSubRelations: string[]) =>
   relations
-    .map(({ name, type }): string => {
-      const relatedModel = summonByName(models, type);
-      const subRelations = typesWithSubRelations.includes(type) ? relatedModel.fields.filter(isRelation) : [];
+    .map((relation): string => {
+      const subRelations = typesWithSubRelations.includes(relation.targetModel.name) ? relation.targetModel.relations : [];
 
-      return `${name} {
+      return `${relation.name} {
           id
-          ${displayField(relatedModel)}
+          ${displayField(relation.targetModel)}
           ${subRelations.length > 0 ? queryRelations(models, subRelations, role, typesWithSubRelations) : ''}
         }`;
     })

package/src/context.ts

@@ -2,7 +2,7 @@ import { DocumentNode, GraphQLResolveInfo } from 'graphql';
 import { IncomingMessage } from 'http';
 import { Knex } from 'knex';
 import { DateTime } from 'luxon';
-import { Models, RawModels } from './models/models';
+import { Models } from './models/models';
 import { Entity, MutationHook } from './models/mutation-hook';
 import { Permissions } from './permissions/generate';
 import { AliasGenerator } from './resolvers/utils';
@@ -18,7 +18,6 @@ export type Context = {
   locale: string;
   locales: string[];
   user: User;
-  rawModels: RawModels;
   models: Models;
   permissions: Permissions;
   mutationHook?: MutationHook;