sasat 0.18.5 → 0.19.1

package/lib/cli/commands/generate.js

@@ -1,5 +1,3 @@
-import { Parser } from '../../parser/parser.js';
-import { CodeGenerateController } from '../../generator/controller.js';
 import { Console } from '../console.js';
 import { DataStoreHandler } from '../../migration/dataStore.js';
 import { writeCurrentSchema } from '../../util/fsUtil.js';
@@ -7,6 +5,7 @@ import { createCurrentMigrationDataStore } from '../../migration/exec/createCurr
 import { compileMigrationFiles } from '../../migration/exec/migrationFileCompiler.js';
 import { config } from '../../config/config.js';
 import { getMigrationFileNames } from '../../migration/exec/getMigrationFiles.js';
+import { CodeGen_v2 } from '../../generatorv2/codegen_v2.js';
 export const generate = async () => {
     try {
         await compileMigrationFiles();
@@ -16,8 +15,7 @@ export const generate = async () => {
         const store = (await createCurrentMigrationDataStore(targetFile)).serialize();
         const storeHandler = new DataStoreHandler(store);
         writeCurrentSchema(store);
-        const ir = new Parser().parse(storeHandler);
-        await new CodeGenerateController(ir).generate();
+        await new CodeGen_v2(storeHandler).generate();
         Console.success(`code generated. DIR: ${config().migration.out}\nmigration target: ${targetFile}`);
     }
     catch (e) {

package/lib/cli/commands/migrate.js

@@ -1,10 +1,9 @@
 import { MigrationController } from '../../migration/controller.js';
 import { Console } from '../console.js';
-import { Parser } from '../../parser/parser.js';
-import { CodeGenerateController } from '../../generator/controller.js';
 import { DataStoreHandler } from '../../migration/dataStore.js';
 import { writeCurrentSchema } from '../../util/fsUtil.js';
 import { getDbClient } from '../../db/getDbClient.js';
+import { CodeGen_v2 } from '../../generatorv2/codegen_v2.js';
 export const migrate = async (options) => {
     let current;
     try {
@@ -14,8 +13,7 @@ export const migrate = async (options) => {
         if (options.generateFiles) {
             const storeHandler = new DataStoreHandler(result.store);
             writeCurrentSchema(result.store);
-            const ir = new Parser().parse(storeHandler);
-            await new CodeGenerateController(ir).generate();
+            await new CodeGen_v2(storeHandler).generate();
         }
     }
     catch (e) {

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

@@ -1,8 +1,8 @@
 import { TokenKind } from './lexer/lexer.js';
 import { camelize } from '../../../util/stringUtil.js';
-import { columnTypeToGqlPrimitive } from '../../../generator/gql/columnToGqlType.js';
-import { GqlPrimitive } from '../../../generator/gql/types.js';
 import { getDefaultGqlOption } from '../../../migration/data/GQLOption.js';
+import { columnTypeToGqlPrimitive } from '../../../generatorv2/scripts/columnToGqlType.js';
+import { GqlPrimitive } from '../../../generatorv2/scripts/gqlTypes.js';
 const splitArray = (array, callback) => {
     const indexes = [];
     array.forEach((it, i) => {
@@ -57,6 +57,7 @@ export class CreateTableParser {
             uniqueKeys: [],
             indexes: [],
             gqlOption: getDefaultGqlOption(),
+            virtualRelations: [],
         };
     }
     resolveParen() {
@@ -142,7 +143,7 @@ export class CreateTableParser {
             onUpdateCurrentTimeStamp: isOnUpdate(),
         };
         if (column.default === '.nan' || Number.isNaN(column.default)) {
-            console.log(column);
+            console.error(column);
         }
         this.result.columns.push(column);
         if (tokens.some(it => it.kind === 'PRIMARY')) {
@@ -203,10 +204,10 @@ export class CreateTableParser {
         const isColumnUnique = this.result.uniqueKeys
             .filter(it => it.length === 1)
             .find(it => it[0] === columnName);
-        const sameTableRefs = this.result.columns.filter(it => it.hasReference && it.reference.targetTable === targetTable);
+        const sameTableRefs = this.result.columns.filter(it => it.hasReference && it.reference.parentTable === targetTable);
         const reference = {
-            targetTable,
-            targetColumn,
+            parentTable: targetTable,
+            parentColumn: targetColumn,
             columnName,
             relation: isColumnUnique ? 'OneOrZero' : 'Many',
             relationName: sameTableRefs.length !== 0

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

@@ -70,12 +70,12 @@ const startStrMap = [
             const isColumnUnique = table.uniqueKeys
                 .filter(it => it.length === 1)
                 .find(it => it[0] === columnName);
-            const sameTableRefs = table.columns.filter(it => it.hasReference && it.reference.targetTable === targetTable);
+            const sameTableRefs = table.columns.filter(it => it.hasReference && it.reference.parentTable === targetTable);
             const onUpdate = tokens.findIndex(it => it.kind === TokenKind.Keyword && it.value === 'ON UPDATE');
             const onDelete = tokens.findIndex(it => it.kind === TokenKind.Keyword && it.value === 'ON DELETE');
             const reference = {
-                targetTable,
-                targetColumn,
+                parentTable: targetTable,
+                parentColumn: targetColumn,
                 columnName,
                 relation: isColumnUnique ? 'OneOrZero' : 'Many',
                 relationName: sameTableRefs.length !== 0

package/lib/db/sql/sqlCreater.js

@@ -11,6 +11,6 @@ export const SqlCreator = {
         const onDelete = reference.onDelete
             ? ' ON DELETE ' + reference.onDelete
             : '';
-        return `ALTER TABLE ${tableName} ADD CONSTRAINT '${constraintName}' FOREIGN KEY (${reference.columnName}) REFERENCES ${reference.targetTable}(${reference.targetColumn})${onUpdate}${onDelete}`;
+        return `ALTER TABLE ${tableName} ADD CONSTRAINT '${constraintName}' FOREIGN KEY (${reference.columnName}) REFERENCES ${reference.parentTable}(${reference.parentColumn})${onUpdate}${onDelete}`;
     },
 };

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

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,102 @@
+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';
+export const generateTypeDefs = (root) => {
+    const types = [
+        ...root.entities.map(makeEntityType),
+        makeQuery(root.queries),
+        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 makeQuery = (queries) => {
+    if (queries.length === 0)
+        return null;
+    return tsg.propertyAssign('Query', tsg.object(...queries.map(query => {
+        return tsg.propertyAssign(query.queryName, typeFieldDefinitionToTsg({
+            return: GQLString.type(query.returnType),
+            args: query.args.map(arg => ({
+                name: arg.name,
+                type: GQLString.type(arg.type),
+            })),
+        }));
+    })));
+};
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,13 @@
+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/names.d.ts

@@ -0,0 +1,4 @@
+import { EntityName } from '../nodes/entityName.js';
+import { MutationType } from '../nodes/mutationNode.js';
+export declare const publishFunctionName: (entityName: EntityName, type: MutationType) => string;
+export declare const makeFindQueryName: (keys: string[]) => string;

package/lib/generatorv2/codegen/names.js

@@ -0,0 +1,10 @@
+import { capitalizeFirstLetter } from '../../util/stringUtil.js';
+const map = {
+    create: 'Created',
+    update: 'Updated',
+    delete: 'Deleted',
+};
+export const publishFunctionName = (entityName, type) => {
+    return `publish${entityName}${map[type]}`;
+};
+export const makeFindQueryName = (keys) => 'findBy' + keys.map(capitalizeFirstLetter).join('And');

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

@@ -0,0 +1,4 @@
+import { TsFile } from '../../../tsg/index.js';
+import { EntityNode } from '../../nodes/entityNode.js';
+export declare const generateAutoGeneratedDatasource: (node: EntityNode) => TsFile;
+export declare const makeClassProperties: (node: EntityNode) => import("../../../tsg/index.js").PropertyDeclaration[];

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

@@ -0,0 +1,123 @@
+import { KeywordTypeNode, TsFile, tsg } from '../../../tsg/index.js';
+import { makeContextTypeRef, makeTypeRef, } from './scripts/getEntityTypeRefs.js';
+import { Directory } from '../../directory.js';
+import { sqlValueToTsExpression } from './scripts/sqlValueToTsExpression.js';
+import { columnTypeToTsType } from '../../../migration/column/columnTypes.js';
+const DIR = 'GENERATED_DS';
+export const generateAutoGeneratedDatasource = (node) => {
+    return new TsFile(tsg.typeAlias('QueryResult', tsg.intersectionType(makeTypeRef(node.name, 'withRelation', DIR).partial(), makeTypeRef(node.name, 'identifiable', DIR))), tsg
+        .class(node.name.generatedDataSourceName())
+        .export()
+        .abstract()
+        .extends(tsg
+        .extends(tsg.typeRef('BaseDBDataSource', [
+        makeTypeRef(node.name, 'entity', DIR),
+        makeTypeRef(node.name, 'identifiable', DIR),
+        makeTypeRef(node.name, 'creatable', DIR),
+        makeTypeRef(node.name, 'updatable', DIR),
+        makeTypeRef(node.name, 'fields', DIR),
+        tsg.typeRef('QueryResult'),
+    ]))
+        .addImport(['BaseDBDataSource'], Directory.resolve(DIR, 'BASE', 'baseDBDataSource')))
+        .addProperty(...makeClassProperties(node))
+        .addMethod(makeDefaultValueMethod(node), ...makeFindMethods(node))).disableEsLint();
+};
+export const makeClassProperties = (node) => {
+    const ai = node.fields.find(it => it.isAutoIncrement);
+    return [
+        tsg
+            .propertyDeclaration('tableName', KeywordTypeNode.string, false)
+            .modifiers(tsg.propertyModifiers().readonly())
+            .initializer(tsg.string(node.tableName)),
+        tsg
+            .propertyDeclaration('fields', tsg.arrayType(KeywordTypeNode.string), false)
+            .modifiers(tsg.propertyModifiers().readonly())
+            .initializer(tsg.array(node.fields.map(it => tsg.string(it.fieldName)))),
+        tsg
+            .propertyDeclaration('primaryKeys', tsg.arrayType(KeywordTypeNode.string), false)
+            .modifiers(tsg.propertyModifiers().readonly().protected())
+            .initializer(tsg.array(node.identifyKeys.map(it => tsg.string(it)))),
+        tsg
+            .propertyDeclaration('identifyFields', tsg.arrayType(KeywordTypeNode.string), false)
+            .modifiers(tsg.propertyModifiers().readonly().protected())
+            .initializer(tsg.array(node.identifyKeys
+            .map(it => node.fields.find(f => it === f.columnName).fieldName)
+            .map(tsg.string))),
+        tsg
+            .propertyDeclaration('autoIncrementColumn', tsg.unionType(KeywordTypeNode.string, KeywordTypeNode.undefined), true)
+            .modifiers(tsg.propertyModifiers().readonly().protected())
+            .initializer(ai ? tsg.string(ai.fieldName) : tsg.identifier('undefined')),
+    ];
+};
+const fieldToExpression = (node) => {
+    if (node.column.defaultCurrentTimeStamp) {
+        return tsg
+            .identifier('getCurrentDateTimeString')
+            .addImport(['getCurrentDateTimeString'], 'sasat')
+            .call();
+    }
+    return sqlValueToTsExpression(node.column.default);
+};
+const makeDefaultValueMethod = (node) => {
+    const columns = node.fields.filter(it => it.column.defaultCurrentTimeStamp || it.column.default !== undefined);
+    const properties = columns.map(it => {
+        return tsg.propertyAssign(it.fieldName, fieldToExpression(it));
+    });
+    const body = tsg.return(tsg.object(...properties));
+    return tsg
+        .method('getDefaultValueString', [], columns.length !== 0
+        ? tsg.typeRef(node.name.name).pick(...columns.map(it => it.fieldName))
+        : tsg.typeRef('Record<string, never>'), [body])
+        .modifiers(tsg.methodModifiers().protected());
+};
+const makeFindMethods = (node) => {
+    const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+    return node.findMethods.map(it => {
+        const bve = it.params.flatMap(it => {
+            if (!it.entity)
+                return qExpr
+                    .property('conditions')
+                    .property('eq')
+                    .call(qExpr
+                    .property('field')
+                    .call(tsg.identifier('tableName'), tsg.string(it.columnName.toString())), qExpr
+                    .property('value')
+                    .call(tsg.identifier(it.fieldName.toString())));
+            return it.fields.map(field => {
+                return qExpr
+                    .property('conditions')
+                    .property('eq')
+                    .call(qExpr
+                    .property('field')
+                    .call(tsg.identifier('tableName'), tsg.string(field.columnName)), qExpr
+                    .property('value')
+                    .call(tsg.identifier(it.name).property(field.fieldName)));
+            });
+        });
+        const body = [
+            tsg.variable('const', 'tableName', tsg.identifier('fields?.tableAlias || "t0"')),
+            tsg.return(tsg.identifier(it.isArray ? 'this.find' : 'this.first').call(tsg.identifier('fields'), tsg.object().addProperties(tsg.spreadAssign(tsg.identifier('options')), tsg.propertyAssign('where', qExpr
+                .property('conditions')
+                .property('and')
+                .call(...bve, tsg.identifier('options?').property('where')))), tsg.identifier('context'))),
+        ];
+        const returnType = tsg.typeRef('QueryResult');
+        return tsg.method(it.name, [
+            ...it.params.map(it => tsg.parameter(it.entity ? it.name.toString() : it.fieldName, it.entity
+                ? makeTypeRef(it.entityName, 'identifiable', 'GENERATED_DS')
+                : tsg.typeRef(columnTypeToTsType(it.dbtype)))),
+            tsg.parameter(`fields?`, makeTypeRef(node.name, 'fields', DIR)),
+            tsg.parameter('options?', it.isArray
+                ? tsg.typeRef('QueryOptions').importFrom('sasat')
+                : tsg.typeRef('Omit', [
+                    tsg.typeRef('QueryOptions').importFrom('sasat'),
+                    tsg.typeRef('"offset" | "limit" | "sort"'),
+                ])),
+            tsg.parameter('context?', makeContextTypeRef(DIR)),
+        ], tsg.typeRef('Promise', [
+            it.isArray
+                ? tsg.arrayType(returnType)
+                : tsg.unionType(returnType, tsg.typeRef('null')),
+        ]), body);
+    });
+};

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

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

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

@@ -0,0 +1,8 @@
+import { TsFile, tsg } from '../../../tsg/index.js';
+import { columnTypeToTsType } from '../../../migration/column/columnTypes.js';
+export const generateContext = (root) => {
+    return new TsFile(tsg
+        .interface('BaseGQLContext')
+        .addProperties(root.contexts.map(it => tsg.propertySignature(it.name, tsg.typeRef(columnTypeToTsType(it.dbtype)))))
+        .export()).disableEsLint();
+};

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

@@ -0,0 +1,3 @@
+import { EntityNode } from '../../nodes/entityNode.js';
+import { TsFile } from '../../../tsg/index.js';
+export declare const generateDatasource: (node: EntityNode) => TsFile;

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

@@ -0,0 +1,10 @@
+import { TsFile, tsg } from '../../../tsg/index.js';
+import { Directory } from '../../directory.js';
+export const generateDatasource = (node) => {
+    return new TsFile(tsg
+        .class(node.name.dataSourceName())
+        .extends(tsg.extends(tsg
+        .typeRef(node.name.generatedDataSourceName())
+        .importFrom(Directory.resolve('DATA_SOURCES', 'GENERATED_DS', node.name.name))))
+        .export());
+};

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

@@ -0,0 +1,3 @@
+import { TsFile } from '../../../tsg/index.js';
+import { EntityNode } from '../../nodes/entityNode.js';
+export declare const generateEntityFile: (node: EntityNode) => TsFile;

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

@@ -0,0 +1,29 @@
+import { tsg, TsFile } from '../../../tsg/index.js';
+import { fieldToPropertySignature } from './scripts/fieldToProperty.js';
+export const generateEntityFile = (node) => {
+    return new TsFile(generateEntity(node), generateCreatable(node), generateUpdatable(node), generateIdentifiable(node)).disableEsLint();
+};
+const generateEntity = (node) => {
+    return tsg
+        .typeAlias(node.name.name, tsg.typeLiteral(node.fields.map(fieldToPropertySignature)))
+        .export();
+};
+const generateCreatable = (node) => {
+    return tsg
+        .typeAlias(node.name.creatableInterface(), node.creatable.fields.length === 0
+        ? tsg.typeRef('Record<string, never>')
+        : tsg.typeLiteral(node.creatable.fields.map(fieldToPropertySignature)))
+        .export();
+};
+const generateUpdatable = (node) => {
+    return tsg
+        .typeAlias(node.name.updatable(), node.updateInput.fields.length === 0
+        ? tsg.typeRef('Record<string, never>')
+        : tsg.typeLiteral(node.updateInput.fields.map(fieldToPropertySignature)))
+        .export();
+};
+const generateIdentifiable = (node) => {
+    return tsg
+        .typeAlias(node.name.identifiableInterfaceName(), tsg.typeLiteral(node.fields.filter(it => it.isPrimary).map(fieldToPropertySignature)))
+        .export();
+};

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

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

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

@@ -0,0 +1,19 @@
+import { TsFile, tsg } from '../../../tsg/index.js';
+import { makeTypeRef } from './scripts/getEntityTypeRefs.js';
+import { EntityName } from '../../nodes/entityName.js';
+export const generateFields = (root) => {
+    return new TsFile(...root.entities.map(it => tsg
+        .typeAlias(it.name.fieldsTypeName(), tsg
+        .typeRef('Fields', [
+        makeTypeRef(it.name, 'entity', 'GENERATED'),
+        makeTypeLiteral(it),
+    ])
+        .importFrom('sasat'))
+        .export())).disableEsLint();
+};
+const makeTypeLiteral = (entity) => {
+    return tsg.typeLiteral([
+        ...entity.references.map(it => tsg.propertySignature(`${it.fieldName}?`, tsg.typeRef(EntityName.fromTableName(it.parentTableName).fieldsTypeName()))),
+        ...entity.referencedBy.map(it => tsg.propertySignature(`${it.fieldName}?`, tsg.typeRef(EntityName.fromTableName(it.childTable).fieldsTypeName()))),
+    ]);
+};

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

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