vona-module-a-orm 5.0.61 → 5.0.62

package/cli/model/metadata/magic.ts

@@ -6,9 +6,10 @@ import path from 'node:path';
 import { ensureArray } from '@cabloy/utils';
 import { toUpperCaseFirstChar } from '@cabloy/word-utils';
 
-type TypeMagicFieldMethod = 'getBy' | 'selectBy';
+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>;
@@ -17,31 +18,38 @@ interface IMagicField {
 // id/name/enabled/disabled/closed/active/current/
 const __MagicFields: Record<string, IMagicField> = {
   id: {
+    optional: false,
     type: 'auto',
-    methods: 'getBy',
+    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'],
   },
@@ -56,22 +64,22 @@ export function __parseMagics(cli: BeanCliBase, ast: GoGoCode.GoGoAST, globFile:
   const contentRecords: string[] = [];
   for (const fieldName in __MagicFields) {
     const magicField = __MagicFields[fieldName];
-    if (fieldName === 'id') {
-      if (!modelInfo.fieldNames.includes('getById') && entityInfo.idType) {
-        contentRecords.push(`getById<T extends IModelGetOptions<${entityName},${className}>>(id: ${entityInfo.idType}, options?: T): Promise<TypeModelRelationResult<${entityName}, ${className}, T> | undefined>;`);
-      }
-      continue;
-    }
     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}?: ${magicField.type}, options?: T): Promise<TypeModelRelationResult<${entityName}, ${className}, T> | undefined>;`);
+          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}?: ${magicField.type}, params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<${entityName}, ${className}, T>[]>;`);
+          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>;`);
         }
       }
     }
@@ -95,6 +103,7 @@ function __parseEntityInfo(cli: BeanCliBase, fileEntity: string, entityName: str
   for (const astNode of astNodes) {
     fieldNames.push((astNode as any).key.name);
   }
+  if (idType) fieldNames.push('id');
   return { idType, fieldNames };
 }
 

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

@@ -58,6 +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[]>) | undefined;
+    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

@@ -3541,12 +3541,33 @@ class BeanModelCache extends BeanModelCrud {
         };
         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 : {
+    [fieldName]: fieldValue === undefined ? undefined : op === 'eq' ? fieldValue : {
       [`_${op}_`]: fieldValue
     }
   };

package/package.json

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