sasat 0.19.13 → 0.19.14

package/lib/cli/cli.js

@@ -11,6 +11,8 @@ try {
         .usage('yarn sasat <command> [options]\n')
         .command('migrate', 'execute migration')
         .option('-g, --generateFiles', 'migrate with generate files')
+        .option('-d, --dry', 'dry run')
+        .option('-s, --silent', 'do not print logs')
         .action(async (options) => {
         await migrate(options).catch(() => {
             process.exit(1);

package/lib/cli/commands/migrate.d.ts

@@ -1,3 +1,6 @@
-export declare const migrate: (options: {
-    [key: string]: boolean;
-}) => Promise<void>;
+export type MigrateCommandOption = {
+    generateFiles: boolean;
+    silent: boolean;
+    dry: boolean;
+};
+export declare const migrate: (options: MigrateCommandOption) => Promise<void>;

package/lib/cli/commands/migrate.js

@@ -8,7 +8,7 @@ export const migrate = async (options) => {
     let current;
     try {
         const migration = new MigrationController();
-        const result = await migration.migrate();
+        const result = await migration.migrate(options);
         current = result.currentMigration;
         if (options.generateFiles) {
             const storeHandler = new DataStoreHandler(result.store);

package/lib/db/getDbClient.d.ts

@@ -1,2 +1,2 @@
 import { DBClient } from './connectors/dbClient.js';
-export declare const getDbClient: (connectionOption?: Partial<import("mysql2").ConnectionOptions> | undefined, poolOption?: Partial<import("mysql2").PoolOptions> | undefined) => DBClient;
+export declare const getDbClient: (connectionOption?: Partial<import("mysql2/typings/mysql/lib/Connection.js").ConnectionOptions> | undefined, poolOption?: Partial<import("mysql2/typings/mysql/lib/Pool.js").PoolOptions> | undefined) => DBClient;

package/lib/db/sql/createTable/createTableParser.js

@@ -1,7 +1,7 @@
 import { TokenKind } from './lexer/lexer.js';
 import { camelize } from '../../../util/stringUtil.js';
 import { defaultColumnOption, } from '../../../migration/serialized/serializedColumn.js';
-import { getDefaultGqlOption } from '../../../migration/data/GQLOption.js';
+import { defaultGQLOption } from '../../../migration/data/GQLOption.js';
 import { columnTypeToGqlPrimitive } from '../../../generatorv2/scripts/columnToGqlType.js';
 const splitArray = (array, callback) => {
     const indexes = [];
@@ -56,7 +56,7 @@ export class CreateTableParser {
             primaryKey: [],
             uniqueKeys: [],
             indexes: [],
-            gqlOption: getDefaultGqlOption(),
+            gqlOption: defaultGQLOption(),
             virtualRelations: [],
         };
     }

package/lib/generatorv2/codegen/ts/generateIDEncoder.js

@@ -35,9 +35,6 @@ export const generateIDEncoder = (root, content) => {
     const makeEncoder = isImported(sourceFile, 'makeNumberIdEncoder', ['sasat'])
         ? ''
         : new ImportDeclaration(['makeNumberIdEncoder'], 'sasat').toString();
-    return (imports +
-        makeEncoder +
-        content +
-        '\n' +
-        new TsFile(...statements).toString());
+    const addition = statements.length === 0 ? '' : '\n' + new TsFile(...statements).toString();
+    return imports + makeEncoder + content + addition;
 };

package/lib/generatorv2/codegen/ts/generateMiddlewares.d.ts

@@ -0,0 +1,2 @@
+import { RootNode } from '../../nodes/rootNode.js';
+export declare const generateMiddlewares: (root: RootNode, content: string) => string | null;

package/lib/generatorv2/codegen/ts/generateMiddlewares.js

@@ -0,0 +1,45 @@
+import typescript from 'typescript';
+import { TsFile, tsg } from '../../../tsg/index.js';
+import { isImported } from './scripts/ast/isImported.js';
+import { getExportedVariables } from './scripts/ast/getExportedVariables.js';
+import { tsFileNames } from './tsFileNames.js';
+import { ImportDeclaration as TsgImport } from '../../../tsg/importDeclaration.js';
+import { unique } from '../../../runtime/util.js';
+const { createSourceFile, ScriptTarget } = typescript;
+export const generateMiddlewares = (root, content) => {
+    const middlewares = unique(root.entities.flatMap(it => [
+        ...it.queries.flatMap(it => it.middlewares),
+        ...it.mutations.flatMap(it => it.middlewares),
+    ]));
+    if (middlewares.length === 0)
+        return null;
+    const sourceFile = createSourceFile(tsFileNames.middleware + '.ts', content, ScriptTarget.ESNext);
+    const exportedVariables = getExportedVariables(sourceFile);
+    const statements = [];
+    middlewares.forEach(middleware => {
+        const exists = exportedVariables.some(it => {
+            return (it.declarationList.declarations[0].name.getText(sourceFile) ===
+                middleware);
+        });
+        if (exists)
+            return;
+        statements.push(tsg
+            .variable('const', middleware, tsg.arrowFunc([tsg.parameter('args')], undefined, tsg.block(tsg.throw(tsg.new(tsg.identifier('Error'), tsg.string('TODO: Not implemented'))), tsg.return(tsg.identifier('args')))), tsg.typeRef('ResolverMiddleware', [tsg.typeRef('GQLContext')]))
+            .export());
+    });
+    const contextImported = isImported(sourceFile, 'GQLContext', [
+        './context',
+        './context.js',
+    ]);
+    const resolverMiddlewareImported = isImported(sourceFile, 'ResolverMiddleware', ['sasat']);
+    const imports = [
+        contextImported
+            ? ''
+            : new TsgImport(['GQLContext'], './context').toString() + '\n',
+        resolverMiddlewareImported
+            ? ''
+            : new TsgImport(['ResolverMiddleware'], 'sasat').toString() + '\n',
+    ].join('');
+    const addition = statements.length === 0 ? '' : '\n' + new TsFile(...statements).toString();
+    return imports + content + addition;
+};

package/lib/generatorv2/codegen/ts/generateQueryResolver.js

@@ -78,15 +78,24 @@ const getHashIdArgs = (entity, query) => {
     })
         .filter(nonNullable);
 };
-const makeMiddlewares = (entity, query) => {
+const makeHashIdMiddleware = (entity, query) => {
     const args = getHashIdArgs(entity, query);
     if (!args || args?.length === 0)
         return null;
-    return tsg.array([
-        tsg.arrowFunc([tsg.parameter('args')], undefined, tsg.block(new RawCodeStatement(`args[1] = {...args[1], ${args
-            .map(it => `${it.name}: ${it.encoder}.decode(args[1].${it.name} as string),`)
-            .join('')}};`).addImport(args.map(it => it.encoder), Directory.resolve(DIR, 'BASE', tsFileNames.encoder)), tsg.return(tsg.identifier('args')))),
-    ]);
+    return tsg.arrowFunc([tsg.parameter('args')], undefined, tsg.block(new RawCodeStatement(`args[1] = {...args[1], ${args
+        .map(it => `${it.name}: ${it.encoder}.decode(args[1].${it.name} as string),`)
+        .join('')}};`).addImport(args.map(it => it.encoder), Directory.resolve(DIR, 'BASE', tsFileNames.encoder)), tsg.return(tsg.identifier('args'))));
+};
+const makeMiddlewares = (entity, query) => {
+    const hashId = makeHashIdMiddleware(entity, query);
+    if (!hashId && query.middlewares.length === 0)
+        return null;
+    if (query.middlewares.length === 0)
+        return tsg.array([hashId]);
+    const middlewares = query.middlewares.map(it => tsg.identifier(it).importFrom('../' + tsFileNames.middleware));
+    if (!hashId)
+        return tsg.array(middlewares);
+    return tsg.array([hashId, ...middlewares]);
 };
 const makeTypeArgs = (args) => {
     let hashIds = false;

package/lib/generatorv2/codegen/ts/generateUserDefinedCondition.js

@@ -44,5 +44,6 @@ export const generateUserDefinedCondition = (root, content) => {
     const condition = customConditionImported
         ? ''
         : new TsgImport(['CustomCondition'], 'sasat').toString() + '\n';
-    return (context + condition + content + '\n' + new TsFile(...statements).toString());
+    const addition = statements.length === 0 ? '' : '\n' + new TsFile(...statements).toString();
+    return context + condition + content + addition;
 };

package/lib/generatorv2/codegen/ts/mutation/makeMutationInputDecoder.js

@@ -40,7 +40,7 @@ const makeResolverMiddleware = (typeName, entity, fields, node) => {
     if (!node.requireIdDecodeMiddleware)
         return [
             requiredType,
-            tsg.variable('const', middlewareName, tsg.array([]), tsg.arrayType(tsg
+            tsg.variable('const', middlewareName, tsg.array(node.middlewares.map(it => tsg.identifier(it).importFrom('../' + tsFileNames.middleware))), tsg.arrayType(tsg
                 .typeRef('ResolverMiddleware', [
                 makeContextTypeRef(DIR),
                 tsg.identifier(typeName),
@@ -50,7 +50,10 @@ const makeResolverMiddleware = (typeName, entity, fields, node) => {
     const incomingType = tsg.typeAlias('GQL' + typeName, tsg.typeLiteral([
         tsg.propertySignature(entity.name.lowerCase(), tsg.typeLiteral(sig)),
     ]));
-    const middleware = tsg.variable('const', node.mutationName + 'Middleware', tsg.array([makeIdDecodeMiddleware(fields, node)]), tsg.arrayType(tsg
+    const middleware = tsg.variable('const', node.mutationName + 'Middleware', tsg.array([
+        makeIdDecodeMiddleware(fields, node),
+        ...node.middlewares.map(it => tsg.identifier(it).importFrom('../' + tsFileNames.middleware)),
+    ]), tsg.arrayType(tsg
         .typeRef('ResolverMiddleware', [
         makeContextTypeRef(DIR),
         tsg.identifier(typeName),

package/lib/generatorv2/codegen/ts/tsFileNames.d.ts

@@ -1,4 +1,5 @@
 export declare const tsFileNames: {
     encoder: string;
     conditions: string;
+    middleware: string;
 };

package/lib/generatorv2/codegen/ts/tsFileNames.js

@@ -1,4 +1,5 @@
 export const tsFileNames = {
     encoder: 'idEncoder',
     conditions: 'conditions',
+    middleware: 'middlewares',
 };

package/lib/generatorv2/codegen/tscodegen_v2.d.ts

@@ -19,4 +19,5 @@ export declare class TsCodegen_v2 {
     generateOnceFiles: () => FileData[];
     generateConditions: (root: RootNode, currentFile: string) => string | null;
     generateIDEncoders: (root: RootNode, currentFile: string) => string | null;
+    generateMiddlewares: (root: RootNode, currentFile: string) => string | null;
 }

package/lib/generatorv2/codegen/tscodegen_v2.js

@@ -12,6 +12,7 @@ import { generateContext } from './ts/generateContext.js';
 import { generateSubscription } from './ts/generateSubscription.js';
 import { generateUserDefinedCondition } from './ts/generateUserDefinedCondition.js';
 import { generateIDEncoder } from './ts/generateIDEncoder.js';
+import { generateMiddlewares } from './ts/generateMiddlewares.js';
 export class TsCodegen_v2 {
     constructor() {
         this.fileExtension = 'ts';
@@ -42,5 +43,8 @@ export class TsCodegen_v2 {
         this.generateIDEncoders = (root, currentFile) => {
             return generateIDEncoder(root, currentFile);
         };
+        this.generateMiddlewares = (root, currentFile) => {
+            return generateMiddlewares(root, currentFile);
+        };
     }
 }

package/lib/generatorv2/codegen_v2.d.ts

@@ -19,4 +19,5 @@ export declare class CodeGen_v2 {
     private generateOnceFiles;
     private generateCondition;
     private generateIDEncoders;
+    private generateMiddleware;
 }

package/lib/generatorv2/codegen_v2.js

@@ -28,6 +28,7 @@ export class CodeGen_v2 {
             ...this.generateOnceFiles(),
             this.generateCondition(this.root),
             this.generateIDEncoders(this.root),
+            this.generateMiddleware(this.root),
         ]);
     }
     async prepareDirs() {
@@ -87,4 +88,13 @@ export class CodeGen_v2 {
         if (nextContent)
             fs.writeFileSync(filePath, nextContent);
     }
+    async generateMiddleware(rootNode) {
+        const filePath = this.getFullPath(this.outDir, tsFileNames.middleware);
+        const content = fs.existsSync(filePath)
+            ? fs.readFileSync(filePath).toString()
+            : '';
+        const nextContent = this.codeGen.generateMiddlewares(rootNode, content);
+        if (nextContent)
+            fs.writeFileSync(filePath, nextContent);
+    }
 }

package/lib/generatorv2/nodes/entityNode.js

@@ -32,7 +32,7 @@ const makeFieldNode = (store, entity, column) => {
         isNullable: column.isNullable(),
         isUpdatable: !(column.data.onUpdateCurrentTimeStamp || column.isPrimary()) &&
             column.data.option.updatable,
-        isGQLOpen: !column.table.gqlOption.mutation.fromContextColumns.some(it => it.column === column.columnName()),
+        isGQLOpen: true,
         column: column.data,
         option: column.data.option,
         hashId,
@@ -53,7 +53,8 @@ const makeCreatableFieldNode = (store, entity, column) => {
         isPrimary: column.isPrimary(),
         isNullable: column.isNullableOnCreate(),
         isUpdatable: column.isUpdatable(),
-        isGQLOpen: !column.table.gqlOption.mutation.fromContextColumns.some(it => it.column === column.columnName()),
+        isGQLOpen: !(column.table.gqlOption.mutations.find(it => it.type === 'create')
+            ?.contextFields || []).some(it => it.column === column.columnName()),
         column: column.data,
         option: column.data.option,
         hashId: getHashId(store, entity.name, column),
@@ -74,7 +75,8 @@ const makeUpdatableFieldNode = (store, entity, column) => {
         isNullable: true,
         isPrimary: false,
         isUpdatable: true,
-        isGQLOpen: !column.table.gqlOption.mutation.fromContextColumns.some(it => it.column === column.columnName()),
+        isGQLOpen: !(column.table.gqlOption.mutations.find(it => it.type === 'update')
+            ?.contextFields || []).some(it => it.column === column.columnName()),
         column: column.data,
         option: column.data.option,
         hashId: getHashId(store, entity.name, column),
@@ -89,13 +91,17 @@ export class EntityNode {
         this.identifyKeys = table.primaryKey;
         this.queries = table.gqlOption.queries;
         this.creatable = {
-            gqlEnabled: table.gqlOption.enabled && table.gqlOption.mutation.create.enabled,
+            gqlEnabled: table.gqlOption.enabled &&
+                table.gqlOption.mutations.find(it => it.type === 'create') !==
+                    undefined,
             fields: table.columns
                 .map(it => makeCreatableFieldNode(store, this, it))
                 .filter(nonNullable),
         };
         this.updateInput = {
-            gqlEnabled: table.gqlOption.enabled && table.gqlOption.mutation.update.enabled,
+            gqlEnabled: table.gqlOption.enabled &&
+                table.gqlOption.mutations.find(it => it.type === 'update') !==
+                    undefined,
             fields: [
                 ...this.fields.filter(it => it.isPrimary),
                 ...table.columns

package/lib/generatorv2/nodes/mutationNode.d.ts

@@ -19,4 +19,5 @@ export type MutationNode = {
     refetch: boolean;
     contextFields: ContextField[];
     requireIdDecodeMiddleware: boolean;
+    middlewares: string[];
 };

package/lib/generatorv2/parser/makeContextNodes.js

@@ -1,8 +1,8 @@
 export const makeContextNodes = (store) => {
     return store.tables.flatMap(table => {
-        return table.gqlOption.mutation.fromContextColumns.map(it => ({
+        return table.gqlOption.mutations.flatMap(mutation => mutation.contextFields.map(it => ({
             name: it.contextName || it.column,
             dbtype: table.column(it.column).dataType(),
-        }));
+        })));
     });
 };

package/lib/generatorv2/parser/makeMutationNodes.js

@@ -1,29 +1,31 @@
 import { DBColumnTypes } from '../../migration/column/columnTypes.js';
 export const makeEntityMutationNodes = (table, entity) => {
-    const result = [];
     if (!table.gqlOption.enabled)
         return [];
-    if (table.gqlOption.mutation.create.enabled)
-        result.push(makeCreateMutationNode(table, entity));
-    if (table.gqlOption.mutation.update.enabled)
-        result.push(makeUpdateMutationNode(table, entity));
-    if (table.gqlOption.mutation.delete.enabled)
-        result.push(makeDeleteMutationNode(table, entity));
-    return result;
+    return table.gqlOption.mutations.map(mutation => {
+        switch (mutation.type) {
+            case 'create':
+                return makeCreateMutationNode(table, entity, mutation);
+            case 'update':
+                return makeUpdateMutationNode(table, entity, mutation);
+            case 'delete':
+                return makeDeleteMutationNode(table, entity, mutation);
+        }
+    });
 };
 const makeContextField = (params) => ({
     fieldName: params.column,
     contextName: params.contextName || params.column,
 });
-const makeCreateMutationNode = (table, entity) => {
+const makeCreateMutationNode = (table, entity, mutation) => {
     return {
         entity,
-        contextFields: table.gqlOption.mutation.fromContextColumns.map(makeContextField),
+        contextFields: mutation.contextFields.map(makeContextField),
         entityName: table.getEntityName(),
         identifyFields: table.getPrimaryKeyColumns().map(it => it.fieldName()),
         mutationName: `create${table.getEntityName().name}`,
         inputName: entity.name.createInputName(),
-        refetch: !table.gqlOption.mutation.create.noReFetch,
+        refetch: !mutation.noReFetch,
         returnType: {
             typeName: table.getEntityName().name,
             nullable: false,
@@ -42,28 +44,28 @@ const makeCreateMutationNode = (table, entity) => {
             },
         ],
         mutationType: 'create',
-        subscription: table.gqlOption.mutation.create.subscription,
+        subscription: mutation.subscription.enabled,
         requireIdDecodeMiddleware: entity.creatable.fields.some(it => it.hashId),
+        middlewares: mutation.middlewares,
     };
 };
-const makeUpdateMutationNode = (table, entity) => {
-    const noRefetch = table.gqlOption.mutation.update.noReFetch;
+const makeUpdateMutationNode = (table, entity, mutation) => {
     return {
         entity,
-        contextFields: table.gqlOption.mutation.fromContextColumns.map(makeContextField),
+        contextFields: mutation.contextFields.map(makeContextField),
         entityName: table.getEntityName(),
         identifyFields: table.getPrimaryKeyColumns().map(it => it.fieldName()),
         mutationName: `update${table.getEntityName().name}`,
         inputName: entity.name.updateInputName(),
-        refetch: !table.gqlOption.mutation.update.noReFetch,
+        refetch: !mutation.noReFetch,
         returnType: {
-            typeName: noRefetch ? 'Boolean' : table.getEntityName().name,
-            dbType: noRefetch
+            typeName: mutation.noReFetch ? 'Boolean' : table.getEntityName().name,
+            dbType: mutation.noReFetch
                 ? DBColumnTypes.boolean
                 : undefined,
             nullable: false,
             array: false,
-            entity: !noRefetch,
+            entity: !mutation.noReFetch,
         },
         args: [
             {
@@ -77,16 +79,17 @@ const makeUpdateMutationNode = (table, entity) => {
             },
         ],
         mutationType: 'update',
-        subscription: table.gqlOption.mutation.update.subscription,
+        subscription: mutation.subscription.enabled,
         requireIdDecodeMiddleware: entity.updateInput.fields.some(it => it.hashId),
+        middlewares: mutation.middlewares,
     };
 };
-const makeDeleteMutationNode = (table, entity) => {
+const makeDeleteMutationNode = (table, entity, mutation) => {
     return {
         entity,
         mutationName: `delete${table.getEntityName().name}`,
         inputName: entity.name.identifyInputName(),
-        contextFields: table.gqlOption.mutation.fromContextColumns.map(makeContextField),
+        contextFields: mutation.contextFields.map(makeContextField),
         entityName: table.getEntityName(),
         identifyFields: table.getPrimaryKeyColumns().map(it => it.fieldName()),
         refetch: false,
@@ -109,7 +112,8 @@ const makeDeleteMutationNode = (table, entity) => {
             },
         ],
         mutationType: 'delete',
-        subscription: table.gqlOption.mutation.update.subscription,
+        subscription: mutation.subscription.enabled,
         requireIdDecodeMiddleware: entity.identifyFields().some(it => it.hashId),
+        middlewares: mutation.middlewares,
     };
 };

package/lib/generatorv2/parser/makeSubscriptionNode.js

@@ -2,18 +2,9 @@ import { nonNullable } from '../../runtime/util.js';
 export const makeSubscriptionNodes = (store) => {
     return store.tables
         .flatMap(table => {
-        const mutation = table.gqlOption.mutation;
-        return [
-            mutation.create.subscription
-                ? makeSubscriptionNode('create', table)
-                : undefined,
-            mutation.update.subscription
-                ? makeSubscriptionNode('update', table)
-                : undefined,
-            mutation.delete.subscription
-                ? makeSubscriptionNode('delete', table)
-                : undefined,
-        ];
+        return table.gqlOption.mutations.map(it => {
+            return makeSubscriptionNode(table, it);
+        });
     })
         .filter(nonNullable);
 };
@@ -22,9 +13,10 @@ const subscriptionNamePostfix = {
     update: 'Updated',
     delete: 'Deleted',
 };
-const makeSubscriptionNode = (mutationType, table) => {
-    const subscriptionName = table.getEntityName().name + subscriptionNamePostfix[mutationType];
-    const option = table.gqlOption.mutation[mutationType];
+const makeSubscriptionNode = (table, mutation) => {
+    if (!mutation.subscription.enabled)
+        return null;
+    const subscriptionName = table.getEntityName().name + subscriptionNamePostfix[mutation.type];
     return {
         subscriptionName,
         entity: table.getEntityName(),
@@ -35,7 +27,7 @@ const makeSubscriptionNode = (mutationType, table) => {
             array: false,
             entity: true,
         },
-        args: table.gqlOption.mutation[mutationType].subscriptionFilter.map(it => {
+        args: mutation.subscription.subscriptionFilter.map(it => {
             const column = table.column(it);
             return {
                 name: it,
@@ -48,14 +40,14 @@ const makeSubscriptionNode = (mutationType, table) => {
                 },
             };
         }),
-        filters: option.subscriptionFilter.map(it => {
+        filters: (mutation.subscription?.subscriptionFilter || []).map(it => {
             const column = table.column(it);
             return {
                 field: column.fieldName(),
                 gqlType: column.gqlType(),
             };
         }),
-        mutationType,
-        gqlEnabled: table.gqlOption.enabled && option.enabled,
+        mutationType: mutation.type,
+        gqlEnabled: table.gqlOption.enabled && mutation.subscription.enabled,
     };
 };

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export { ResolverMiddleware } from './runtime/resolverMiddleware.js';
 export { makeNumberIdEncoder } from './runtime/id.js';
 export type { CustomCondition } from './runtime/types.js';
 export { Queries } from './migration/makeQuery.js';
+export { Mutations } from './migration/makeMutaion.js';
 export { Conditions } from './migration/makeCondition.js';
 export type { BooleanValueExpression, Query, LockMode, } from './runtime/dsl/query/query.js';
 export type { Relation } from './migration/data/relation.js';

package/lib/index.js

@@ -1,5 +1,6 @@
 export { makeNumberIdEncoder } from './runtime/id.js';
 export { Queries } from './migration/makeQuery.js';
+export { Mutations } from './migration/makeMutaion.js';
 export { Conditions } from './migration/makeCondition.js';
 export { QExpr } from './runtime/dsl/factory.js';
 export { gqlResolveInfoToField } from './runtime/gqlResolveInfoToField.js';

package/lib/migration/controller.d.ts

@@ -1,6 +1,7 @@
 import { SerializedStore } from './serialized/serializedStore.js';
+import { MigrateCommandOption } from '../cli/commands/migrate.js';
 export declare class MigrationController {
-    migrate(): Promise<{
+    migrate(options: MigrateCommandOption): Promise<{
         store: SerializedStore;
         currentMigration: string;
     }>;

package/lib/migration/controller.js

@@ -5,15 +5,19 @@ import { readMigration } from './exec/readMigrationFile.js';
 import { runMigration } from './exec/runMigration.js';
 import { getMigrationTargets } from './exec/getMigrationTarget.js';
 import { createCurrentMigrationDataStore } from './exec/createCurrentMigrationDataStore.js';
+import { Console } from '../cli/console.js';
 export class MigrationController {
-    async migrate() {
+    async migrate(options) {
         const fileNames = await compileMigrationFiles();
         const currentMigration = await getCurrentMigration();
         let store = await createCurrentMigrationDataStore(currentMigration);
         const target = getMigrationTargets(fileNames, currentMigration);
         for (const tsFileName of target.files) {
+            if (!options.silent) {
+                Console.log('---------\n' + tsFileName);
+            }
             store = await readMigration(store, tsFileName, target.direction);
-            await runMigration(store, tsFileName, target.direction);
+            await runMigration(store, tsFileName, target.direction, options);
             store.resetQueue();
         }
         return {

package/lib/migration/creators/tableCreator.d.ts

@@ -2,7 +2,7 @@ import { ColumnCreator } from './columnCreator.js';
 import { ColumnBuilderBase, ReferenceColumnBuilder } from './columnBuilder.js';
 import { Reference } from '../serialized/serializedColumn.js';
 import { TableHandler } from '../serializable/table.js';
-import { GqlFromContextParam, GQLOption, GQLQuery, MutationOption } from '../data/GQLOption.js';
+import { GQLMutation, GQLOption, GQLQuery } from '../data/GQLOption.js';
 import { DataStore } from '../dataStore.js';
 import { VirtualRelation } from '../data/virtualRelation.js';
 export interface TableBuilder {
@@ -18,13 +18,10 @@ export interface TableBuilder {
     createdAt(): TableBuilder;
     updatedAt(): TableBuilder;
     addIndex(...columns: string[]): TableBuilder;
-    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;
-    setGQLContextColumn(columns: GqlFromContextParam[]): TableBuilder;
     enableGQL(): TableBuilder;
     setGQLOption(option: Partial<GQLOption>): TableBuilder;
-    addQuery(query: GQLQuery): TableBuilder;
+    addGQLQuery(...query: GQLQuery[]): TableBuilder;
+    addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
 }
 export declare class TableCreator implements TableBuilder {
     tableName: string;
@@ -48,9 +45,6 @@ export declare class TableCreator implements TableBuilder {
     addIndex(...columns: string[]): TableBuilder;
     enableGQL(): TableBuilder;
     setGQLOption(option: Partial<GQLOption>): TableBuilder;
-    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;
-    setGQLContextColumn(columns: GqlFromContextParam[]): TableBuilder;
-    addQuery(query: GQLQuery): TableBuilder;
+    addGQLQuery(...query: GQLQuery[]): TableBuilder;
+    addGQLMutation(...mutation: GQLMutation[]): TableBuilder;
 }

package/lib/migration/creators/tableCreator.js

@@ -79,25 +79,15 @@ export class TableCreator {
         this.table.setGQLOption(option);
         return this;
     }
-    setGQLCreate(enabled, options) {
-        this.table.setGQLCreate(enabled, options);
-        return this;
-    }
-    setGQLUpdate(enabled, options) {
-        this.table.setGQLUpdate(enabled, options);
-        return this;
-    }
-    setGQLDelete(enabled, options) {
-        this.table.setGQLDelete(enabled, options);
-        return this;
-    }
-    setGQLContextColumn(columns) {
-        this.table.setGQLContextColumn(columns);
+    addGQLQuery(...query) {
+        this.table.setGQLOption({
+            queries: [...this.table.gqlOption.queries, ...query],
+        });
         return this;
     }
-    addQuery(query) {
+    addGQLMutation(...mutation) {
         this.table.setGQLOption({
-            queries: [...this.table.gqlOption.queries, query],
+            mutations: [...this.table.gqlOption.mutations, ...mutation],
         });
         return this;
     }