sasat 0.19.13 → 0.19.14

package/lib/migration/data/GQLOption.d.ts

@@ -4,40 +4,36 @@ export interface GqlFromContextParam {
     column: string;
     contextName?: string;
 }
-type Enabled = {
-    enabled: boolean;
-};
 export type MutationOption = {
     noReFetch: boolean;
     subscription: boolean;
     subscriptionFilter: string[];
 };
+export type GQLMutation = {
+    type: 'create' | 'update' | 'delete';
+    noReFetch: boolean;
+    middlewares: string[];
+    contextFields: GqlFromContextParam[];
+    subscription: {
+        enabled: boolean;
+        subscriptionFilter: string[];
+    };
+};
 export type GQLQuery = {
     type: 'single' | 'list-all' | 'list-paging';
     name: string;
     conditions: QueryConditionNode[];
+    middlewares: string[];
 } | {
     type: 'primary';
     name?: never;
     conditions: never[];
+    middlewares: string[];
 };
 export interface GQLOption {
     enabled: boolean;
     queries: GQLQuery[];
-    mutation: {
-        create: MutationOption & Enabled;
-        update: MutationOption & Enabled;
-        delete: Omit<MutationOption, 'noReFetch'> & Enabled;
-        fromContextColumns: GqlFromContextParam[];
-    };
+    mutations: GQLMutation[];
 }
-export declare const defaultMutationOption: {
-    enabled: boolean;
-    noReFetch: boolean;
-    subscription: boolean;
-    subscriptionFilter: never[];
-};
-export declare const getDefaultGqlOption: () => GQLOption;
-export declare const updateMutationOption: (option: GQLOption, mutation: Partial<GQLOption['mutation']>) => GQLOption;
+export declare const defaultGQLOption: () => GQLOption;
 export declare const getArgs: (query: GQLQuery, entity: EntityNode) => ArgQueryConditionValue[];
-export {};

package/lib/migration/data/GQLOption.js

@@ -1,28 +1,8 @@
-export const defaultMutationOption = {
-    enabled: false,
-    noReFetch: false,
-    subscription: false,
-    subscriptionFilter: [],
-};
-export const getDefaultGqlOption = () => ({
+export const defaultGQLOption = () => ({
     enabled: false,
     queries: [],
-    mutation: {
-        create: defaultMutationOption,
-        update: defaultMutationOption,
-        delete: defaultMutationOption,
-        fromContextColumns: [],
-    },
+    mutations: [],
 });
-export const updateMutationOption = (option, mutation) => {
-    return {
-        ...option,
-        mutation: {
-            ...option.mutation,
-            ...mutation,
-        },
-    };
-};
 export const getArgs = (query, entity) => {
     if (query.type === 'primary')
         return entity.fields

package/lib/migration/exec/runMigration.d.ts

@@ -1,3 +1,4 @@
 import { StoreMigrator } from '../front/storeMigrator.js';
 import { Direction } from './getCurrentMigration.js';
-export declare const runMigration: (store: StoreMigrator, migrationName: string, direction: Direction) => Promise<void>;
+import { MigrateCommandOption } from '../../cli/commands/migrate.js';
+export declare const runMigration: (store: StoreMigrator, migrationName: string, direction: Direction, options: MigrateCommandOption) => Promise<void>;

package/lib/migration/exec/runMigration.js

@@ -1,9 +1,15 @@
 import { getDbClient } from '../../db/getDbClient.js';
 import { Console } from '../../cli/console.js';
 import { config } from '../../config/config.js';
-export const runMigration = async (store, migrationName, direction) => {
+export const runMigration = async (store, migrationName, direction, options) => {
     const sqls = store.getSql();
     store.resetQueue();
+    if (!options.silent) {
+        sqls.forEach(Console.log);
+    }
+    if (options.dry) {
+        return;
+    }
     const transaction = await getDbClient().transaction();
     try {
         for (const sql of sqls) {

package/lib/migration/front/tableMigrator.d.ts

@@ -1,7 +1,7 @@
 import { StoreMigrator } from './storeMigrator.js';
 import { Table, TableHandler } from '../serializable/table.js';
 import { Reference, SerializedColumn, SerializedNormalColumn } from '../serialized/serializedColumn.js';
-import { GqlFromContextParam, GQLOption, MutationOption } from '../data/GQLOption.js';
+import { GQLMutation, GQLOption, GQLQuery } from '../data/GQLOption.js';
 import { BaseColumn } from '../serializable/column.js';
 import { SerializedTable } from '../serialized/serializedStore.js';
 import { DBType } from '../column/columnTypes.js';
@@ -14,12 +14,10 @@ export interface MigrationTable extends Table {
     addForeignKey(reference: Reference): MigrationTable;
     changeColumnType(columnName: string, type: DBType): MigrationTable;
     setDefault(columnName: string, value: string | number | null): MigrationTable;
-    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
-    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
-    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): MigrationTable;
-    setGQLContextColumn(columns: GqlFromContextParam[]): MigrationTable;
     enableGQL(): MigrationTable;
     setGQLOption(option: GQLOption): MigrationTable;
+    addGQLQuery(...queries: GQLQuery[]): MigrationTable;
+    addGQLMutation(...mutations: GQLMutation[]): MigrationTable;
 }
 export declare class TableMigrator implements MigrationTable {
     private table;
@@ -36,15 +34,13 @@ export declare class TableMigrator implements MigrationTable {
     removeIndex(...columns: string[]): MigrationTable;
     addColumn(column: SerializedNormalColumn): MigrationTable;
     dropColumn(columnName: string): MigrationTable;
-    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
-    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
     enableGQL(): MigrationTable;
     setGQLOption(option: GQLOption): MigrationTable;
-    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): MigrationTable;
-    setGQLContextColumn(columns: GqlFromContextParam[]): MigrationTable;
     addForeignKey(reference: Reference): MigrationTable;
     changeColumnType(columnName: string, type: DBType): MigrationTable;
     protected tableExists(tableName: string): true;
     setDefault(columnName: string, value: string | number | null): MigrationTable;
     get gqlOption(): GQLOption;
+    addGQLQuery(...queries: GQLQuery[]): MigrationTable;
+    addGQLMutation(...mutations: GQLMutation[]): MigrationTable;
 }

package/lib/migration/front/tableMigrator.js

@@ -51,14 +51,6 @@ export class TableMigrator {
         this.store.addQuery(SqlCreator.dropColumn(this.tableName, columnName));
         return this;
     }
-    setGQLCreate(enabled, options) {
-        this.table.setGQLCreate(enabled, options);
-        return this;
-    }
-    setGQLUpdate(enabled, options) {
-        this.table.setGQLUpdate(enabled, options);
-        return this;
-    }
     enableGQL() {
         this.table.setGQLOption({
             ...this.table.gqlOption,
@@ -70,14 +62,6 @@ export class TableMigrator {
         this.table.setGQLOption(option);
         return this;
     }
-    setGQLDelete(enabled, options) {
-        this.table.setGQLDelete(enabled, options);
-        return this;
-    }
-    setGQLContextColumn(columns) {
-        this.table.setGQLContextColumn(columns);
-        return this;
-    }
     addForeignKey(reference) {
         this.tableExists(reference.parentTable);
         this.table.addForeignKey(reference);
@@ -116,4 +100,18 @@ export class TableMigrator {
     get gqlOption() {
         return this.table.gqlOption;
     }
+    addGQLQuery(...queries) {
+        this.table.setGQLOption({
+            ...this.table.gqlOption,
+            queries: [...this.table.gqlOption.queries, ...queries],
+        });
+        return this;
+    }
+    addGQLMutation(...mutations) {
+        this.table.setGQLOption({
+            ...this.table.gqlOption,
+            mutations: [...this.table.gqlOption.mutations, ...mutations],
+        });
+        return this;
+    }
 }

package/lib/migration/makeMutaion.d.ts

@@ -0,0 +1,16 @@
+import { GqlFromContextParam, GQLMutation } from './data/GQLOption.js';
+type Option = {
+    noRefetch?: boolean;
+    middlewares?: string[];
+    contextFields?: GqlFromContextParam[];
+    subscription?: {
+        enabled: boolean;
+        subscriptionFilter?: string[];
+    } | boolean;
+};
+export declare const Mutations: {
+    create: (options?: Option) => GQLMutation;
+    update: (options?: Option) => GQLMutation;
+    delete: (options?: Omit<Option, 'noRefetch'>) => GQLMutation;
+};
+export {};

package/lib/migration/makeMutaion.js

@@ -0,0 +1,29 @@
+const formatSubscription = (subscription) => {
+    if (subscription === undefined || subscription === false) {
+        return {
+            enabled: false,
+            subscriptionFilter: [],
+        };
+    }
+    if (subscription === true)
+        return {
+            enabled: true,
+            subscriptionFilter: [],
+        };
+    return {
+        enabled: subscription.enabled,
+        subscriptionFilter: subscription.subscriptionFilter || [],
+    };
+};
+const formatOptions = (type, option) => ({
+    type,
+    noReFetch: option?.noRefetch || false,
+    middlewares: option?.middlewares || [],
+    contextFields: option?.contextFields || [],
+    subscription: formatSubscription(option?.subscription),
+});
+export const Mutations = {
+    create: (options) => formatOptions('create', options),
+    update: (options) => formatOptions('update', options),
+    delete: (options) => formatOptions('delete', options),
+};

package/lib/migration/makeQuery.d.ts

@@ -1,8 +1,17 @@
 import { QueryConditionNode } from '../generatorv2/nodes/QueryConditionNode.js';
 import { GQLQuery } from './data/GQLOption.js';
 export declare const Queries: {
-    single: (name: string, conditions?: QueryConditionNode[]) => GQLQuery;
-    listAll: (name: string, conditions?: QueryConditionNode[]) => GQLQuery;
-    paging: (name: string, conditions?: QueryConditionNode[]) => GQLQuery;
-    primary: GQLQuery;
+    single: (name: string, options?: {
+        conditions?: QueryConditionNode[];
+        middlewares?: string[];
+    }) => GQLQuery;
+    listAll: (name: string, options?: {
+        conditions?: QueryConditionNode[];
+        middlewares?: string[];
+    }) => GQLQuery;
+    paging: (name: string, options?: {
+        conditions?: QueryConditionNode[];
+        middlewares?: string[];
+    }) => GQLQuery;
+    primary: (middlewares?: string[]) => GQLQuery;
 };

package/lib/migration/makeQuery.js

@@ -1,25 +1,29 @@
-const single = (name, conditions) => ({
+const single = (name, options) => ({
     type: 'single',
     name,
-    conditions: conditions || [],
+    conditions: options?.conditions || [],
+    middlewares: options?.middlewares || [],
 });
-const listAll = (name, conditions) => ({
+const listAll = (name, options) => ({
     type: 'list-all',
     name,
-    conditions: conditions || [],
+    conditions: options?.conditions || [],
+    middlewares: options?.middlewares || [],
 });
-const paging = (name, conditions) => ({
+const paging = (name, options) => ({
     type: 'list-paging',
     name,
-    conditions: conditions || [],
+    conditions: options?.conditions || [],
+    middlewares: options?.middlewares || [],
 });
-const primary = () => ({
+const primary = (middlewares = []) => ({
     type: 'primary',
     conditions: [],
+    middlewares,
 });
 export const Queries = {
     single,
     listAll,
     paging,
-    primary: primary(),
+    primary,
 };

package/lib/migration/serializable/table.d.ts

@@ -3,7 +3,7 @@ import { SerializedTable } from '../serialized/serializedStore.js';
 import { BaseColumn, ReferenceColumn } from './column.js';
 import { Reference, SerializedColumn } from '../serialized/serializedColumn.js';
 import { DBIndex } from '../data/index.js';
-import { GqlFromContextParam, GQLOption, MutationOption } from '../data/GQLOption.js';
+import { GQLOption } from '../data/GQLOption.js';
 import { EntityName } from '../../generatorv2/nodes/entityName.js';
 import { DataStore } from '../dataStore.js';
 import { DBColumnTypes } from '../column/columnTypes.js';
@@ -43,11 +43,7 @@ export declare class TableHandler implements Table {
     hasColumn(columnName: string): boolean;
     isColumnPrimary(columnName: string): boolean;
     getEntityName(): EntityName;
-    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): void;
-    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): void;
     setGQLOption(option: Partial<GQLOption>): void;
-    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): void;
-    setGQLContextColumn(columns: GqlFromContextParam[]): void;
     getReferenceColumns(): ReferenceColumn[];
     addForeignKey(reference: Reference): void;
     changeType(columnName: string, type: DBColumnTypes): void;

package/lib/migration/serializable/table.js

@@ -3,7 +3,7 @@ import { SqlString } from '../../runtime/sql/sqlString.js';
 import { SasatError } from '../../error.js';
 import { referenceToSql, } from '../serialized/serializedColumn.js';
 import { DBIndex } from '../data/index.js';
-import { defaultMutationOption, getDefaultGqlOption, updateMutationOption, } from '../data/GQLOption.js';
+import { defaultGQLOption } from '../data/GQLOption.js';
 import { assembleColumn } from '../functions/assembleColumn.js';
 import { EntityName } from '../../generatorv2/nodes/entityName.js';
 export class TableHandler {
@@ -24,13 +24,13 @@ export class TableHandler {
     }
     constructor(table, store) {
         this.store = store;
-        this._gqlOption = getDefaultGqlOption();
+        this._gqlOption = defaultGQLOption();
         this.tableName = table.tableName;
         this.primaryKey = table.primaryKey || [];
         this.uniqueKeys = table.uniqueKeys || [];
         this.indexes =
             table.indexes?.map(it => new DBIndex(this.tableName, it.columns)) || [];
-        this._gqlOption = table.gqlOption || getDefaultGqlOption();
+        this._gqlOption = table.gqlOption || defaultGQLOption();
         this._columns = (table.columns || []).map(it => assembleColumn(it, this));
         this._virtualRelations = table.virtualRelations || [];
     }
@@ -133,41 +133,9 @@ export class TableHandler {
     getEntityName() {
         return EntityName.fromTableName(this.tableName);
     }
-    setGQLCreate(enabled, options) {
-        this._gqlOption = updateMutationOption(this._gqlOption, {
-            create: {
-                ...defaultMutationOption,
-                ...(options || defaultMutationOption),
-                enabled,
-            },
-        });
-    }
-    setGQLUpdate(enabled, options) {
-        this._gqlOption = updateMutationOption(this._gqlOption, {
-            update: {
-                ...defaultMutationOption,
-                ...(options || defaultMutationOption),
-                enabled,
-            },
-        });
-    }
     setGQLOption(option) {
         this._gqlOption = { ...this.gqlOption, ...option };
     }
-    setGQLDelete(enabled, options) {
-        this._gqlOption = updateMutationOption(this._gqlOption, {
-            delete: {
-                ...defaultMutationOption,
-                ...(options || defaultMutationOption),
-                enabled,
-            },
-        });
-    }
-    setGQLContextColumn(columns) {
-        this._gqlOption = updateMutationOption(this._gqlOption, {
-            fromContextColumns: columns,
-        });
-    }
     getReferenceColumns() {
         return this.columns.filter(it => it.isReference());
     }

package/lib/runtime/resolverMiddleware.d.ts

@@ -1,2 +1,2 @@
 import { ResolverArgs } from './makeResolver.js';
-export type ResolverMiddleware<Context, RequiredParams = unknown, IncomingParams = RequiredParams> = (args: ResolverArgs<Context, IncomingParams | RequiredParams>) => ResolverArgs<Context, RequiredParams | IncomingParams>;
+export type ResolverMiddleware<Context, RequiredParams = any, IncomingParams = RequiredParams> = (args: ResolverArgs<Context, IncomingParams | RequiredParams>) => ResolverArgs<Context, RequiredParams | IncomingParams>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasat",
-  "version": "0.19.13",
+  "version": "0.19.14",
   "repository": "https://github.com/nin138/sasat.git",
   "author": "nin138 <ninian138@gmail.com>",
   "license": "MIT",
@@ -35,31 +35,31 @@
     "graphql-subscriptions": "^2.0.0",
     "hashids": "^2.2.10",
     "js-yaml": "^4.1.0",
-    "mysql2": "^2.3.3",
+    "mysql2": "^3.1.2",
     "pluralize": "^8.0.0",
     "prettier": "^2.7.1",
     "sqlstring": "^2.3.3",
-    "typescript": "^4.8.2"
+    "typescript": "^4.9.5"
   },
   "devDependencies": {
     "@apollo/server": "^4.3.0",
     "@types/fs-extra": "11.0.1",
-    "@types/jest": "29.2.5",
+    "@types/jest": "29.4.0",
     "@types/js-yaml": "4.0.5",
-    "@types/node": "18.11.18",
+    "@types/node": "18.13.0",
     "@types/pluralize": "0.0.29",
     "@types/prettier": "2.7.2",
     "@types/sqlstring": "2.3.0",
-    "@typescript-eslint/eslint-plugin": "5.48.2",
-    "@typescript-eslint/parser": "5.48.2",
+    "@typescript-eslint/eslint-plugin": "5.51.0",
+    "@typescript-eslint/parser": "5.51.0",
     "env-cmd": "10.1.0",
-    "eslint": "8.32.0",
+    "eslint": "8.33.0",
     "eslint-config-prettier": "8.6.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-prettier": "4.2.1",
     "husky": "8.0.3",
-    "jest": "29.3.1",
-    "lint-staged": "13.1.0",
+    "jest": "29.4.2",
+    "lint-staged": "13.1.1",
     "sasat": "link:./lib",
     "ts-jest": "29.0.5",
     "ts-node": "10.9.1",

package/lib/generatorv2/codegen/gql/generateTypeDefs.d.ts

@@ -1,3 +0,0 @@
-import { TsFile } from '../../../tsg/index.js';
-import { RootNode } from '../../nodes/rootNode.js';
-export declare const generateTypeDefs: (root: RootNode) => TsFile;

package/lib/generatorv2/codegen/gql/generateTypeDefs.js

@@ -1,114 +0,0 @@
-import { TsFile, tsg } from '../../../tsg/index.js';
-import { nonNullableFilter } from '../../../util/type.js';
-import { GQLString, makeGQLType } from './gqlString.js';
-import { typeFieldDefinitionToTsg } from './typeDefinition.js';
-import { EntityName } from '../../nodes/entityName.js';
-import { getArgs } from '../../../migration/data/GQLOption.js';
-export const generateTypeDefs = (root) => {
-    const types = [
-        ...root.entities.map(makeEntityType),
-        makeQuery(root),
-        makeMutation(root.mutations),
-        makeSubscription(root.subscriptions.filter(it => it.gqlEnabled)),
-    ].filter(nonNullableFilter);
-    const inputs = [
-        tsg.propertyAssign('PagingOption', tsg.object(tsg.propertyAssign('numberOfItem', typeFieldDefinitionToTsg({ return: 'Int!' })), tsg.propertyAssign('offset', typeFieldDefinitionToTsg({ return: 'Int' })), tsg.propertyAssign('order', typeFieldDefinitionToTsg({ return: 'String' })), tsg.propertyAssign('asc', typeFieldDefinitionToTsg({ return: 'Boolean' })))),
-        ...root.entities.map(makeCreateInput),
-        ...root.entities.map(makeUpdateInput),
-    ].filter(nonNullableFilter);
-    return new TsFile(tsg
-        .variable('const', tsg.identifier('typeDefs'), tsg.object(...types))
-        .export(), tsg
-        .variable('const', tsg.identifier('inputs'), tsg.object(...inputs))
-        .export()).disableEsLint();
-};
-const makeEntityType = (node) => {
-    if (!node.gqlEnabled)
-        return null;
-    return tsg.propertyAssign(node.name.name, tsg.object(...node.fields
-        .filter(it => it.isGQLOpen)
-        .map(it => {
-        return tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({
-            return: makeGQLType(it.gqlType, it.isNullable, it.isArray),
-        }));
-    }), ...node.references
-        .filter(it => it.isGQLOpen)
-        .map(it => {
-        return tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({
-            return: makeGQLType(EntityName.fromTableName(it.parentTableName).name, it.isNullable, it.isArray),
-        }));
-    }), ...node.referencedBy
-        .filter(it => it.isGQLOpen)
-        .map(it => {
-        return tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({
-            return: makeGQLType(EntityName.fromTableName(it.childTable).name, it.isNullable, it.isArray),
-        }));
-    })));
-};
-const makeInput = (inputName, fields) => {
-    return tsg.propertyAssign(inputName, tsg.object(...fields
-        .filter(it => it.isGQLOpen)
-        .map(it => tsg.propertyAssign(it.fieldName, typeFieldDefinitionToTsg({
-        return: makeGQLType(it.gqlType, it.isNullable, it.isArray),
-    })))));
-};
-const makeCreateInput = (node) => {
-    if (!node.gqlEnabled || !node.creatable.gqlEnabled)
-        return null;
-    return makeInput(node.name.createInputName(), node.creatable.fields);
-};
-const makeUpdateInput = (node) => {
-    if (!node.gqlEnabled || !node.updateInput.gqlEnabled)
-        return null;
-    return makeInput(node.name.updateInputName(), node.updateInput.fields);
-};
-const makeQueryTypeDef = (entity, query) => {
-    const args = getArgs(query, entity);
-    return tsg.propertyAssign(query.type === 'primary' ? entity.name.lowerCase() : query.name, typeFieldDefinitionToTsg({
-        return: GQLString.type({
-            typeName: entity.name.name,
-            entity: true,
-            array: query.type === 'list-paging' || query.type === 'list-all',
-            nullable: query.type !== 'list-paging' && query.type !== 'list-all',
-        }),
-        args: args.map(it => ({
-            name: it.name,
-            type: it.type + '!',
-        })),
-    }));
-};
-const makeQueryProperties = (root) => {
-    return root.entities.flatMap(entity => entity.queries.map(it => makeQueryTypeDef(entity, it)));
-};
-const makeQuery = (root) => {
-    const properties = makeQueryProperties(root);
-    if (properties.length === 0)
-        return null;
-    return tsg.propertyAssign('Query', tsg.object(...properties));
-};
-const makeMutation = (mutations) => {
-    if (mutations.length === 0)
-        return null;
-    return tsg.propertyAssign('Mutation', tsg.object(...mutations.map(mutation => {
-        return tsg.propertyAssign(mutation.mutationName, typeFieldDefinitionToTsg({
-            return: GQLString.type(mutation.returnType),
-            args: mutation.args.map(arg => ({
-                name: arg.name,
-                type: GQLString.type(arg.type),
-            })),
-        }));
-    })));
-};
-const makeSubscription = (subscriptions) => {
-    if (subscriptions.length === 0)
-        return null;
-    return tsg.propertyAssign('Subscription', tsg.object(...subscriptions.map(subscription => {
-        return tsg.propertyAssign(subscription.subscriptionName, typeFieldDefinitionToTsg({
-            return: GQLString.type(subscription.returnType),
-            args: subscription.args.map(arg => ({
-                name: arg.name,
-                type: GQLString.type(arg.type),
-            })),
-        }));
-    })));
-};

package/lib/generatorv2/codegen/gql/gqlString.d.ts

@@ -1,16 +0,0 @@
-import { ArgNode, TypeNode } from '../../nodes/typeNode.js';
-import { FieldNode, ReferencedNode, ReferenceNode } from '../../nodes/entityNode.js';
-import { MutationNode } from '../../nodes/mutationNode.js';
-import { SubscriptionNode } from '../../nodes/subscriptionNode.js';
-import { QueryNode } from '../../nodes/queryNode.js';
-export declare const GQLString: {
-    args: (args: ArgNode[]) => string;
-    field: (field: FieldNode) => string;
-    referenceField: (ref: ReferenceNode) => string;
-    referencedField: (ref: ReferencedNode) => string;
-    query: (node: QueryNode) => string;
-    mutation: (node: MutationNode) => string;
-    subscription: (node: SubscriptionNode) => string;
-    type: (node: TypeNode) => string;
-};
-export declare const makeGQLType: (typeName: string, isNullable: boolean, isArray: boolean) => string;

package/lib/generatorv2/codegen/gql/gqlString.js

@@ -1,43 +0,0 @@
-import { EntityName } from '../../nodes/entityName.js';
-export const GQLString = {
-    args: (args) => {
-        if (args.length === 0)
-            return '';
-        return `(${args
-            .map(arg => `${arg.name}: ${GQLString.type(arg.type)}`)
-            .join(',')})`;
-    },
-    field: (field) => {
-        return `${field.fieldName}: ${fieldGqlType(field)}`;
-    },
-    referenceField: (ref) => {
-        return `${ref.fieldName}: ${makeGQLType(EntityName.fromTableName(ref.parentTableName).name, ref.isNullable, ref.isArray)}`;
-    },
-    referencedField: (ref) => {
-        return `${ref.fieldName}: ${makeGQLType(EntityName.fromTableName(ref.childTable).name, ref.isNullable, ref.isArray)}`;
-    },
-    query: (node) => {
-        return `${node.queryName}${GQLString.args(node.args)}: ${GQLString.type(node.returnType)}`;
-    },
-    mutation: (node) => {
-        return `${node.mutationName}${GQLString.args(node.args)}: ${GQLString.type(node.returnType)}`;
-    },
-    subscription: (node) => {
-        return `${node.subscriptionName}${GQLString.args(node.args)}: ${GQLString.type(node.returnType)}`;
-    },
-    type: (node) => {
-        const type = node.nullable ? node.typeName : node.typeName + '!';
-        if (node.array)
-            return `[${type}]!`;
-        return type;
-    },
-};
-const fieldGqlType = (field) => {
-    return makeGQLType(field.gqlType, field.isNullable, field.isArray);
-};
-export const makeGQLType = (typeName, isNullable, isArray) => {
-    const type = isNullable ? typeName : typeName + '!';
-    if (isArray)
-        return `[${type}]!`;
-    return type;
-};

package/lib/generatorv2/codegen/gql/typeDefinition.d.ts

@@ -1,9 +0,0 @@
-import { ObjectLiteral } from '../../../tsg/index.js';
-export declare type TypeFieldDefinition = {
-    return: string;
-    args?: {
-        name: string;
-        type: string;
-    }[];
-};
-export declare const typeFieldDefinitionToTsg: (def: TypeFieldDefinition) => ObjectLiteral;

package/lib/generatorv2/codegen/gql/typeDefinition.js

@@ -1,13 +0,0 @@
-import { tsg } from '../../../tsg/index.js';
-import { nonNullableFilter } from '../../../util/type.js';
-export const typeFieldDefinitionToTsg = (def) => {
-    const properties = [
-        tsg.propertyAssign('return', tsg.string(def.return)),
-        def.args
-            ? tsg.propertyAssign('args', tsg.array(def.args.map(it => {
-                return tsg.object(tsg.propertyAssign('name', tsg.string(it.name)), tsg.propertyAssign('type', tsg.string(it.type)));
-            })))
-            : null,
-    ];
-    return tsg.object(...properties.filter(nonNullableFilter));
-};

package/lib/generatorv2/codegen/ts/relationMap/makeCondition.d.ts

@@ -1,2 +0,0 @@
-import { EntityNode, ReferencedNode, ReferenceNode } from '../../../nodes/entityNode.js';
-export declare const makeCondition: (node: EntityNode, ref: ReferenceNode | ReferencedNode) => import("../../../../tsg/index.js").PropertyAssignment;