vona-module-a-orm 5.0.60 → 5.0.62

package/cli/model/metadata/generate.ts

@@ -1,5 +1,6 @@
 import type { IMetadataCustomGenerateOptions } from '@cabloy/cli';
 import { types as t } from '@babel/core';
+import { __parseMagics } from './magic.ts';
 
 export default async function (options: IMetadataCustomGenerateOptions): Promise<string> {
   const { sceneName, moduleName, globFiles, cli } = options;
@@ -13,6 +14,7 @@ export default async function (options: IMetadataCustomGenerateOptions): Promise
     const astNodes = ast.find(`@Model<$$$0>({$$$1})export class ${className} extends $$$2 {}`).match.$$$1;
     const entityName = __parseEntityName(__getAstNode(astNodes as any, 'entity'));
     const relations = __parseRelations(__getAstNode(astNodes as any, 'relations'));
+    const magics = __parseMagics(cli, ast, globFile, entityName);
     const entityMetaName = `${entityName}Meta`;
     const opionsName = `IModelOptions${beanNameCapitalize}`;
     if (relations && relations.length > 0) {
@@ -41,6 +43,7 @@ export default async function (options: IMetadataCustomGenerateOptions): Promise
       count<T extends IModelSelectCountParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | 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

package/cli/model/metadata/magic.ts

@@ -0,0 +1,119 @@
+import type { BeanCliBase } from '@cabloy/cli';
+import type { IGlobBeanFile } from '@cabloy/module-info';
+import type GoGoCode from 'gogocode';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { ensureArray } from '@cabloy/utils';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+
+type TypeMagicFieldMethod = 'getBy' | 'selectBy' | 'updateBy' | 'deleteBy';
+type TypeMagicFieldOp = '' | 'eqI';
+interface IMagicField {
+  optional: boolean;
+  type: 'auto' | 'number' | 'TableIdentity' | 'string' | 'boolean';
+  methods: TypeMagicFieldMethod | Array<TypeMagicFieldMethod>;
+  ops?: TypeMagicFieldOp | Array<TypeMagicFieldOp>;
+}
+
+// id/name/enabled/disabled/closed/active/current/
+const __MagicFields: Record<string, IMagicField> = {
+  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'],
+  },
+  current: {
+    optional: true,
+    type: 'boolean',
+    methods: ['getBy', 'selectBy'],
+  },
+};
+
+export function __parseMagics(cli: BeanCliBase, ast: GoGoCode.GoGoAST, globFile: IGlobBeanFile, entityName: string) {
+  const { className, file } = globFile;
+  const astImportEntity = ast.find(`import { ${entityName} } from '$$$0'`);
+  const fileEntity = path.join(path.dirname(file), (astImportEntity as any).value.source.value);
+  const entityInfo = __parseEntityInfo(cli, fileEntity, entityName);
+  const modelInfo = __parseModelInfo(cli, file, className);
+  const contentRecords: string[] = [];
+  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: BeanCliBase, fileEntity: string, entityName: string) {
+  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: string[] = [];
+  for (const astNode of astNodes) {
+    fieldNames.push((astNode as any).key.name);
+  }
+  if (idType) fieldNames.push('id');
+  return { idType, fieldNames };
+}
+
+function __parseModelInfo(cli: BeanCliBase, fileModel: string, modelName: string) {
+  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: string[] = [];
+  for (const astNode of astNodes) {
+    fieldNames.push((astNode as any).key.name);
+  }
+  return { fieldNames };
+}

package/dist/bean/bean.model/bean.model_cache.d.ts

@@ -58,5 +58,6 @@ export declare class BeanModelCache<TRecord extends {} = {}> extends BeanModelCr
     protected _checkDisableCacheEntityByOptions(options?: IModelMethodOptionsGeneral): boolean;
     private __checkIfOnlyKey;
     private __checkCacheKeyValid;
+    protected __get__(prop: string): ((fieldValue?: any, options?: any) => Promise<Partial<TRecord> | undefined>) | ((fieldValue?: any, params?: any, options?: any, modelJoins?: any) => Promise<any[]>) | ((fieldValue: any, data: any, options?: any) => Promise<Partial<TRecord>>) | ((fieldValue: any, options?: any) => Promise<void>) | undefined;
 }
 export {};

package/dist/index.js

@@ -10,6 +10,7 @@ import { swapDeps } from '@cabloy/deps';
 import { prepareClassType, getTargetDecoratorRules, getTargetDecoratorRuleColumnsMap, Api, v, OrderMaxBase, OrderCoreBase, getSchemaDynamic, SymbolSchemaDynamicRefId, addSchemaDynamic, mergeFieldsOpenapiMetadata } from 'vona-module-a-openapi';
 import { ZodMetadata } from '@cabloy/zod-openapi';
 import z from 'zod';
+import { parseFirstWord, toLowerCaseFirstChar } from '@cabloy/word-utils';
 import { Broadcast, BeanBroadcastBase } from 'vona-module-a-broadcast';
 import { Event, BeanEventBase } from 'vona-module-a-event';
 import { Queue, BeanQueueBase } from 'vona-module-a-queue';
@@ -3520,6 +3521,62 @@ class BeanModelCache extends BeanModelCrud {
     if (!columnId) return undefined;
     return ['number', 'string', 'bigint', 'array'].includes(typeof where[columnId]) ? where[columnId] : undefined;
   }
+  __get__(prop) {
+    if (prop.startsWith('getBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('getBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, options) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        return this.get(where, options);
+      };
+    } else if (prop.startsWith('selectBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('selectBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, params, options, modelJoins) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        const params2 = params ? deepExtend({}, params, {
+          where
+        }) : {
+          where
+        };
+        return this.select(params2, options, modelJoins);
+      };
+    } else if (prop.startsWith('updateBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('updateBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, data, options) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        if (fieldName === 'id') {
+          data = Object.assign({}, data, where);
+        } else {
+          options = deepExtend({}, options, {
+            where
+          });
+        }
+        return this.update(data, options);
+      };
+    } else if (prop.startsWith('deleteBy')) {
+      const [fieldName, op] = __parseMagicField(prop.substring('deleteBy'.length));
+      if (!fieldName) throw new Error(`invalid magic method: ${prop}`);
+      return (fieldValue, options) => {
+        const where = __combineMagicWhere(fieldName, op, fieldValue);
+        return this.delete(where, options);
+      };
+    }
+  }
+}
+function __combineMagicWhere(fieldName, op, fieldValue) {
+  return {
+    [fieldName]: fieldValue === undefined ? undefined : op === 'eq' ? fieldValue : {
+      [`_${op}_`]: fieldValue
+    }
+  };
+}
+function __parseMagicField(str) {
+  const fieldName = parseFirstWord(str, true);
+  if (!fieldName) return [fieldName, undefined];
+  const op = toLowerCaseFirstChar(str.substring(fieldName.length)) || 'eq';
+  return [fieldName, op];
 }
 
 var _dec$8, _dec2$8, _dec3$2, _class$8;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-orm",
   "type": "module",
-  "version": "5.0.60",
+  "version": "5.0.62",
   "title": "a-orm",
   "vonaModule": {
     "capabilities": {