vona-module-a-orm 5.0.88 → 5.0.90

package/dist-cli/entity/metadata/generate.js

@@ -0,0 +1,52 @@
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+export default async function (options) {
+    const { sceneName, moduleName, globFiles } = options;
+    const contentColumns = [];
+    const contentEntityMetas = [];
+    const contentRecords = [];
+    const contentFields = [];
+    for (const globFile of globFiles) {
+        const { className, beanName, fileContent } = globFile;
+        const opionsName = `IEntityOptions${toUpperCaseFirstChar(beanName)}`;
+        const tableName = __parseTableName(fileContent);
+        contentColumns.push(`export type ${className}TableName = '${tableName}';`);
+        contentEntityMetas.push(`export type ${className}Meta=TypeEntityMeta<${className},${className}TableName>;`);
+        const contentRecordItem = `'${tableName}': never;`;
+        if (!contentRecords.includes(contentRecordItem)) {
+            contentRecords.push(contentRecordItem);
+        }
+        contentFields.push(`
+    export interface ${opionsName} {
+      fields?: TypeEntityOptionsFields<${className}, ${opionsName}[TypeSymbolKeyFieldsMore]>;
+    }`);
+    }
+    if (contentColumns.length === 0 && contentEntityMetas.length === 0 && contentRecords.length === 0 && contentFields.length === 0)
+        return '';
+    // combine
+    const content = `/** ${sceneName}: begin */
+${contentColumns.join('\n')}
+${contentEntityMetas.join('\n')}
+declare module 'vona-module-a-orm' {
+  export interface ITableRecord {
+    ${contentRecords.join('\n')}
+  }
+}
+declare module 'vona-module-${moduleName}' {
+  ${contentFields.join('\n')}
+}
+/** ${sceneName}: end */
+`;
+    return content;
+}
+function __parseTableName(fileContent) {
+    let matched = fileContent.match(/@Entity<.*?>\(\{[\s\S]*?table: ('[^']*')[\s\S]*?\}[\s\S]*?\)\s*export class/);
+    if (!matched) {
+        matched = fileContent.match(/@Entity<.*?>\(([^)]*)\)/);
+    }
+    if (!matched)
+        return false;
+    const tableName = matched[1];
+    if (tableName === '')
+        return '';
+    return tableName.split(',')[0].replaceAll("'", '');
+}

package/dist-cli/model/metadata/generate.js

@@ -0,0 +1,296 @@
+import { types as t } from '@babel/core';
+import { __parseMagics } from "./magic.js";
+export default async function (options) {
+    const { sceneName, moduleName, globFiles, cli } = options;
+    const contentRelations = [];
+    const contentRecords = [];
+    const contentModels = [];
+    // const contentModelsOptions: string[] = [];
+    for (const globFile of globFiles) {
+        const { className, beanName, fileContent, beanNameCapitalize } = globFile;
+        const ast = cli.helper.gogocode(fileContent);
+        const astNodes = ast.find(`@Model<$$$0>({$$$1})export class ${className} extends $$$2 {}`).match.$$$1;
+        const entityName = __parseEntityName(__getAstNode(astNodes, 'entity'));
+        const relations = __parseRelations(__getAstNode(astNodes, 'relations'));
+        const magics = __parseMagics(cli, ast, globFile, entityName);
+        const entityMetaName = `${entityName}Meta`;
+        const opionsName = `IModelOptions${beanNameCapitalize}`;
+        if (relations && relations.length > 0) {
+            contentRelations.push(`export interface ${opionsName} {
+        relations: {
+          ${relations.join('\n')}
+        };
+      }`);
+        }
+        contentRecords.push(`export interface ${className} {
+      [SymbolKeyEntity]: ${entityName};
+      [SymbolKeyEntityMeta]: ${entityMetaName};
+      [SymbolKeyModelOptions]: ${opionsName};
+      get<T extends IModelGetOptions<${entityName},${className}>>(where: TypeModelWhere<${entityName}>, options?: T): Promise<TypeModelRelationResult<${entityName}, ${className}, T> | undefined>;
+      mget<T extends IModelGetOptions<${entityName},${className}>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<${entityName}, ${className}, T>[]>;
+      selectAndCount<T extends IModelSelectParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelSelectAndCount<${entityName}, ${className}, T>>;
+      select<T extends IModelSelectParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<${entityName}, ${className}, T>[]>;
+      insert<T extends IModelInsertOptions<${entityName},${className}>>(data?: TypeModelMutateRelationData<${entityName},${className}, T>, options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T, true>>;
+      insertBulk<T extends IModelInsertOptions<${entityName},${className}>>(items: TypeModelMutateRelationData<${entityName},${className}, T>[], options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T, true>[]>;
+      update<T extends IModelUpdateOptions<${entityName},${className}>>(data: TypeModelMutateRelationData<${entityName},${className}, T>, options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>>;
+      updateBulk<T extends IModelUpdateOptions<${entityName},${className}>>(items: TypeModelMutateRelationData<${entityName},${className}, T>[], options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>[]>;
+      delete<T extends IModelDeleteOptions<${entityName},${className}>>(where?: TypeModelWhere<${entityName}>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<${entityName},${className}>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<${entityName},${className}>>(data?: TypeModelMutateRelationData<${entityName},${className}, T>, options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>>;
+      mutateBulk<T extends IModelMutateOptions<${entityName},${className}>>(items: TypeModelMutateRelationData<${entityName},${className}, T>[], options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>[]>;
+      count<T extends IModelSelectCountParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<string | undefined>;
+      aggregate<T extends IModelSelectAggrParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<${entityName}, T>[]>;
+      ${magics.join('\n')}
+    }`);
+        contentModels.push(`'${moduleName}:${beanName}': ${className};`);
+        // only override cache.keyAux which not enough
+        // contentModelsOptions.push(`export interface ${opionsName} {
+        //   cache?: {
+        //     keyAux?: keyof ${entityName};
+        //   };
+        // }`);
+    }
+    if (contentRelations.length === 0 && contentRecords.length === 0 && contentModels.length === 0)
+        return '';
+    // combine
+    const content = `/** ${sceneName}: begin */
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TypeModelSelectAndCount, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
+declare module 'vona-module-${moduleName}' {
+  ${contentRelations.join('\n')}
+  ${contentRecords.join('\n')}
+}
+declare module 'vona-module-a-orm' {
+  export interface IModelClassRecord {
+    ${contentModels.join('\n')}
+  }
+}
+/** ${sceneName}: end */
+`;
+    return content;
+}
+function __getAstNode(astNodes, name) {
+    return astNodes.find(node => node.key.name === name);
+}
+function __parseEntityName(node) {
+    return node.value.name;
+    // const matched = fileContent.match(/@Model<.*?>\(\{[\s\S]*?entity: (Entity\S+)[\s\S]*?\}[\s\S]*?\)\s*export class/);
+    // if (!matched) return false;
+    // const entityName = matched[1];
+    // if (entityName === '') return '';
+    // return entityName.split(',')[0];
+}
+function __parseRelations(node) {
+    if (!node)
+        return;
+    const relations = [];
+    const nodeRelations = node.value;
+    for (const nodeRelation of nodeRelations.properties) {
+        relations.push(__parseRelation(nodeRelation));
+    }
+    return relations;
+}
+function __parseRelation(nodeRelation) {
+    const relationName = nodeRelation.key.name;
+    const callExpression = nodeRelation.value;
+    const relationType = callExpression.callee.property.name;
+    const args = callExpression.arguments;
+    // relation
+    if (relationType === 'hasOne') {
+        return `${relationName}: ${__parseRelationHasOne(args)};`;
+    }
+    else if (relationType === 'belongsTo') {
+        return `${relationName}: ${__parseRelationBelongsTo(args)};`;
+    }
+    else if (relationType === 'hasMany') {
+        return `${relationName}: ${__parseRelationHasMany(args)};`;
+    }
+    else if (relationType === 'belongsToMany') {
+        return `${relationName}: ${__parseRelationBelongsToMany(args)};`;
+    }
+    return '';
+}
+function __parseRelationHasOne(args) {
+    // classModel
+    const classModel = __parseRelation_classModel(args[0]);
+    // key
+    const key = __parseRelation_key(args[1]);
+    // options
+    const options = __parseRelation_options(args[2]);
+    // combine
+    return `IModelRelationHasOne<${classModel}, '${key}', ${options.autoload}, ${options.columns}>`;
+}
+function __parseRelationBelongsTo(args) {
+    // classModelSelf
+    const classModelSelf = __parseRelation_classModel(args[0]);
+    // classModel
+    const classModel = __parseRelation_classModel(args[1]);
+    // options
+    const options = __parseRelation_options(args[3]);
+    // combine
+    return `IModelRelationBelongsTo<${classModelSelf}, ${classModel}, ${options.autoload}, ${options.columns}>`;
+}
+function __parseRelationHasMany(args) {
+    // classModel
+    const classModel = __parseRelation_classModel(args[0]);
+    // key
+    const key = __parseRelation_key(args[1]);
+    // options
+    const options = __parseRelation_options(args[2]);
+    // modelJoins
+    const modelJoins = __parseRelation_modelJoins(args[3]);
+    // combine
+    return `IModelRelationHasMany<${classModel}, '${key}', ${options.autoload}, ${options.columns}, ${modelJoins}, ${options.aggrs}, ${options.groups}>`;
+}
+function __parseRelationBelongsToMany(args) {
+    // classModelMiddle
+    const classModelMiddle = __parseRelation_classModel(args[0]);
+    // classModel
+    const classModel = __parseRelation_classModel(args[1]);
+    // options
+    const options = __parseRelation_options(args[4]);
+    // modelJoins
+    const modelJoins = __parseRelation_modelJoins(args[5]);
+    // combine
+    return `IModelRelationBelongsToMany<${classModelMiddle}, ${classModel}, ${options.autoload}, ${options.columns},${modelJoins},${options.aggrs},${options.groups}>`;
+}
+function __parseRelation_classModel(node) {
+    if (t.isArrowFunctionExpression(node)) {
+        return node.body.name;
+    }
+    else if (t.isIdentifier(node)) {
+        return node.name;
+    }
+    else if (t.isStringLiteral(node)) {
+        return `'${node.value}'`;
+    }
+    throw new Error('invalid classModel');
+}
+function __parseRelation_key(node) {
+    if (t.isStringLiteral(node)) {
+        return node.value;
+    }
+    throw new Error('invalid key');
+}
+function __parseRelation_modelJoins(node) {
+    if (!node)
+        return 'undefined';
+    if (t.isIdentifier(node) && node.name === 'undefined')
+        return 'undefined';
+    let modelJoins;
+    if (t.isArrayExpression(node)) {
+        modelJoins = node.elements.map(item => __parseRelation_classModel(item));
+    }
+    else {
+        modelJoins = [__parseRelation_classModel(node)];
+    }
+    return `[${modelJoins.join(',')}]`;
+    // const content = `${modelJoins.join('|')}`;
+    // return `${content} | Array<${content}>`;
+}
+function __parseRelation_aggrs(node) {
+    if (!node)
+        return 'undefined';
+    if (t.isIdentifier(node) && node.name === 'undefined')
+        return 'undefined';
+    const aggrs = __parseRelation_aggrs_inner(node);
+    return `{ ${aggrs.join(';')} }`;
+}
+function __parseRelation_aggrs_inner(node) {
+    const aggrs = [];
+    for (const _nodeProperty of node.properties) {
+        const nodeProperty = _nodeProperty;
+        const key = nodeProperty.key.name;
+        const value = __parseColumns(nodeProperty);
+        if (value) {
+            aggrs.push(`${key}?: ${__joinColumnsType(value, true)}`);
+        }
+    }
+    return aggrs;
+}
+function __parseRelation_options(node) {
+    const options = __parseRelation_options_inner(node);
+    let autoload;
+    let columns;
+    let groups;
+    let aggrs;
+    // autoload
+    if (options?.autoload) {
+        autoload = 'true';
+    }
+    else {
+        autoload = 'false';
+    }
+    // groups
+    if (!options?.groups) {
+        groups = 'undefined';
+    }
+    else {
+        groups = __joinColumnsType(options?.groups, true);
+    }
+    // aggrs
+    if (!options?.aggrs) {
+        aggrs = 'undefined';
+    }
+    else {
+        aggrs = options?.aggrs;
+    }
+    // columns
+    if (!options?.columns) {
+        if (options?.groups) {
+            columns = 'undefined';
+        }
+        else {
+            columns = 'undefined'; // '\'*\'';
+        }
+    }
+    else {
+        if (options?.columns.includes('*')) {
+            columns = '\'*\'';
+        }
+        else {
+            columns = __joinColumnsType(options?.columns, false);
+        }
+    }
+    return { autoload, columns, groups, aggrs };
+}
+function __parseRelation_options_inner(node) {
+    if (!node)
+        return undefined;
+    if (!t.isObjectExpression(node))
+        throw new Error('invalid options');
+    let autoload;
+    let columns;
+    let groups;
+    let aggrs;
+    for (const _nodeProperty of node.properties) {
+        const nodeProperty = _nodeProperty;
+        const key = nodeProperty.key.name;
+        if (key === 'autoload') {
+            autoload = nodeProperty.value.value;
+        }
+        else if (key === 'columns') {
+            columns = __parseColumns(nodeProperty);
+        }
+        else if (key === 'groups') {
+            groups = __parseColumns(nodeProperty);
+        }
+        else if (key === 'aggrs') {
+            aggrs = __parseRelation_aggrs(nodeProperty.value);
+        }
+    }
+    return { autoload, columns, groups, aggrs };
+}
+function __parseColumns(node) {
+    if (t.isArrayExpression(node.value)) {
+        return node.value.elements.map(item => item.value);
+    }
+    else if (t.isStringLiteral(node.value)) {
+        return [node.value.value];
+    }
+}
+function __joinColumnsType(columns, withArray) {
+    const temp = columns.map(item => `'${item}'`).join('|');
+    return withArray ? `${temp} | Array<${temp}>` : temp;
+}

package/dist-cli/model/metadata/magic.js

@@ -0,0 +1,105 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { ensureArray } from '@cabloy/utils';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+// id/name/enabled/disabled/closed/active
+const __MagicFields = {
+    id: {
+        optional: false,
+        type: 'auto',
+        methods: ['getBy', 'updateBy', 'deleteBy'],
+    },
+    name: {
+        optional: true,
+        type: 'string',
+        methods: ['getBy', 'selectBy'],
+        ops: ['', 'eqI'],
+    },
+    enabled: {
+        optional: true,
+        type: 'boolean',
+        methods: ['getBy', 'selectBy'],
+    },
+    disabled: {
+        optional: true,
+        type: 'boolean',
+        methods: ['getBy', 'selectBy'],
+    },
+    closed: {
+        optional: true,
+        type: 'boolean',
+        methods: ['getBy', 'selectBy'],
+    },
+    active: {
+        optional: true,
+        type: 'boolean',
+        methods: ['getBy', 'selectBy'],
+    },
+};
+export function __parseMagics(cli, ast, globFile, entityName) {
+    const { className, file } = globFile;
+    const astImportEntity = ast.find(`import { ${entityName} } from '$$$0'`);
+    const fileEntity = path.join(path.dirname(file), astImportEntity.value.source.value);
+    const entityInfo = __parseEntityInfo(cli, fileEntity, entityName);
+    const modelInfo = __parseModelInfo(cli, file, className);
+    const contentRecords = [];
+    for (const fieldName in __MagicFields) {
+        const magicField = __MagicFields[fieldName];
+        if (!entityInfo.fieldNames.includes(fieldName))
+            continue;
+        for (const method of ensureArray(magicField.methods)) {
+            const ops = ensureArray(magicField.ops || ['']);
+            for (const op of ops) {
+                const actionName = `${method}${toUpperCaseFirstChar(fieldName)}${toUpperCaseFirstChar(op)}`;
+                if (modelInfo.fieldNames.includes(actionName))
+                    continue;
+                const optional = magicField.optional ? '?' : '';
+                const type = fieldName === 'id' ? entityInfo.idType : magicField.type;
+                if (method === 'getBy') {
+                    contentRecords.push(`${actionName}<T extends IModelGetOptions<${entityName},${className}>>(${fieldName}${optional}: ${type}, options?: T): Promise<TypeModelRelationResult<${entityName}, ${className}, T> | undefined>;`);
+                }
+                else if (method === 'selectBy') {
+                    contentRecords.push(`${actionName}<T extends IModelSelectParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(${fieldName}${optional}: ${type}, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<${entityName}, ${className}, T>[]>;`);
+                }
+                else if (method === 'updateBy') {
+                    contentRecords.push(`${actionName}<T extends IModelUpdateOptions<${entityName},${className}>>(${fieldName}: ${type}${optional ? ' | undefined' : ''}, data: TypeModelMutateRelationData<${entityName},${className}, T>, options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>>;`);
+                }
+                else if (method === 'deleteBy') {
+                    contentRecords.push(`${actionName}<T extends IModelDeleteOptions<${entityName},${className}>>(${fieldName}${optional}: ${type}, options?: T): Promise<void>;`);
+                }
+            }
+        }
+    }
+    return contentRecords;
+}
+function __parseEntityInfo(cli, fileEntity, entityName) {
+    const content = readFileSync(fileEntity).toString();
+    const regexpSimple = new RegExp(`export class ${entityName} extends.*?EntityBaseSimple.*?{`);
+    const regexpBase = new RegExp(`export class ${entityName} extends.*?EntityBase.*?{`);
+    let idType;
+    if (content.match(regexpSimple)) {
+        idType = 'number';
+    }
+    else if (content.match(regexpBase)) {
+        idType = 'TableIdentity';
+    }
+    const ast = cli.helper.gogocode(content);
+    const astNodes = ast.find(`export class ${entityName} extends $$$0 {$$$1}`).match.$$$1;
+    const fieldNames = [];
+    for (const astNode of astNodes) {
+        fieldNames.push(astNode.key.name);
+    }
+    if (idType)
+        fieldNames.push('id');
+    return { idType, fieldNames };
+}
+function __parseModelInfo(cli, fileModel, modelName) {
+    const content = readFileSync(fileModel).toString();
+    const ast = cli.helper.gogocode(content);
+    const astNodes = ast.find(`export class ${modelName} extends $$$0 {$$$1}`).match.$$$1;
+    const fieldNames = [];
+    for (const astNode of astNodes) {
+        fieldNames.push(astNode.key.name);
+    }
+    return { fieldNames };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-orm",
   "type": "module",
-  "version": "5.0.88",
+  "version": "5.0.90",
   "title": "a-orm",
   "vonaModule": {
     "capabilities": {
@@ -19,8 +19,8 @@
         "optionsGlobalInterfaceFrom": "vona-module-a-orm",
         "scopeResource": true,
         "scopeResourceTypeTemplate": "{{className}}Meta",
-        "boilerplate": "cli/entity/boilerplate",
-        "metadataCustom": "cli/entity/metadata/generate.ts"
+        "boilerplate": "entity/boilerplate",
+        "metadataCustom": "entity/metadata/generate.ts"
       },
       "model": {
         "sceneIsolate": true,
@@ -28,14 +28,14 @@
         "optionsGlobalInterfaceFrom": "vona-module-a-orm",
         "scopeResource": true,
         "beanGeneral": true,
-        "boilerplate": "cli/model/boilerplate",
-        "metadataCustom": "cli/model/metadata/generate.ts"
+        "boilerplate": "model/boilerplate",
+        "metadataCustom": "model/metadata/generate.ts"
       },
       "databaseDialect": {
         "beanGeneral": true,
         "optionsGlobalInterfaceName": "IDecoratorDatabaseDialectOptions",
         "optionsGlobalInterfaceFrom": "vona-module-a-orm",
-        "boilerplate": "cli/databaseDialect/boilerplate"
+        "boilerplate": "databaseDialect/boilerplate"
       }
     }
   },
@@ -57,7 +57,8 @@
   "files": [
     "assets",
     "cli",
-    "dist"
+    "dist",
+    "dist-cli"
   ],
   "dependencies": {
     "knex": "^3.1.0",
@@ -69,7 +70,7 @@
   },
   "gitHead": "0eab9dc4a5622caffe89e7b1b3f02c08ccbc4c4b",
   "scripts": {
-    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
-    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
+    "clean": "rimraf dist dist-cli tsconfig.build.tsbuildinfo tsconfig.cli.tsbuildinfo",
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json && tsc -p tsconfig.cli.json"
   }
 }