@smartive/graphql-magic 23.10.0 → 23.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartive/graphql-magic",
-  "version": "23.10.0",
+  "version": "23.11.0",
   "description": "",
   "repository": {
     "type": "git",

package/src/client/mutations.ts

@@ -1,39 +1,70 @@
 import upperCase from 'lodash/upperCase';
+import { Field } from '../schema/utils';
 import { isRootModel, not } from '..';
 import { Models } from '../models/models';
 
 const constantCase = (str: string) => upperCase(str).replace(/ /g, '_');
 
+const argTypeStr = (field: Field) => {
+  const base = field.list ? `[${field.type}!]` : field.type;
+
+  return field.nonNull ? `${base}!` : base;
+};
+
+const argsToVariables = (args: readonly Field[]) => args.map((a) => `$${a.name}: ${argTypeStr(a)}`).join(', ');
+
+const argsToMutationArgs = (args: readonly Field[]) => args.map((a) => `${a.name}: $${a.name}`).join(', ');
+
 export const generateMutations = (models: Models) => {
   const parts: string[] = [];
   for (const { name, creatable, updatable, deletable } of models.entities.filter(not(isRootModel))) {
     if (creatable) {
+      const extraArgs = creatable !== true && creatable.args ? creatable.args : [];
+      const variables = extraArgs.length ? `$data: Create${name}!, ${argsToVariables(extraArgs)}` : `$data: Create${name}!`;
+      const mutationArgs = extraArgs.length ? `data: $data, ${argsToMutationArgs(extraArgs)}` : `data: $data`;
       parts.push(
         `export const CREATE_${constantCase(
           name,
-        )} = gql\`\n  mutation Create${name}Mutation($data: Create${name}!) {\n    create${name}(data: $data) { id }\n  }\n\`;`,
+        )} = gql\`\n  mutation Create${name}Mutation(${variables}) {\n    create${name}(${mutationArgs}) { id }\n  }\n\`;`,
       );
     }
 
     if (updatable) {
+      const extraArgs = updatable !== true && updatable.args ? updatable.args : [];
+      const variables = extraArgs.length
+        ? `$id: ID!, $data: Update${name}!, ${argsToVariables(extraArgs)}`
+        : `$id: ID!, $data: Update${name}!`;
+      const mutationArgs = extraArgs.length
+        ? `where: { id: $id }, data: $data, ${argsToMutationArgs(extraArgs)}`
+        : `where: { id: $id }, data: $data`;
       parts.push(
         `export const UPDATE_${constantCase(
           name,
-        )} = gql\`\n  mutation Update${name}Mutation($id: ID!, $data: Update${name}!) {\n    update${name}(where: { id: $id }, data: $data) { id }\n  }\n\`;`,
+        )} = gql\`\n  mutation Update${name}Mutation(${variables}) {\n    update${name}(${mutationArgs}) { id }\n  }\n\`;`,
       );
     }
 
     if (deletable) {
+      const deleteExtraArgs = deletable !== true && deletable.args ? deletable.args : [];
+      const deleteVariables = deleteExtraArgs.length ? `$id: ID!, ${argsToVariables(deleteExtraArgs)}` : `$id: ID!`;
+      const deleteMutationArgs = deleteExtraArgs.length
+        ? `where: { id: $id }, ${argsToMutationArgs(deleteExtraArgs)}`
+        : `where: { id: $id }`;
       parts.push(
         `export const DELETE_${constantCase(
           name,
-        )} = gql\`\n  mutation Delete${name}Mutation($id: ID!) {\n    delete${name}(where: { id: $id })\n  }\n\`;`,
+        )} = gql\`\n  mutation Delete${name}Mutation(${deleteVariables}) {\n    delete${name}(${deleteMutationArgs})\n  }\n\`;`,
       );
 
+      const restoreExtraArgs = deletable !== true && deletable.restoreArgs ? deletable.restoreArgs : [];
+      const restoreVariables = restoreExtraArgs.length ? `$id: ID!, ${argsToVariables(restoreExtraArgs)}` : `$id: ID!`;
+      const restoreMutationArgs = restoreExtraArgs.length
+        ? `where: { id: $id }, ${argsToMutationArgs(restoreExtraArgs)}`
+        : `where: { id: $id }`;
       parts.push(
         `export const RESTORE_${constantCase(
           name,
-        )} = gql\`\n  mutation Restore${name}Mutation($id: ID!) {\n    restore${name}(where: { id: $id })\n  }\n\`;`,
+        )} = gql\`\n  mutation Restore${name}Mutation(${restoreVariables}) {\n    restore${name}(${restoreMutationArgs})\n  }\n\`;`,
       );
     }
   }

package/src/migrations/generate.ts

@@ -1026,19 +1026,11 @@ export class MigrationGenerator {
     return -1;
   }
 
-  private static readonly TRIGGER_EVENT_ORDER: readonly ('INSERT' | 'UPDATE' | 'DELETE')[] = [
-    'INSERT',
-    'UPDATE',
-    'DELETE',
-  ];
-
-  private static sortTriggerEvents(
-    events: readonly ('INSERT' | 'UPDATE' | 'DELETE')[],
-  ): ('INSERT' | 'UPDATE' | 'DELETE')[] {
+  private static readonly TRIGGER_EVENT_ORDER: readonly ('INSERT' | 'UPDATE' | 'DELETE')[] = ['INSERT', 'UPDATE', 'DELETE'];
+
+  private static sortTriggerEvents(events: readonly ('INSERT' | 'UPDATE' | 'DELETE')[]): ('INSERT' | 'UPDATE' | 'DELETE')[] {
     return [...events].sort(
-      (a, b) =>
-        MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(a) -
-        MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(b),
+      (a, b) => MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(a) - MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(b),
     );
   }
 
@@ -1050,7 +1042,9 @@ export class MigrationGenerator {
       .replace(/\bON\s+[a-zA-Z_][a-zA-Z0-9_]*\./gi, 'ON ')
       .trim();
 
-    const eventsMatch = s.match(/\b(AFTER|BEFORE)\s+((?:INSERT|UPDATE|DELETE)(?:\s+OR\s+(?:INSERT|UPDATE|DELETE))+)\s+ON\b/i);
+    const eventsMatch = s.match(
+      /\b(AFTER|BEFORE)\s+((?:INSERT|UPDATE|DELETE)(?:\s+OR\s+(?:INSERT|UPDATE|DELETE))+)\s+ON\b/i,
+    );
     if (eventsMatch) {
       const events = eventsMatch[2].split(/\s+OR\s+/).map((e) => e.toUpperCase());
       const sorted = [...events].sort(
@@ -1311,8 +1305,7 @@ export class MigrationGenerator {
 
   private sortTriggerEvents(events: readonly ('INSERT' | 'UPDATE' | 'DELETE')[]): ('INSERT' | 'UPDATE' | 'DELETE')[] {
     return [...events].sort(
-      (a, b) =>
-        MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(a) - MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(b),
+      (a, b) => MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(a) - MigrationGenerator.TRIGGER_EVENT_ORDER.indexOf(b),
     );
   }
 

package/src/models/model-definitions.ts

@@ -145,14 +145,28 @@ export type ModelDefinition = {
       interfaces?: readonly string[];
       queriable?: boolean;
       listQueriable?: boolean | { args?: readonly Field[] };
-      creatable?: boolean | { createdBy?: Partial<RelationFieldDefinition>; createdAt?: Partial<DateTimeFieldDefinition> };
-      updatable?: boolean | { updatedBy?: Partial<RelationFieldDefinition>; updatedAt?: Partial<DateTimeFieldDefinition> };
+      creatable?:
+        | boolean
+        | {
+            createdBy?: Partial<RelationFieldDefinition>;
+            createdAt?: Partial<DateTimeFieldDefinition>;
+            args?: readonly Field[];
+          };
+      updatable?:
+        | boolean
+        | {
+            updatedBy?: Partial<RelationFieldDefinition>;
+            updatedAt?: Partial<DateTimeFieldDefinition>;
+            args?: readonly Field[];
+          };
       deletable?:
         | boolean
         | {
             deleted?: Partial<BooleanFieldDefinition>;
             deletedBy?: Partial<RelationFieldDefinition>;
             deletedAt?: Partial<DateTimeFieldDefinition>;
+            args?: readonly Field[];
+            restoreArgs?: readonly Field[];
           };
       aggregatable?: boolean;
       displayField?: string;

package/src/models/models.ts

@@ -344,14 +344,28 @@ export class EntityModel extends Model {
   interfaces?: string[];
   queriable?: boolean;
   listQueriable?: boolean | { args?: readonly Field[] };
-  creatable?: boolean | { createdBy?: Partial<RelationFieldDefinition>; createdAt?: Partial<DateTimeFieldDefinition> };
-  updatable?: boolean | { updatedBy?: Partial<RelationFieldDefinition>; updatedAt?: Partial<DateTimeFieldDefinition> };
+  creatable?:
+    | boolean
+    | {
+        createdBy?: Partial<RelationFieldDefinition>;
+        createdAt?: Partial<DateTimeFieldDefinition>;
+        args?: readonly Field[];
+      };
+  updatable?:
+    | boolean
+    | {
+        updatedBy?: Partial<RelationFieldDefinition>;
+        updatedAt?: Partial<DateTimeFieldDefinition>;
+        args?: readonly Field[];
+      };
   deletable?:
     | boolean
     | {
         deleted?: Partial<BooleanFieldDefinition>;
         deletedBy?: Partial<RelationFieldDefinition>;
         deletedAt?: Partial<DateTimeFieldDefinition>;
+        args?: readonly Field[];
+        restoreArgs?: readonly Field[];
       };
   aggregatable?: boolean;
   displayField?: string;

package/src/models/mutation-hook.ts

@@ -19,6 +19,7 @@ export type MutationHook<DateType extends AnyDateType = AnyDateType> = (args: {
   trigger: Trigger;
   when: 'before' | 'after';
   data: { prev: Entity; input: Entity; normalizedInput: Entity; next: Entity };
+  args?: Record<string, unknown>;
   ctx: MutationContext<DateType>;
 }) => Promise<void> | void;
 

package/src/resolvers/mutations.ts

@@ -18,14 +18,14 @@ export const mutationResolver = async (_parent: any, args: any, partialCtx: Cont
     const [, mutation, modelName] = it(info.fieldName.match(/^(create|update|delete|restore)(.+)$/));
     switch (mutation) {
       case 'create': {
-        const id = await createEntity(modelName, args.data, ctx, 'mutation');
+        const id = await createEntity(modelName, args.data, ctx, { trigger: 'mutation', args });
 
         return await resolve(ctx, id);
       }
       case 'update': {
         const id = args.where.id;
 
-        await updateEntity(modelName, id, args.data, ctx, 'mutation');
+        await updateEntity(modelName, id, args.data, ctx, { trigger: 'mutation', args });
 
         return await resolve(ctx, id);
       }
@@ -35,6 +35,7 @@ export const mutationResolver = async (_parent: any, args: any, partialCtx: Cont
         await deleteEntity(modelName, id, ctx, {
           dryRun: args.dryRun,
           trigger: 'mutation',
+          args,
         });
 
         return id;
@@ -42,7 +43,7 @@ export const mutationResolver = async (_parent: any, args: any, partialCtx: Cont
       case 'restore': {
         const id = args.where.id;
 
-        await restoreEntity(modelName, id, ctx, 'mutation');
+        await restoreEntity(modelName, id, ctx, { trigger: 'mutation', args });
 
         return id;
       }
@@ -53,7 +54,7 @@ export const createEntity = async (
   modelName: string,
   input: Entity,
   ctx: MutationContext,
-  trigger: Trigger = 'direct-call',
+  { args, trigger = 'direct-call' }: { args?: Record<string, unknown>; trigger?: Trigger } = {},
 ) =>
   withTransaction(ctx, async (ctx) => {
     const model = ctx.models.getModel(modelName, 'entity');
@@ -81,6 +82,7 @@ export const createEntity = async (
       trigger,
       when: 'before',
       data: { prev: {}, input, normalizedInput, next: normalizedInput },
+      args,
       ctx,
     });
 
@@ -114,6 +116,7 @@ export const createEntity = async (
       trigger,
       when: 'after',
       data: { prev: {}, input, normalizedInput, next: normalizedInput },
+      args,
       ctx,
     });
 
@@ -125,11 +128,12 @@ export const updateEntities = async (
   where: Record<string, unknown>,
   updateFields: Entity,
   ctx: MutationContext,
+  { args }: { args?: Record<string, unknown> } = {},
 ) =>
   withTransaction(ctx, async (ctx) => {
     const entities = await ctx.knex(modelName).where(where).select('id');
     for (const entity of entities) {
-      await updateEntity(modelName, entity.id, updateFields, ctx);
+      await updateEntity(modelName, entity.id, updateFields, ctx, args);
     }
   });
 
@@ -138,7 +142,7 @@ export const updateEntity = async (
   id: string,
   input: Entity,
   ctx: MutationContext,
-  trigger: Trigger = 'direct-call',
+  { args, trigger = 'direct-call' }: { args?: Record<string, unknown>; trigger?: Trigger } = {},
 ) =>
   withTransaction(ctx, async (ctx) => {
     const model = ctx.models.getModel(modelName, 'entity');
@@ -164,6 +168,7 @@ export const updateEntity = async (
         trigger,
         when: 'before',
         data: { prev: currentEntity, input, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+        args,
         ctx,
       });
       await doUpdate(model, currentEntity, normalizedInput, ctx);
@@ -173,6 +178,7 @@ export const updateEntity = async (
         trigger,
         when: 'after',
         data: { prev: currentEntity, input, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+        args,
         ctx,
       });
     }
@@ -180,12 +186,18 @@ export const updateEntity = async (
 
 type Callbacks = (() => Promise<void>)[];
 
-export const deleteEntities = async (modelName: string, where: Record<string, unknown>, ctx: MutationContext) =>
+export const deleteEntities = async (
+  modelName: string,
+  where: Record<string, unknown>,
+  ctx: MutationContext,
+  args?: Record<string, unknown>,
+) =>
   withTransaction(ctx, async (ctx) => {
     const entities = await ctx.knex(modelName).where(where).select('id');
     for (const entity of entities) {
       await deleteEntity(modelName, entity.id, ctx, {
         trigger: 'direct-call',
+        args,
       });
     }
   });
@@ -197,9 +209,11 @@ export const deleteEntity = async (
   {
     dryRun = false,
     trigger = 'direct-call',
+    args,
   }: {
     dryRun?: boolean;
     trigger?: Trigger;
+    args?: Record<string, unknown>;
   } = {},
 ) =>
   withTransaction(ctx, async (ctx) => {
@@ -239,6 +253,7 @@ export const deleteEntity = async (
 
     const mutationHook = ctx.mutationHook;
     const deleteCascade = async (currentModel: EntityModel, currentEntity: Entity, currentTrigger: Trigger) => {
+      const isDeleteRoot = currentModel.name === rootModel.name && currentEntity.id === entity.id;
       if (!(currentModel.name in toDelete)) {
         toDelete[currentModel.name] = {};
       }
@@ -263,6 +278,7 @@ export const deleteEntity = async (
               trigger: currentTrigger,
               when: 'before',
               data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+              ...(isDeleteRoot ? { args } : {}),
               ctx,
             });
           });
@@ -278,6 +294,7 @@ export const deleteEntity = async (
               trigger: currentTrigger,
               when: 'after',
               data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+              ...(isDeleteRoot ? { args } : {}),
               ctx,
             });
           });
@@ -407,7 +424,12 @@ export const deleteEntity = async (
     }
   });
 
-export const restoreEntity = async (modelName: string, id: string, ctx: MutationContext, trigger: Trigger = 'direct-call') =>
+export const restoreEntity = async (
+  modelName: string,
+  id: string,
+  ctx: MutationContext,
+  { args, trigger = 'direct-call' }: { args?: Record<string, unknown>; trigger?: Trigger } = {},
+) =>
   withTransaction(ctx, async (ctx) => {
     const model = ctx.models.getModel(modelName, 'entity');
     const rootModel = model.rootModel;
@@ -433,6 +455,7 @@ export const restoreEntity = async (modelName: string, id: string, ctx: Mutation
     const afterHooks: Callbacks = [];
 
     const restoreCascade = async (currentModel: EntityModel, currentEntity: Entity, currentTrigger: Trigger) => {
+      const isRestoreRoot = currentModel.name === rootModel.name && currentEntity.id === entity.id;
       if (entity.deleteRootId || currentEntity.deleteRootId) {
         if (!(currentEntity.deleteRootType === model.name && currentEntity.deleteRootId === entity.id)) {
           return;
@@ -465,6 +488,7 @@ export const restoreEntity = async (modelName: string, id: string, ctx: Mutation
             trigger: currentTrigger,
             when: 'before',
             data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+            ...(isRestoreRoot ? { args } : {}),
             ctx,
           });
         });
@@ -496,6 +520,7 @@ export const restoreEntity = async (modelName: string, id: string, ctx: Mutation
             trigger: currentTrigger,
             when: 'after',
             data: { prev: currentEntity, input: {}, normalizedInput, next: { ...currentEntity, ...normalizedInput } },
+            ...(isRestoreRoot ? { args } : {}),
             ctx,
           });
         });

package/src/schema/generate.ts

@@ -249,6 +249,7 @@ export const generateDefinitions = ({
                 type: `Create${model.name}`,
                 nonNull: true,
               },
+              ...((model.creatable && model.creatable !== true && model.creatable.args) || []),
             ],
           });
         }
@@ -269,6 +270,7 @@ export const generateDefinitions = ({
                 type: `Update${model.name}`,
                 nonNull: true,
               },
+              ...((model.updatable && model.updatable !== true && model.updatable.args) || []),
             ],
           });
         }
@@ -288,6 +290,7 @@ export const generateDefinitions = ({
                 name: 'dryRun',
                 type: 'Boolean',
               },
+              ...((model.deletable && model.deletable !== true && model.deletable.args) || []),
             ],
           });
           mutations.push({
@@ -300,6 +303,7 @@ export const generateDefinitions = ({
                 type: `${model.name}WhereUnique`,
                 nonNull: true,
               },
+              ...((model.deletable && model.deletable !== true && model.deletable.restoreArgs) || []),
             ],
           });
         }