sasat 0.19.21 → 0.19.23

package/lib/cli/commands/migrate.js

@@ -15,6 +15,7 @@ export const migrate = async (options) => {
             writeCurrentSchema(result.store);
             await new CodeGen_v2(storeHandler).generate();
         }
+        Console.success(`current migration is ${current}`);
     }
     catch (e) {
         Console.error(e.message);
@@ -22,6 +23,5 @@ export const migrate = async (options) => {
     }
     finally {
         await getDbClient().release();
-        Console.success(`current migration is ${current}`);
     }
 };

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

@@ -52,7 +52,8 @@ const getHashIdArgs = (entity, query) => {
     }
     const getHashIdArg = (arg, field) => {
         const columnName = field.column;
-        const hashIdOpt = entity.fields.find(e => e.columnName === columnName)?.hashId;
+        const hashIdOpt = entity.fields.find(e => e.columnName === columnName)
+            ?.hashId;
         if (!hashIdOpt)
             return null;
         return {

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

@@ -1,2 +1,2 @@
-import { ReferencedNode, ReferenceNode } from '../../../nodes/entityNode.js';
+import { ReferencedNode, ReferenceNode } from '../../../nodes/ReferencedNode.js';
 export declare const getChildRequiredNames: (ref: ReferencedNode | ReferenceNode) => string[];

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

@@ -1,5 +1,6 @@
-import { EntityNode, ReferencedNode, ReferenceNode } from '../../../nodes/entityNode.js';
+import { EntityNode } from '../../../nodes/entityNode.js';
 import { JoinConditionValue } from '../../../nodes/JoinConditionNode.js';
 import { TsExpression } from '../../../../tsg/index.js';
+import { ReferencedNode, ReferenceNode } from '../../../nodes/ReferencedNode.js';
 export declare const makeJoinConditionValueQExpr: (node: EntityNode, cv: JoinConditionValue) => TsExpression;
 export declare const makeJoinConditionValue: (node: EntityNode, ref: ReferenceNode | ReferencedNode) => import("../../../../tsg/index.js").PropertyAssignment;

package/lib/generatorv2/codegen/ts/scripts/fieldToProperty.d.ts

@@ -1,3 +1,3 @@
 import { PropertySignature } from '../../../../tsg/index.js';
-import { FieldNode } from '../../../nodes/entityNode.js';
+import { FieldNode } from '../../../nodes/FieldNode.js';
 export declare const fieldToPropertySignature: (field: FieldNode) => PropertySignature;

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

@@ -1,8 +1,9 @@
 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';
+import { ReferencedNode, ReferenceNode } from '../../../nodes/ReferencedNode.js';
+import { FieldNode } from '../../../nodes/FieldNode.js';
 export declare const GQLString: {
     args: (args: ArgNode[]) => string;
     field: (field: FieldNode) => string;

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

@@ -6,16 +6,16 @@ export type FileData = {
 };
 export declare class TsCodegen_v2 {
     readonly fileExtension = "ts";
-    generateEntity: (node: EntityNode) => string;
-    generateDatasource: (node: EntityNode) => string;
-    generateGeneratedDatasource: (node: EntityNode) => string;
-    generateGqlTypeDefs: (root: RootNode) => string;
-    generateGqlResolver: (root: RootNode) => string;
-    generateGqlQuery: (root: RootNode) => string;
-    generateGqlMutation: (root: RootNode) => string;
-    generateGqlSubscription: (root: RootNode) => string;
-    generateGQLContext: (root: RootNode) => string;
-    generateFiles: (root: RootNode) => FileData[];
+    generateEntity: (node: EntityNode) => Promise<string>;
+    generateDatasource: (node: EntityNode) => Promise<string>;
+    generateGeneratedDatasource: (node: EntityNode) => Promise<string>;
+    generateGqlTypeDefs: (root: RootNode) => Promise<string>;
+    generateGqlResolver: (root: RootNode) => Promise<string>;
+    generateGqlQuery: (root: RootNode) => Promise<string>;
+    generateGqlMutation: (root: RootNode) => Promise<string>;
+    generateGqlSubscription: (root: RootNode) => Promise<string>;
+    generateGQLContext: (root: RootNode) => Promise<string>;
+    generateFiles: (root: RootNode) => Promise<FileData[]>;
     generateOnceFiles: () => FileData[];
     generateConditions: (root: RootNode, currentFile: string) => string | null;
     generateIDEncoders: (root: RootNode, currentFile: string) => string | null;

package/lib/generatorv2/codegen/tscodegen_v2.js

@@ -16,22 +16,22 @@ import { generateMiddlewares } from './ts/generateMiddlewares.js';
 export class TsCodegen_v2 {
     constructor() {
         this.fileExtension = 'ts';
-        this.generateEntity = (node) => generateEntityFile(node).toString();
-        this.generateDatasource = (node) => generateDatasource(node).toString();
-        this.generateGeneratedDatasource = (node) => generateAutoGeneratedDatasource(node).toString();
-        this.generateGqlTypeDefs = (root) => generateTypeDefs(root).toString();
-        this.generateGqlResolver = (root) => generateResolver(root).toString();
-        this.generateGqlQuery = (root) => generateQueryResolver(root).toString();
-        this.generateGqlMutation = (root) => generateMutationResolver(root).toString();
-        this.generateGqlSubscription = (root) => generateSubscription(root).toString();
-        this.generateGQLContext = (root) => generateContext(root).toString();
-        this.generateFiles = (root) => {
+        this.generateEntity = (node) => generateEntityFile(node).generate();
+        this.generateDatasource = (node) => generateDatasource(node).generate();
+        this.generateGeneratedDatasource = (node) => generateAutoGeneratedDatasource(node).generate();
+        this.generateGqlTypeDefs = (root) => generateTypeDefs(root).generate();
+        this.generateGqlResolver = (root) => generateResolver(root).generate();
+        this.generateGqlQuery = (root) => generateQueryResolver(root).generate();
+        this.generateGqlMutation = (root) => generateMutationResolver(root).generate();
+        this.generateGqlSubscription = (root) => generateSubscription(root).generate();
+        this.generateGQLContext = (root) => generateContext(root).generate();
+        this.generateFiles = async (root) => {
             return [
                 {
                     name: 'relationMap',
-                    body: generateRelationMap(root).toString(),
+                    body: await generateRelationMap(root).generate(),
                 },
-                { name: 'fields', body: generateFields(root).toString() },
+                { name: 'fields', body: await generateFields(root).generate() },
             ];
         };
         this.generateOnceFiles = () => {

package/lib/generatorv2/codegen_v2.js

@@ -23,8 +23,8 @@ export class CodeGen_v2 {
             ...this.root.entities.map(it => this.generateEntity(it)),
             ...this.root.entities.map(it => this.generateDatasource(it)),
             ...this.root.entities.map(it => this.generateGeneratedDatasource(it)),
-            ...this.generateGql(this.root),
-            ...this.generateFiles(this.root),
+            this.generateGql(this.root),
+            this.generateFiles(this.root),
             ...this.generateOnceFiles(),
             this.generateCondition(this.root),
             this.generateIDEncoders(this.root),
@@ -41,29 +41,28 @@ export class CodeGen_v2 {
     getFullPath(basePath, entityName) {
         return path.join(basePath, `${entityName}.${this.codeGen.fileExtension}`);
     }
-    generateEntity(node) {
-        return writeFile(this.getFullPath(this.generateEntityDir, node.name.name), this.codeGen.generateEntity(node));
+    async generateEntity(node) {
+        return writeFile(this.getFullPath(this.generateEntityDir, node.name.name), await this.codeGen.generateEntity(node));
     }
-    generateDatasource(node) {
-        return writeFileIfNotExist(this.getFullPath(this.dbDataSourceDir, node.name.name), this.codeGen.generateDatasource(node));
+    async generateDatasource(node) {
+        return writeFileIfNotExist(this.getFullPath(this.dbDataSourceDir, node.name.name), await this.codeGen.generateDatasource(node));
     }
-    generateGeneratedDatasource(node) {
-        return writeFile(this.getFullPath(this.generateDbDataSourceDir, node.name.name), this.codeGen.generateGeneratedDatasource(node));
+    async generateGeneratedDatasource(node) {
+        return writeFile(this.getFullPath(this.generateDbDataSourceDir, node.name.name), await this.codeGen.generateGeneratedDatasource(node));
     }
-    generateGql(rootNode) {
-        return [
-            writeFile(this.getFullPath(this.generateDir, 'typeDefs'), this.codeGen.generateGqlTypeDefs(rootNode)),
-            writeFile(this.getFullPath(this.generateDir, 'resolver'), this.codeGen.generateGqlResolver(rootNode)),
-            writeFile(this.getFullPath(this.generateDir, 'query'), this.codeGen.generateGqlQuery(rootNode)),
-            writeFile(this.getFullPath(this.generateDir, 'mutation'), this.codeGen.generateGqlMutation(rootNode)),
-            writeFile(this.getFullPath(this.generateDir, 'subscription'), this.codeGen.generateGqlSubscription(rootNode)),
-            writeFile(this.getFullPath(this.generateDir, 'context'), this.codeGen.generateGQLContext(rootNode)),
-        ];
+    async generateGql(rootNode) {
+        return Promise.all([
+            writeFile(this.getFullPath(this.generateDir, 'typeDefs'), await this.codeGen.generateGqlTypeDefs(rootNode)),
+            writeFile(this.getFullPath(this.generateDir, 'resolver'), await this.codeGen.generateGqlResolver(rootNode)),
+            writeFile(this.getFullPath(this.generateDir, 'query'), await this.codeGen.generateGqlQuery(rootNode)),
+            writeFile(this.getFullPath(this.generateDir, 'mutation'), await this.codeGen.generateGqlMutation(rootNode)),
+            writeFile(this.getFullPath(this.generateDir, 'subscription'), await this.codeGen.generateGqlSubscription(rootNode)),
+            writeFile(this.getFullPath(this.generateDir, 'context'), await this.codeGen.generateGQLContext(rootNode)),
+        ]);
     }
-    generateFiles(rootNode) {
-        return this.codeGen
-            .generateFiles(rootNode)
-            .map(it => writeFileIfNotExist(this.getFullPath(this.generateDir, it.name), it.body));
+    async generateFiles(rootNode) {
+        const files = await this.codeGen.generateFiles(rootNode);
+        return Promise.all(files.map(it => writeFileIfNotExist(this.getFullPath(this.generateDir, it.name), it.body)));
     }
     generateOnceFiles() {
         return this.codeGen

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

@@ -0,0 +1,27 @@
+import { GQLPrimitive } from '../scripts/gqlTypes.js';
+import { DBColumnTypes } from '../../migration/column/columnTypes.js';
+import { ColumnOptions, SerializedColumn } from '../../migration/serialized/serializedColumn.js';
+import { EntityNode } from './entityNode.js';
+import { DataStoreHandler } from '../../migration/dataStore.js';
+import { BaseColumn } from '../../migration/serializable/column.js';
+export type FieldNode = {
+    entity: EntityNode;
+    fieldName: string;
+    columnName: string;
+    gqlType: GQLPrimitive | string;
+    dbType: DBColumnTypes;
+    isNullable: boolean;
+    isArray: boolean;
+    isPrimary: boolean;
+    isUpdatable: boolean;
+    isGQLOpen: boolean;
+    isAutoIncrement: boolean;
+    column: SerializedColumn;
+    option: ColumnOptions;
+    hashId?: {
+        encoder: string;
+    };
+};
+export declare const makeFieldNode: (store: DataStoreHandler, entity: EntityNode, column: BaseColumn) => FieldNode;
+export declare const makeCreatableFieldNode: (store: DataStoreHandler, entity: EntityNode, column: BaseColumn) => FieldNode | null;
+export declare const makeUpdatableFieldNode: (store: DataStoreHandler, entity: EntityNode, column: BaseColumn) => FieldNode | null;

package/lib/generatorv2/nodes/FieldNode.js

@@ -0,0 +1,78 @@
+const getHashId = (store, entity, column) => {
+    if (!column.isReference()) {
+        if (column.data.option.autoIncrementHashId)
+            return { encoder: entity.IDEncoderName() };
+        return undefined;
+    }
+    const ref = column.data.reference;
+    const parent = store.table(ref.parentTable);
+    if (!parent.column(ref.parentColumn).data.option.autoIncrementHashId)
+        return undefined;
+    return {
+        encoder: parent.getEntityName().IDEncoderName(),
+    };
+};
+export const makeFieldNode = (store, entity, column) => {
+    const hashId = getHashId(store, entity.name, column);
+    return {
+        entity,
+        fieldName: column.fieldName(),
+        columnName: column.columnName(),
+        gqlType: hashId ? 'ID' : column.gqlType(),
+        dbType: column.dataType(),
+        isAutoIncrement: column.data.autoIncrement,
+        isArray: false,
+        isPrimary: column.isPrimary(),
+        isNullable: column.isNullable(),
+        isUpdatable: !(column.data.onUpdateCurrentTimeStamp || column.isPrimary()) &&
+            column.data.option.updatable,
+        isGQLOpen: true,
+        column: column.data,
+        option: column.data.option,
+        hashId,
+    };
+};
+export const makeCreatableFieldNode = (store, entity, column) => {
+    if (column.data.autoIncrement || column.data.defaultCurrentTimeStamp)
+        return null;
+    const hashId = getHashId(store, entity.name, column);
+    return {
+        entity,
+        fieldName: column.fieldName(),
+        columnName: column.columnName(),
+        gqlType: hashId ? 'ID' : column.gqlType(),
+        dbType: column.dataType(),
+        isAutoIncrement: column.data.autoIncrement,
+        isArray: false,
+        isPrimary: column.isPrimary(),
+        isNullable: column.isNullableOnCreate(),
+        isUpdatable: column.isUpdatable(),
+        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),
+    };
+};
+export const makeUpdatableFieldNode = (store, entity, column) => {
+    if (!column.isUpdatable() || !column.data.option.updatable)
+        return null;
+    const hashId = getHashId(store, entity.name, column);
+    return {
+        entity,
+        fieldName: column.fieldName(),
+        columnName: column.columnName(),
+        gqlType: hashId ? 'ID' : column.gqlType(),
+        dbType: column.dataType(),
+        isAutoIncrement: column.data.autoIncrement,
+        isArray: false,
+        isNullable: true,
+        isPrimary: false,
+        isUpdatable: true,
+        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),
+    };
+};

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

@@ -0,0 +1,33 @@
+import { Table, TableHandler } from '../../migration/serializable/table.js';
+import { ReferenceColumn } from '../../migration/serializable/column.js';
+import { DataStoreHandler } from '../../migration/dataStore.js';
+import { VirtualRelation } from '../../migration/data/virtualRelation.js';
+import { JoinConditionNode } from './JoinConditionNode.js';
+import { EntityNode } from './entityNode.js';
+export declare class ReferenceNode {
+    readonly entity: EntityNode;
+    readonly fieldName: string;
+    readonly tableName: string;
+    readonly parentTableName: string;
+    readonly joinCondition: JoinConditionNode[];
+    readonly isArray: boolean;
+    readonly isNullable: boolean;
+    readonly isPrimary: boolean;
+    readonly isGQLOpen: boolean;
+    static fromReference(entity: EntityNode, column: ReferenceColumn, parentTable: Table): ReferenceNode | null;
+    static formVirtualRelation(ds: DataStoreHandler, entity: EntityNode, rel: VirtualRelation): ReferenceNode | null;
+    private constructor();
+}
+export declare class ReferencedNode {
+    readonly entity: EntityNode;
+    readonly fieldName: string;
+    readonly childTable: string;
+    readonly joinCondition: JoinConditionNode[];
+    readonly isArray: boolean;
+    readonly isNullable: boolean;
+    readonly isPrimary: boolean;
+    readonly isGQLOpen: boolean;
+    static fromReference(entity: EntityNode, parentTable: TableHandler, column: ReferenceColumn): ReferencedNode | null;
+    static fromVirtualRelation(ds: DataStoreHandler, entity: EntityNode, rel: VirtualRelation): ReferencedNode | null;
+    private constructor();
+}

package/lib/generatorv2/nodes/ReferencedNode.js

@@ -0,0 +1,92 @@
+import { Conditions } from '../../migration/makeCondition.js';
+export class ReferenceNode {
+    static fromReference(entity, column, parentTable) {
+        const ref = column.data.reference;
+        if (!ref.fieldName)
+            return null;
+        return new ReferenceNode(entity, ref.fieldName, column.table.tableName, ref.parentTable, makeJoinCondition(ref.parentColumn, column.columnName()), false, false, column.isPrimary(), column.table.gqlOption.enabled && parentTable.gqlOption.enabled);
+    }
+    static formVirtualRelation(ds, entity, rel) {
+        if (!rel.childFieldName)
+            return null;
+        return new ReferenceNode(entity, rel.childFieldName, rel.childTable, rel.parentTable, rel.conditions, rel.childType === undefined || rel.childType === 'array', rel.childType === 'nullable', false, ds.table(rel.parentTable).gqlOption.enabled &&
+            ds.table(rel.childTable).gqlOption.enabled);
+    }
+    constructor(entity, fieldName, tableName, parentTableName, joinCondition, isArray, isNullable, isPrimary, isGQLOpen) {
+        this.entity = entity;
+        this.fieldName = fieldName;
+        this.tableName = tableName;
+        this.parentTableName = parentTableName;
+        this.joinCondition = joinCondition;
+        this.isArray = isArray;
+        this.isNullable = isNullable;
+        this.isPrimary = isPrimary;
+        this.isGQLOpen = isGQLOpen;
+    }
+}
+export class ReferencedNode {
+    static fromReference(entity, parentTable, column) {
+        const ref = column.data.reference;
+        if (!ref.parentFieldName)
+            return null;
+        return new ReferencedNode(entity, ref.parentFieldName, column.table.tableName, makeJoinCondition(column.columnName(), ref.parentColumn), ref.relation === 'Many', ref.relation === 'OneOrZero', column.isPrimary(), parentTable.gqlOption.enabled && column.table.gqlOption.enabled);
+    }
+    static fromVirtualRelation(ds, entity, rel) {
+        if (!rel.parentFieldName)
+            return null;
+        return new ReferencedNode(entity, rel.parentFieldName, rel.childTable, rel.conditions.map(reverseConditionNode), rel.parentType === undefined || rel.parentType === 'array', rel.parentType === 'nullable', false, ds.table(rel.parentTable).gqlOption.enabled &&
+            ds.table(rel.childTable).gqlOption.enabled);
+    }
+    constructor(entity, fieldName, childTable, joinCondition, isArray, isNullable, isPrimary, isGQLOpen) {
+        this.entity = entity;
+        this.fieldName = fieldName;
+        this.childTable = childTable;
+        this.joinCondition = joinCondition;
+        this.isArray = isArray;
+        this.isNullable = isNullable;
+        this.isPrimary = isPrimary;
+        this.isGQLOpen = isGQLOpen;
+    }
+}
+const reverseConditionValue = (cv) => {
+    if (cv.kind === 'parent') {
+        return {
+            ...cv,
+            kind: 'child',
+        };
+    }
+    else if (cv.kind === 'child') {
+        return {
+            ...cv,
+            kind: 'parent',
+        };
+    }
+    return cv;
+};
+const reverseRangeCondition = (condition) => {
+    if (condition.kind === 'range') {
+        return {
+            kind: condition.kind,
+            begin: reverseConditionValue(condition.begin),
+            end: reverseConditionValue(condition.end),
+        };
+    }
+    return condition;
+};
+const reverseConditionNode = (condition) => {
+    if (condition.kind === 'custom')
+        return {
+            ...condition,
+            parentRequiredFields: condition.childRequiredFields,
+            childRequiredFields: condition.parentRequiredFields,
+        };
+    if (condition.operator === 'BETWEEN') {
+        return Conditions.rel.between(reverseConditionValue(condition.left), reverseRangeCondition(condition.right));
+    }
+    return Conditions.rel.comparison(reverseConditionValue(condition.right), condition.operator, reverseConditionValue(condition.left));
+};
+const makeJoinCondition = (parentColumn, childColumn) => {
+    return [
+        Conditions.rel.comparison(Conditions.value.parent(parentColumn), '=', Conditions.value.child(childColumn)),
+    ];
+};

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

@@ -1,14 +1,12 @@
 import { DBColumnTypes } from '../../migration/column/columnTypes.js';
 import { DataStoreHandler } from '../../migration/dataStore.js';
-import { Table, TableHandler } from '../../migration/serializable/table.js';
-import { ReferenceColumn } from '../../migration/serializable/column.js';
-import { ColumnOptions, SerializedColumn } from '../../migration/serialized/serializedColumn.js';
+import { TableHandler } from '../../migration/serializable/table.js';
 import { EntityName } from './entityName.js';
 import { GQLPrimitive } from '../scripts/gqlTypes.js';
-import { VirtualRelation } from '../../migration/data/virtualRelation.js';
-import { JoinConditionNode } from './JoinConditionNode.js';
 import { GQLQuery } from '../../migration/data/GQLOption.js';
 import { MutationNode } from './mutationNode.js';
+import { ReferencedNode, ReferenceNode } from './ReferencedNode.js';
+import { FieldNode } from './FieldNode.js';
 export declare class EntityNode {
     readonly name: EntityName;
     readonly tableName: string;
@@ -26,56 +24,11 @@ export declare class EntityNode {
     identifyFields(): FieldNode[];
     primaryQueryName(): string;
 }
-export declare class ReferenceNode {
-    readonly entity: EntityNode;
-    readonly fieldName: string;
-    readonly tableName: string;
-    readonly parentTableName: string;
-    readonly joinCondition: JoinConditionNode[];
-    readonly isArray: boolean;
-    readonly isNullable: boolean;
-    readonly isPrimary: boolean;
-    readonly isGQLOpen: boolean;
-    static fromReference(entity: EntityNode, column: ReferenceColumn, parentTable: Table): ReferenceNode | null;
-    static formVirtualRelation(ds: DataStoreHandler, entity: EntityNode, rel: VirtualRelation): ReferenceNode | null;
-    private constructor();
-}
-export declare class ReferencedNode {
-    readonly entity: EntityNode;
-    readonly fieldName: string;
-    readonly childTable: string;
-    readonly joinCondition: JoinConditionNode[];
-    readonly isArray: boolean;
-    readonly isNullable: boolean;
-    readonly isPrimary: boolean;
-    readonly isGQLOpen: boolean;
-    static fromReference(entity: EntityNode, parentTable: TableHandler, column: ReferenceColumn): ReferencedNode | null;
-    static fromVirtualRelation(ds: DataStoreHandler, entity: EntityNode, rel: VirtualRelation): ReferencedNode | null;
-    private constructor();
-}
-export type SubTypeNode = {
+type SubTypeNode = {
     gqlEnabled: boolean;
     fields: FieldNode[];
 };
-export type FieldNode = {
-    entity: EntityNode;
-    fieldName: string;
-    columnName: string;
-    gqlType: GQLPrimitive | string;
-    dbType: DBColumnTypes;
-    isNullable: boolean;
-    isArray: boolean;
-    isPrimary: boolean;
-    isUpdatable: boolean;
-    isGQLOpen: boolean;
-    isAutoIncrement: boolean;
-    column: SerializedColumn;
-    option: ColumnOptions;
-    hashId?: {
-        encoder: string;
-    };
-};
-export type FindMethodNode = {
+type FindMethodNode = {
     name: string;
     params: ParameterNode[];
     isArray: boolean;

package/lib/generatorv2/nodes/entityNode.js

@@ -2,86 +2,9 @@ import { makeFindQueryName } from '../codegen/names.js';
 import { EntityName } from './entityName.js';
 import { columnTypeToGqlPrimitive } from '../scripts/columnToGqlType.js';
 import { nonNullable } from '../../runtime/util.js';
-import { Conditions } from '../../migration/makeCondition.js';
 import { makeEntityMutationNodes } from '../parser/makeMutationNodes.js';
-const getHashId = (store, entity, column) => {
-    if (!column.isReference()) {
-        if (column.data.option.autoIncrementHashId)
-            return { encoder: entity.IDEncoderName() };
-        return undefined;
-    }
-    const ref = column.data.reference;
-    const parent = store.table(ref.parentTable);
-    if (!parent.column(ref.parentColumn).data.option.autoIncrementHashId)
-        return undefined;
-    return {
-        encoder: parent.getEntityName().IDEncoderName(),
-    };
-};
-const makeFieldNode = (store, entity, column) => {
-    const hashId = getHashId(store, entity.name, column);
-    return {
-        entity,
-        fieldName: column.fieldName(),
-        columnName: column.columnName(),
-        gqlType: hashId ? 'ID' : column.gqlType(),
-        dbType: column.dataType(),
-        isAutoIncrement: column.data.autoIncrement,
-        isArray: false,
-        isPrimary: column.isPrimary(),
-        isNullable: column.isNullable(),
-        isUpdatable: !(column.data.onUpdateCurrentTimeStamp || column.isPrimary()) &&
-            column.data.option.updatable,
-        isGQLOpen: true,
-        column: column.data,
-        option: column.data.option,
-        hashId,
-    };
-};
-const makeCreatableFieldNode = (store, entity, column) => {
-    if (column.data.autoIncrement || column.data.defaultCurrentTimeStamp)
-        return null;
-    const hashId = getHashId(store, entity.name, column);
-    return {
-        entity,
-        fieldName: column.fieldName(),
-        columnName: column.columnName(),
-        gqlType: hashId ? 'ID' : column.gqlType(),
-        dbType: column.dataType(),
-        isAutoIncrement: column.data.autoIncrement,
-        isArray: false,
-        isPrimary: column.isPrimary(),
-        isNullable: column.isNullableOnCreate(),
-        isUpdatable: column.isUpdatable(),
-        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),
-    };
-};
-const makeUpdatableFieldNode = (store, entity, column) => {
-    if (!column.isUpdatable() || !column.data.option.updatable)
-        return null;
-    const hashId = getHashId(store, entity.name, column);
-    return {
-        entity,
-        fieldName: column.fieldName(),
-        columnName: column.columnName(),
-        gqlType: hashId ? 'ID' : column.gqlType(),
-        dbType: column.dataType(),
-        isAutoIncrement: column.data.autoIncrement,
-        isArray: false,
-        isNullable: true,
-        isPrimary: false,
-        isUpdatable: true,
-        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),
-    };
-};
+import { ReferencedNode, ReferenceNode } from './ReferencedNode.js';
+import { makeCreatableFieldNode, makeFieldNode, makeUpdatableFieldNode, } from './FieldNode.js';
 export class EntityNode {
     constructor(store, table) {
         this.name = EntityName.fromTableName(table.tableName);
@@ -141,60 +64,6 @@ export class EntityNode {
         return makeFindQueryName(this.identifyFields().map(it => it.fieldName));
     }
 }
-const makeJoinCondition = (parentColumn, childColumn) => {
-    return [
-        Conditions.rel.comparison(Conditions.value.parent(parentColumn), '=', Conditions.value.child(childColumn)),
-    ];
-};
-export class ReferenceNode {
-    static fromReference(entity, column, parentTable) {
-        const ref = column.data.reference;
-        if (!ref.fieldName)
-            return null;
-        return new ReferenceNode(entity, ref.fieldName, column.table.tableName, ref.parentTable, makeJoinCondition(ref.parentColumn, column.columnName()), false, false, column.isPrimary(), column.table.gqlOption.enabled && parentTable.gqlOption.enabled);
-    }
-    static formVirtualRelation(ds, entity, rel) {
-        if (!rel.childFieldName)
-            return null;
-        return new ReferenceNode(entity, rel.childFieldName, rel.childTable, rel.parentTable, rel.conditions, rel.childType === undefined || rel.childType === 'array', rel.childType === 'nullable', false, ds.table(rel.parentTable).gqlOption.enabled &&
-            ds.table(rel.childTable).gqlOption.enabled);
-    }
-    constructor(entity, fieldName, tableName, parentTableName, joinCondition, isArray, isNullable, isPrimary, isGQLOpen) {
-        this.entity = entity;
-        this.fieldName = fieldName;
-        this.tableName = tableName;
-        this.parentTableName = parentTableName;
-        this.joinCondition = joinCondition;
-        this.isArray = isArray;
-        this.isNullable = isNullable;
-        this.isPrimary = isPrimary;
-        this.isGQLOpen = isGQLOpen;
-    }
-}
-export class ReferencedNode {
-    static fromReference(entity, parentTable, column) {
-        const ref = column.data.reference;
-        if (!ref.parentFieldName)
-            return null;
-        return new ReferencedNode(entity, ref.parentFieldName, column.table.tableName, makeJoinCondition(column.columnName(), ref.parentColumn), ref.relation === 'Many', ref.relation === 'OneOrZero', column.isPrimary(), parentTable.gqlOption.enabled && column.table.gqlOption.enabled);
-    }
-    static fromVirtualRelation(ds, entity, rel) {
-        if (!rel.parentFieldName)
-            return null;
-        return new ReferencedNode(entity, rel.parentFieldName, rel.childTable, rel.conditions.map(reverseConditionNode), rel.parentType === undefined || rel.parentType === 'array', rel.parentType === 'nullable', false, ds.table(rel.parentTable).gqlOption.enabled &&
-            ds.table(rel.childTable).gqlOption.enabled);
-    }
-    constructor(entity, fieldName, childTable, joinCondition, isArray, isNullable, isPrimary, isGQLOpen) {
-        this.entity = entity;
-        this.fieldName = fieldName;
-        this.childTable = childTable;
-        this.joinCondition = joinCondition;
-        this.isArray = isArray;
-        this.isNullable = isNullable;
-        this.isPrimary = isPrimary;
-        this.isGQLOpen = isGQLOpen;
-    }
-}
 const makePrimitiveParameterNode = (fieldName, columnName, dbtype) => ({
     entity: false,
     fieldName,
@@ -202,40 +71,3 @@ const makePrimitiveParameterNode = (fieldName, columnName, dbtype) => ({
     dbtype,
     gqltype: columnTypeToGqlPrimitive(dbtype),
 });
-const reverseConditionValue = (cv) => {
-    if (cv.kind === 'parent') {
-        return {
-            ...cv,
-            kind: 'child',
-        };
-    }
-    else if (cv.kind === 'child') {
-        return {
-            ...cv,
-            kind: 'parent',
-        };
-    }
-    return cv;
-};
-const reverseRangeCondition = (condition) => {
-    if (condition.kind === 'range') {
-        return {
-            kind: condition.kind,
-            begin: reverseConditionValue(condition.begin),
-            end: reverseConditionValue(condition.end),
-        };
-    }
-    return condition;
-};
-const reverseConditionNode = (condition) => {
-    if (condition.kind === 'custom')
-        return {
-            ...condition,
-            parentRequiredFields: condition.childRequiredFields,
-            childRequiredFields: condition.parentRequiredFields,
-        };
-    if (condition.operator === 'BETWEEN') {
-        return Conditions.rel.between(reverseConditionValue(condition.left), reverseRangeCondition(condition.right));
-    }
-    return Conditions.rel.comparison(reverseConditionValue(condition.right), condition.operator, reverseConditionValue(condition.left));
-};

package/lib/generatorv2/parser/makeMutationNodes.js

@@ -100,17 +100,16 @@ const makeDeleteMutationNode = (table, entity, mutation) => {
             array: false,
             entity: false,
         },
-        args: [
-            {
-                name: table.getEntityName().lowerCase(),
-                type: {
-                    typeName: table.getEntityName().updateInputName(),
-                    nullable: false,
-                    array: false,
-                    entity: true,
-                },
+        args: entity.identifyFields().map(it => ({
+            name: it.fieldName,
+            type: {
+                typeName: it.gqlType,
+                nullable: false,
+                array: false,
+                entity: false,
+                dbType: it.dbType,
             },
-        ],
+        })),
         mutationType: 'delete',
         subscription: mutation.subscription.enabled,
         requireIdDecodeMiddleware: entity.identifyFields().some(it => it.hashId),

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

@@ -6,7 +6,7 @@ export interface MigrationStore extends DataStore {
     createTable(tableName: string, tableCreator: (table: TableBuilder) => void): MigrationStore;
     dropTable(tableName: string): MigrationStore;
     table(tableName: string): MigrationTable;
-    sql(sql: string): MigrationStore;
+    sql(...sql: string[]): MigrationStore;
 }
 export declare class StoreMigrator implements MigrationStore {
     protected tables: TableMigrator[];
@@ -18,7 +18,7 @@ export declare class StoreMigrator implements MigrationStore {
     addQuery(...query: string[]): void;
     createTable(tableName: string, tableCreator: (table: TableBuilder) => void): MigrationStore;
     dropTable(tableName: string): MigrationStore;
-    sql(sql: string): MigrationStore;
+    sql(...sql: string[]): MigrationStore;
     getSql(): string[];
     resetQueue(): void;
     serialize(): SerializedStore;

package/lib/migration/front/storeMigrator.js

@@ -47,8 +47,8 @@ export class StoreMigrator {
         this.tables = this.tables.filter(it => it.tableName !== tableName);
         return this;
     }
-    sql(sql) {
-        this.addQuery(sql);
+    sql(...sql) {
+        this.addQuery(...sql);
         return this;
     }
     getSql() {

package/lib/tsg/file.d.ts

@@ -10,4 +10,5 @@ export declare class TsFile extends TsCode {
     disableEsLint(): this;
     enableEsLint(): this;
     private static prettier;
+    generate(): Promise<string>;
 }

package/lib/tsg/file.js

@@ -15,8 +15,7 @@ export class TsFile extends TsCode {
         ]
             .map(it => it.toString())
             .join('\n');
-        return ((this.esLintDisabled ? '/* eslint-disable */\n' : '') +
-            TsFile.prettier(string));
+        return (this.esLintDisabled ? '/* eslint-disable */\n' : '') + string;
     }
     resolveImport(imports) {
         const map = {};
@@ -41,4 +40,7 @@ export class TsFile extends TsCode {
     static prettier(code) {
         return prettier.format(code, { parser: 'typescript' });
     }
+    generate() {
+        return TsFile.prettier(this.toString());
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasat",
-  "version": "0.19.21",
+  "version": "0.19.23",
   "repository": "https://github.com/nin138/sasat.git",
   "author": "nin138 <ninian138@gmail.com>",
   "license": "MIT",
@@ -21,8 +21,7 @@
     "test:single": "env-cmd jest --silent=false --verbose false",
     "test:base": "node --experimental-vm-modules node_modules/.bin/jest",
     "resetdb": "docker-compose exec db sh -c \"mysql -u root < /docker-entrypoint-initdb.d/temp.sql\"",
-    "prepare": "yarn build",
-    "postinstall": "husky install",
+    "prepare": "yarn build && husky install",
     "sasat": "yarn env-cmd ts-node-esm ./src/cli/cli.ts",
     "server": "yarn env-cmd ts-node-esm -r tsconfig-paths/register ./test/testServer.ts"
   },
@@ -36,28 +35,28 @@
     "js-yaml": "^4.1.0",
     "mysql2": "^3.4.4",
     "pluralize": "^8.0.0",
-    "prettier": "^2.8.8",
+    "prettier": "^3.0.0",
     "sqlstring": "^2.3.3",
     "typescript": "^5.1.6"
   },
   "devDependencies": {
     "@apollo/server": "^4.7.5",
     "@types/fs-extra": "11.0.1",
-    "@types/jest": "29.5.2",
+    "@types/jest": "29.5.3",
     "@types/js-yaml": "4.0.5",
-    "@types/node": "20.3.3",
-    "@types/pluralize": "0.0.29",
+    "@types/node": "20.4.2",
+    "@types/pluralize": "0.0.30",
     "@types/prettier": "2.7.3",
     "@types/sqlstring": "2.3.0",
-    "@typescript-eslint/eslint-plugin": "5.61.0",
-    "@typescript-eslint/parser": "5.61.0",
+    "@typescript-eslint/eslint-plugin": "6.0.0",
+    "@typescript-eslint/parser": "6.0.0",
     "env-cmd": "10.1.0",
-    "eslint": "8.44.0",
+    "eslint": "8.45.0",
     "eslint-config-prettier": "8.8.0",
     "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-prettier": "4.2.1",
+    "eslint-plugin-prettier": "5.0.0",
     "husky": "8.0.3",
-    "jest": "29.6.0",
+    "jest": "29.6.1",
     "lint-staged": "13.2.3",
     "sasat": "link:./lib",
     "ts-jest": "29.1.1",
@@ -74,5 +73,5 @@
     ]
   },
   "type": "module",
-  "packageManager": "yarn@3.6.0"
+  "packageManager": "yarn@3.6.1"
 }