vona-module-a-orm 5.1.39 → 5.1.41

package/dist/index.js

@@ -1,6 +1,7 @@
 import BigNumber from 'bignumber.js';
-import { BeanInfo, BeanAopMethodBase, BeanBase, deepExtend, appResource, assertIsolatedTestDatabaseClient, assertTestClaimDatabaseClient, beanFullNameFromOnionName, cast, useApp, $makeLocaleMagic, Virtual, registerTestClaimDatabaseCreation, BeanSimple, combineConfigDefault, BeanScopeBase, createBeanDecorator, PickClassInner, $Class, disposeInstance } from 'vona';
+import { BeanInfo, BeanBase, BeanAopMethodBase, deepExtend, appResource, assertIsolatedTestDatabaseClient, assertTestClaimDatabaseClient, beanFullNameFromOnionName, cast, useApp, $makeLocaleMagic, Virtual, registerTestClaimDatabaseCreation, BeanSimple, combineConfigDefault, BeanScopeBase, createBeanDecorator, PickClassInner, $Class, registerMappedClassMetadataKey, appMetadata, disposeInstance } from 'vona';
 import { __decorate, __metadata } from 'tslib';
+import { Schedule } from 'vona-module-a-schedule';
 import { AopMethod } from 'vona-module-a-aspect';
 import { Service, Bean, Scope } from 'vona-module-a-bean';
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
@@ -9,18 +10,58 @@ import knex from 'knex';
 import { BeanMutateBase } from 'vona-module-a-beanmutate';
 import { swapDeps } from '@cabloy/deps';
 import { $tableNameFromEntity, $tableDefaults, $columnsAll } from 'vona-module-a-ormutils';
-import { prepareClassType, Api, v, schemaRenderVisible, getSchemaDynamic, SymbolSchemaDynamicRefId, addSchemaDynamic, getTargetDecoratorRuleColumns, mergeTargetDecoratorDtoOpenapi, mergeDtoFieldsOpenapiMetadata } from 'vona-module-a-openapiutils';
+import { prepareClassType, Api, v, getTargetDecoratorRules, schemaRenderVisible, getSchemaDynamic, SymbolSchemaDynamicRefId, addSchemaDynamic, getTargetDecoratorRuleColumns, mergeTargetDecoratorDtoOpenapi, mergeDtoFieldsOpenapiMetadata } from 'vona-module-a-openapiutils';
 import z from 'zod';
 import { Broadcast, BeanBroadcastBase } from 'vona-module-a-broadcast';
 import { Event, BeanEventBase } from 'vona-module-a-event';
 import { Hmr } from 'vona-module-a-hmrbase';
 import { Queue, BeanQueueBase } from 'vona-module-a-queue';
-import { Schedule } from 'vona-module-a-schedule';
 import { configAll, configRedis } from 'vona-module-a-summer';
 import { ServiceDatabaseAsyncLocalStorage as ServiceDatabaseAsyncLocalStorage$1, ServiceTransactionConsistency‌ as ServiceTransactionConsistency_ } from 'vona-module-a-orm';
+import { ZodMetadata } from '@cabloy/zod-openapi';
 import { mutate } from 'mutate-on-copy';
 import { parseFirstWord, toLowerCaseFirstChar } from '@cabloy/word-utils';
 
+let ScheduleSoftDeletionPrune = class ScheduleSoftDeletionPrune extends BeanBase {
+  async execute() {
+    const onionSlices = this.bean.onion.model.getOnionsEnabledCached();
+    for (const onionSlice of onionSlices) {
+      if (onionSlice.beanOptions.options?.disableDeleted) continue;
+      let softDeletionPrune = onionSlice.beanOptions.options?.softDeletionPrune ?? this.scope.config.softDeletionPrune.enable;
+      if (!softDeletionPrune) continue;
+      if (softDeletionPrune === true) softDeletionPrune = {};
+      await this._modulePrune(onionSlice, softDeletionPrune);
+    }
+  }
+  async _modulePrune(onionSlice, softDeletionPrune) {
+    const handler = softDeletionPrune.handler;
+    const expired = softDeletionPrune.expired ?? this.scope.config.softDeletionPrune.expired;
+    const modelTarget = this.bean._getBean(onionSlice.beanOptions.beanFullName);
+    if (handler) {
+      await handler(this.ctx, modelTarget, {
+        expired
+      });
+    } else {
+      const expiredTime = new Date(Date.now() - expired);
+      await modelTarget.delete({
+        deleted: true,
+        updatedAt: {
+          _lt_: expiredTime
+        }
+      }, {
+        disableDeleted: true
+      });
+    }
+  }
+};
+ScheduleSoftDeletionPrune = __decorate([Schedule({
+  repeat: {
+    every: 24 * 3600 * 1000
+  }
+}), BeanInfo({
+  module: "a-orm"
+})], ScheduleSoftDeletionPrune);
+
 let AopMethodTransaction = class AopMethodTransaction extends BeanAopMethodBase {
   execute(options, _args, next, _receiver, _prop) {
     return this.bean.database.current.transaction.begin(() => {
@@ -781,6 +822,50 @@ BeanDatabase = __decorate([Bean(), BeanInfo({
   module: "a-orm"
 })], BeanDatabase);
 
+function normalizeAggregateValue(value, fn) {
+  if (value === undefined) return value;
+  if (value === null && fn !== 'count') return value;
+  if (typeof value === 'string') {
+    if (fn !== 'count' || /^(0|[1-9]\d*)$/.test(value)) return value;
+  } else if (typeof value === 'number') {
+    if (Number.isFinite(value) && (fn !== 'count' || Number.isSafeInteger(value) && value >= 0)) {
+      return String(value);
+    }
+  } else if (typeof value === 'bigint' && (fn !== 'count' || value >= 0n)) {
+    return String(value);
+  }
+  throw new TypeError(`Invalid ORM ${fn} aggregate result`);
+}
+function normalizeAggregateRows(rows, aggrs) {
+  if (!aggrs || rows.length === 0) return rows;
+  const aliases = [];
+  for (const fn of ['count', 'sum', 'avg', 'min', 'max']) {
+    const columns = aggrs[fn];
+    if (columns === undefined) continue;
+    for (const column of typeof columns === 'object' ? columns : [columns]) {
+      aliases.push([`${fn}_${column === '*' ? 'all' : String(column)}`, fn]);
+    }
+  }
+  let result = rows;
+  for (const [index, row] of rows.entries()) {
+    let target = row;
+    for (const [alias, fn] of aliases) {
+      if (!Object.hasOwn(row, alias)) continue;
+      const value = row[alias];
+      const normalized = normalizeAggregateValue(value, fn);
+      if (value === normalized) continue;
+      if (target === row) target = {
+        ...row
+      };
+      target[alias] = normalized;
+    }
+    if (target === row) continue;
+    if (result === rows) result = [...rows];
+    result[index] = target;
+  }
+  return result;
+}
+
 const OpAggrs = ['count', 'sum', 'avg', 'max', 'min'];
 const OpJoint = {
   and: '_and_',
@@ -1068,6 +1153,8 @@ function _safeColumn(column) {
   return column.replace(/[\\.#%'"`;,() ]/g, '');
 }
 
+const SymbolDtoMutateRelations = Symbol('SymbolDtoMutateRelations');
+
 const app$1 = useApp();
 const ormConfig$1 = app$1.util.getModuleConfigRaw('a-orm');
 const ordersDefault = ormConfig$1?.rest?.query?.orders?.default ?? 'createdAt,desc';
@@ -1764,7 +1851,8 @@ class BeanModelCrudInner extends BeanModelView {
       }
       return `model.select: ${tip}, ${builder.toQuery()}`;
     });
-    return await this.dialect.select(builder, datas, () => this.columns(table));
+    const rows = await this.dialect.select(builder, datas, () => this.columns(table));
+    return normalizeAggregateRows(rows, params?.aggrs);
   }
   _select_buildParams(table, params, options) {
     // builder
@@ -1827,7 +1915,7 @@ class BeanModelCrudInner extends BeanModelView {
     // ready
     this.$loggerChild('model').debug(() => `model.count: ${builder.toQuery()}`);
     const res = await builder;
-    return this.extractFirstNumber(res);
+    return normalizeAggregateValue(this.extractFirstValue(res), 'count');
   }
   async _increment(table, params, options) {
     // table
@@ -3080,46 +3168,6 @@ QueueDoubleDelete = __decorate([Queue({
   module: "a-orm"
 })], QueueDoubleDelete);
 
-let ScheduleSoftDeletionPrune = class ScheduleSoftDeletionPrune extends BeanBase {
-  async execute() {
-    const onionSlices = this.bean.onion.model.getOnionsEnabledCached();
-    for (const onionSlice of onionSlices) {
-      if (onionSlice.beanOptions.options?.disableDeleted) continue;
-      let softDeletionPrune = onionSlice.beanOptions.options?.softDeletionPrune ?? this.scope.config.softDeletionPrune.enable;
-      if (!softDeletionPrune) continue;
-      if (softDeletionPrune === true) softDeletionPrune = {};
-      await this._modulePrune(onionSlice, softDeletionPrune);
-    }
-  }
-  async _modulePrune(onionSlice, softDeletionPrune) {
-    const handler = softDeletionPrune.handler;
-    const expired = softDeletionPrune.expired ?? this.scope.config.softDeletionPrune.expired;
-    const modelTarget = this.bean._getBean(onionSlice.beanOptions.beanFullName);
-    if (handler) {
-      await handler(this.ctx, modelTarget, {
-        expired
-      });
-    } else {
-      const expiredTime = new Date(Date.now() - expired);
-      await modelTarget.delete({
-        deleted: true,
-        updatedAt: {
-          _lt_: expiredTime
-        }
-      }, {
-        disableDeleted: true
-      });
-    }
-  }
-};
-ScheduleSoftDeletionPrune = __decorate([Schedule({
-  repeat: {
-    every: 24 * 3600 * 1000
-  }
-}), BeanInfo({
-  module: "a-orm"
-})], ScheduleSoftDeletionPrune);
-
 function config(_app) {
   return {
     sharding: {
@@ -3332,6 +3380,255 @@ ScopeModuleAOrm = __decorate([Scope(), BeanInfo({
 })], ScopeModuleAOrm);
 /** scope: end */
 
+const analysisFunctions = ['count', 'sum', 'avg', 'min', 'max'];
+const analysisReservedFields = new Set(['groups', 'aggrs', 'where', 'joins', 'having', 'columns', 'orders', 'limit', 'offset', 'pageNo', 'pageSize', 'distinct', 'include', 'with']);
+/** A deliberate validation/resource-bound error, also usable without an application context. */
+class AnalysisError extends Error {
+  constructor(...args) {
+    super(...args);
+    this.code = 422;
+    this.status = 422;
+  }
+}
+function analysisFailure(message) {
+  throw new AnalysisError(message);
+}
+function actionDefaults(policy, mode) {
+  if (mode !== 'group' && mode !== 'aggregate') analysisFailure('Unknown analysis action');
+  const defaults = policy.defaults[mode];
+  if (!defaults) analysisFailure(`Analysis ${mode} action is not enabled`);
+  return defaults;
+}
+function columnArray(columns, max) {
+  return z.array(z.enum([...columns])).min(1).max(max).superRefine((value, ctx) => {
+    if (new Set(value).size !== value.length) {
+      ctx.addIssue({
+        code: 'custom',
+        message: 'Duplicate analysis columns are not allowed'
+      });
+    }
+  });
+}
+/** Native array/object schemas preserve finite enums for query coercion and OpenAPI. */
+function analysisControlSchemas(policy, mode) {
+  const defaults = actionDefaults(policy, mode);
+  const shape = {};
+  for (const fn of analysisFunctions) {
+    const columns = policy.aggrs[fn];
+    if (columns) shape[fn] = columnArray(columns, policy.limits.maxMetrics).optional();
+  }
+  const aggrs = z.strictObject(shape).superRefine((value, ctx) => {
+    const count = Object.values(value).reduce((total, columns) => total + (Array.isArray(columns) ? columns.length : 0), 0);
+    if (count === 0 || count > policy.limits.maxMetrics) {
+      ctx.addIssue({
+        code: 'custom',
+        message: `Analysis requires 1 to ${policy.limits.maxMetrics} metrics`
+      });
+    }
+  }).default(() => Object.fromEntries(Object.entries(defaults.aggrs).map(([fn, columns]) => [fn, [...columns]])));
+  const groups = mode === 'group' ? columnArray(policy.groups, policy.limits.maxGroups).default(() => [...defaults.groups]) : undefined;
+  const selection = z.strictObject({
+    groups: groups ?? z.never().optional(),
+    aggrs
+  });
+  return {
+    groups,
+    aggrs,
+    selection
+  };
+}
+/** Validate controls independently of row filters and ignored list controls. */
+function resolveAnalysis(policy, mode, input) {
+  if (input !== undefined && (!input || typeof input !== 'object' || Array.isArray(input))) {
+    analysisFailure('Analysis parameters must be an object');
+  }
+  const params = input ?? {};
+  for (const key of ['joins', 'having', 'distinct', 'include', 'with']) {
+    if (Object.hasOwn(params, key) && params[key] !== undefined) {
+      analysisFailure(`Analysis does not support ${key}`);
+    }
+  }
+  if (mode === 'aggregate' && Object.hasOwn(params, 'groups')) {
+    analysisFailure('Aggregate analysis does not support groups');
+  }
+  // The request context can enable generic query coercion. Direct service calls must
+  // still supply native arrays/objects, never JSON strings or coerced scalar items.
+  const assertNativeColumns = columns => {
+    if (!Array.isArray(columns) || columns.some(column => typeof column !== 'string')) {
+      analysisFailure('Analysis columns must be arrays of strings');
+    }
+  };
+  if (params.groups !== undefined) assertNativeColumns(params.groups);
+  if (params.aggrs !== undefined) {
+    if (!params.aggrs || typeof params.aggrs !== 'object' || Array.isArray(params.aggrs)) {
+      analysisFailure('Analysis metrics must be an object of column arrays');
+    }
+    for (const columns of Object.values(params.aggrs)) assertNativeColumns(columns);
+  }
+  const parsed = analysisControlSchemas(policy, mode).selection.safeParse({
+    ...(mode === 'group' ? {
+      groups: params.groups
+    } : {}),
+    aggrs: params.aggrs
+  });
+  if (!parsed.success) analysisFailure(parsed.error.message);
+  const result = {
+    aggrs: {}
+  };
+  if (mode === 'group') {
+    // Canonical policy order also stabilizes SQL/cache keys for equivalent selections.
+    const selected = parsed.data.groups;
+    result.groups = policy.groups.filter(column => selected.includes(column));
+  }
+  for (const fn of analysisFunctions) {
+    const selected = parsed.data.aggrs[fn];
+    if (selected) result.aggrs[fn] = policy.aggrs[fn].filter(column => selected.includes(column));
+  }
+  return result;
+}
+function analysisCapabilities(policy, mode) {
+  const defaults = actionDefaults(policy, mode);
+  return {
+    mode,
+    groups: mode === 'group' ? [...policy.groups] : [],
+    aggrs: Object.fromEntries(Object.entries(policy.aggrs).map(([fn, columns]) => [fn, [...columns]])),
+    defaults: {
+      ...(mode === 'group' ? {
+        groups: [...defaults.groups]
+      } : {}),
+      aggrs: Object.fromEntries(Object.entries(defaults.aggrs).map(([fn, columns]) => [fn, [...columns]]))
+    },
+    limits: {
+      ...policy.limits
+    }
+  };
+}
+
+function assertModel(model, policy) {
+  if (!(model instanceof policy.modelClass)) analysisFailure('Analysis policy does not belong to this model');
+}
+/** Keep instance/soft-delete scope, caching and scalar normalization owned by the ORM. */
+async function $executeAnalysisGroup(model, policy, params) {
+  assertModel(model, policy);
+  const {
+    groups,
+    aggrs
+  } = resolveAnalysis(policy, 'group', params);
+  const rows = await model.group({
+    where: params?.where,
+    groups: groups,
+    aggrs,
+    orders: groups.map(column => [column, 'asc']),
+    limit: policy.limits.maxGroupRows + 1
+  });
+  if (rows.length > policy.limits.maxGroupRows) analysisFailure(`Analysis exceeds ${policy.limits.maxGroupRows} group rows`);
+  return rows;
+}
+async function $executeAnalysisAggregate(model, policy, params) {
+  assertModel(model, policy);
+  const {
+    aggrs
+  } = resolveAnalysis(policy, 'aggregate', params);
+  return await model.aggregate({
+    where: params?.where,
+    aggrs
+  });
+}
+
+function invalid(message) {
+  throw new TypeError(`Invalid analysis policy: ${message}`);
+}
+function assertColumns(columns, label, allowEmpty = false) {
+  if (!Array.isArray(columns) || !allowEmpty && columns.length === 0) invalid(`${label} must be a nonempty column array`);
+  if (columns.some(column => typeof column !== 'string')) invalid(`${label} columns must be strings`);
+  if (new Set(columns).size !== columns.length) invalid(`${label} contains duplicate columns`);
+}
+function copyAggrs(aggrs) {
+  return Object.freeze(Object.fromEntries(Object.entries(aggrs).map(([fn, columns]) => [fn, Object.freeze([...columns])])));
+}
+/** Static model/entity metadata only: safe while DTO classes are being evaluated. */
+function $defineAnalysis(modelLike, config) {
+  const modelClass = prepareClassModel(modelLike);
+  const entityClass = getClassEntityFromClassModel(modelClass);
+  const rules = getTargetDecoratorRules(entityClass.prototype, true);
+  assertColumns(config.groups, 'groups', true);
+  const validateField = (column, numeric) => {
+    if (!/^[A-Z_]\w*$/i.test(column) || analysisReservedFields.has(column)) invalid(`unsupported column ${column}`);
+    if (!Object.hasOwn(rules, column)) invalid(`unknown entity column ${column}`);
+    const schema = ZodMetadata.unwrapChained(ZodMetadata.resolveLazySchema(rules[column]));
+    if (numeric && (column === 'id' || column === 'iid' || schema.def.type !== 'number')) invalid(`non-count metrics require numeric columns: ${column}`);
+  };
+  for (const column of config.groups) validateField(column, false);
+  if (!config.aggrs || typeof config.aggrs !== 'object' || Array.isArray(config.aggrs)) invalid('aggrs must be an object');
+  const aliases = new Set(config.groups);
+  let metricCount = 0;
+  for (const [fn, columns] of Object.entries(config.aggrs)) {
+    if (!analysisFunctions.includes(fn)) invalid(`unsupported function ${fn}`);
+    assertColumns(columns, fn);
+    for (const column of columns) {
+      if (column !== '*' || fn !== 'count') validateField(column, fn !== 'count');
+      const alias = `${fn}_${column === '*' ? 'all' : column}`;
+      if (aliases.has(alias) || analysisReservedFields.has(alias)) invalid(`alias collision: ${alias}`);
+      aliases.add(alias);
+      metricCount++;
+    }
+  }
+  if (metricCount === 0) invalid('at least one allowed metric is required');
+  const limits = {
+    maxGroups: 3,
+    maxMetrics: 10,
+    maxGroupRows: 1000,
+    ...config.limits
+  };
+  for (const [key, value] of Object.entries(limits)) {
+    if (!['maxGroups', 'maxMetrics', 'maxGroupRows'].includes(key) || !Number.isSafeInteger(value) || value < 1 || value >= Number.MAX_SAFE_INTEGER) {
+      invalid(`invalid limit ${key}`);
+    }
+  }
+  if (!config.defaults || Object.keys(config.defaults).some(key => key !== 'group' && key !== 'aggregate')) {
+    invalid('unknown or missing action defaults');
+  }
+  if (!config.defaults.group && !config.defaults.aggregate) invalid('at least one action default is required');
+  const policy = {
+    modelLike,
+    modelClass,
+    groups: Object.freeze([...config.groups]),
+    aggrs: copyAggrs(config.aggrs),
+    defaults: {},
+    limits: Object.freeze(limits)
+  };
+  const defaults = {};
+  for (const mode of ['group', 'aggregate']) {
+    const input = config.defaults[mode];
+    if (!input) continue;
+    // Do not allow omitted defaults to expand authorization implicitly.
+    if (!Object.hasOwn(input, 'aggrs') || mode === 'group' && !Object.hasOwn(input, 'groups')) invalid(`incomplete ${mode} defaults`);
+    if (Object.keys(input).some(key => key !== 'aggrs' && !(mode === 'group' && key === 'groups'))) invalid(`unsupported ${mode} default control`);
+    const forValidation = {
+      ...policy,
+      defaults: {
+        [mode]: input
+      }
+    };
+    try {
+      const resolved = resolveAnalysis(forValidation, mode, input);
+      const aggrs = copyAggrs(resolved.aggrs);
+      if (mode === 'group') defaults.group = Object.freeze({
+        groups: Object.freeze(resolved.groups),
+        aggrs
+      });else defaults.aggregate = Object.freeze({
+        aggrs
+      });
+    } catch (error) {
+      invalid(`${mode} defaults: ${error.message}`);
+    }
+  }
+  return Object.freeze({
+    ...policy,
+    defaults: Object.freeze(defaults)
+  });
+}
+
 function DatabaseDialect(options) {
   return createBeanDecorator('databaseDialect', options);
 }
@@ -3349,7 +3646,7 @@ function _DtoAggregate_inner(classTarget, _modelLike, aggrs) {
     if (!columns) continue;
     for (const column of columns) {
       const column2 = `${key}_${column === '*' ? 'all' : column}`;
-      Api.field(v.optional(), z.string())(classTarget.prototype, column2);
+      Api.field(v.optional(), key === 'count' ? z.string() : z.string().nullable())(classTarget.prototype, column2);
     }
   }
   return classTarget;
@@ -3377,6 +3674,19 @@ function _DtoGroup_raw(modelLike, groups, aggrs, columns) {
   return TargetClass;
 }
 
+/** A finite optional superset: absent fields are unrequested, null retains SQL meaning. */
+function DtoAnalysisGroup(policy) {
+  if (!policy.defaults.group) throw new TypeError('Analysis group action is not enabled');
+  const base = DtoGroup(policy.modelLike, [...policy.groups], policy.aggrs);
+  return $Class.partial(base);
+}
+function DtoAnalysisAggregate(policy) {
+  if (!policy.defaults.aggregate) throw new TypeError('Analysis aggregate action is not enabled');
+  class TargetClass {}
+  // Aggregate aliases deliberately do not copy field validators/renderers from source columns.
+  return _DtoAggregate_inner(TargetClass, policy.modelLike, policy.aggrs);
+}
+
 function DtoGet(modelLike, params) {
   return _DtoGet_raw(modelLike, params);
 }
@@ -3394,10 +3704,25 @@ function _DtoGet_raw(modelLike, params) {
   return entityClass;
 }
 function _DtoGet_relations(modelClass, entityClass, includeWrapper, mutateTypeTopLevel) {
-  // relations
   const relations = _DtoGet_relations_collection(modelClass, includeWrapper);
-  if (!relations) return;
+  // Mapped-class metadata follows the dtoClass field projection, including pick/omit.
+  registerMappedClassMetadataKey(entityClass.prototype, SymbolDtoMutateRelations, {});
+  const retained = appMetadata.getOwnMetadataMap(true, SymbolDtoMutateRelations, entityClass.prototype);
+  if (mutateTypeTopLevel) {
+    const overridden = new Set(relations.map(relation => relation[0]));
+    for (const name in retained) {
+      if (!overridden.has(name)) {
+        _DtoGet_relation_handle(entityClass, retained[name], mutateTypeTopLevel);
+      }
+    }
+  }
   for (const relation of relations) {
+    const [name, definition] = relation;
+    if (mutateTypeTopLevel && definition !== false && (definition.type === 'hasOne' || definition.type === 'hasMany')) {
+      retained[name] = relation;
+    } else {
+      delete retained[name];
+    }
     _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel);
   }
 }
@@ -3623,6 +3948,8 @@ const $Dto = {
   mutate: DtoMutate,
   get: DtoGet,
   aggregate: DtoAggregate,
+  analysisGroup: DtoAnalysisGroup,
+  analysisAggregate: DtoAnalysisAggregate,
   group: DtoGroup,
   query: DtoQuery,
   queryPage: DtoQueryPage,
@@ -3757,7 +4084,7 @@ class BeanModelCache extends BeanModelCrud {
     }
     // insert/update
     const itemsInsertNew = await this.__insertBulk_raw(table, itemsInsert, options);
-    await this.__updateBulk_raw(table, itemsUpdate, options);
+    const idsUpdate = await this.__updateBulk_raw(table, itemsUpdate, options);
     const itemsMutate = itemsInsert.map((item, index) => {
       return Object.assign({}, item, {
         id: cast(itemsInsertNew[index]).id
@@ -3765,7 +4092,7 @@ class BeanModelCache extends BeanModelCrud {
     }).concat(itemsUpdate);
     let itemsMutateResult = itemsInsertNew.concat(itemsUpdate);
     const indexesMutate = indexesInsert.concat(indexesUpdate);
-    itemsMutateResult = await this.relations.handleRelationsMutate(itemsMutateResult, itemsMutate, options, options);
+    itemsMutateResult = await this.__handleRelationsMutateAdmitted(itemsMutateResult, itemsMutate, [...itemsInsertNew.map(item => [cast(item).id]), ...idsUpdate], options);
     let result = [];
     for (let index = 0; index < indexesMutate.length; index++) {
       result[indexesMutate[index]] = itemsMutateResult[index];
@@ -3997,7 +4324,7 @@ class BeanModelCache extends BeanModelCrud {
       },
       db: this.db
     });
-    return items;
+    return normalizeAggregateRows(items, params?.aggrs);
   }
   async get(where, options) {
     const relations = this.relations.handleRelationsCollection(options);
@@ -4106,19 +4433,80 @@ class BeanModelCache extends BeanModelCrud {
     return items[0];
   }
   async updateBulk(items, options) {
-    await this.__updateBulk_raw(undefined, items, options);
-    return await this.relations.handleRelationsMutate(items, items, options, options);
+    const ids = await this.__updateBulk_raw(undefined, items, options);
+    return await this.__handleRelationsMutateAdmitted(items, items, ids, options);
   }
   async __updateBulk_raw(table, items, options) {
-    if (items.length === 0) return;
+    const ids = [];
     for (const item of items) {
-      await this.__update_raw(table, item, options);
+      ids.push(await this.__update_raw(table, item, options));
     }
+    return ids;
+  }
+  async __handleRelationsMutateAdmitted(results, items, ids, options) {
+    const indexes = [];
+    const itemsAdmitted = [];
+    const resultsAdmitted = [];
+    for (let index = 0; index < items.length; index++) {
+      const idsItem = ids[index];
+      if (!idsItem || idsItem.length !== 1) continue;
+      indexes.push(index);
+      itemsAdmitted.push(Object.assign({}, items[index], {
+        id: idsItem[0]
+      }));
+      resultsAdmitted.push(results[index]);
+    }
+    const resultsMutated = await this.relations.handleRelationsMutate(resultsAdmitted, itemsAdmitted, options, options);
+    const result = results.concat();
+    for (let index = 0; index < indexes.length; index++) {
+      result[indexes[index]] = resultsMutated[index];
+    }
+    return result;
+  }
+  __hasWritableRelations(options) {
+    return this.relations.handleRelationsCollection(options).some(([, relation]) => {
+      return relation !== false && relation.type !== 'belongsTo';
+    });
+  }
+  async __selectMutationIds(table, where, options) {
+    // Admission must use current scoped rows, not cached entities or changed-row counts.
+    const items = await super._select(table, {
+      where,
+      columns: ['id']
+    }, options);
+    return items.map(item => cast(item).id);
   }
   async __update_raw(table, data, options) {
     // table
     table = table || this.getTable(data);
     if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    if (this.__hasWritableRelations(options)) {
+      const where = Object.assign({}, options?.where);
+      const dataNew = Object.assign({}, data);
+      let hasId = false;
+      for (const key of ['id', `${table}.id`]) {
+        if (!isNil(dataNew[key])) {
+          cast(where).id = dataNew[key];
+          delete dataNew[key];
+          hasId = true;
+        }
+      }
+      if (!hasId && !options?.where) {
+        throw new Error('id should be specified for update method');
+      }
+      const ids = await this.__selectMutationIds(table, where, options);
+      if (ids.length === 0) return [];
+      await super._update(table, dataNew, {
+        ...options,
+        where: Object.assign({}, where, {
+          id: ids
+        })
+      });
+      if (!this._checkDisableCacheEntityByOptions(options)) {
+        await this.cacheEntityDel(ids, table);
+      }
+      return ids;
+    }
     // check if cache
     if (this._checkDisableCacheEntityByOptions(options)) {
       await super._update(table, data, options);
@@ -4185,15 +4573,28 @@ class BeanModelCache extends BeanModelCrud {
   }
   async __deleteBulk_raw_with_relations(table, ids, options) {
     if (ids.length === 0) return;
-    await this.__delete_raw(table, {
+    const idsDeleted = await this.__delete_raw(table, {
       id: ids
     }, options);
-    await this.relations.handleRelationsDelete(ids, options, options);
+    if (idsDeleted) {
+      await this.relations.handleRelationsDelete(idsDeleted, options, options);
+    }
   }
   async __delete_raw(table, where, options) {
     // table
     table = table || this.getTable(where);
     if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    if (this.__hasWritableRelations(options)) {
+      const ids = await this.__selectMutationIds(table, where, options);
+      if (ids.length === 0) return [];
+      await super._delete(table, Object.assign({}, where, {
+        id: ids
+      }), options);
+      if (!this._checkDisableCacheEntityByOptions(options)) {
+        await this.cacheEntityDel(ids, table);
+      }
+      return ids;
+    }
     // check if cache
     if (this._checkDisableCacheEntityByOptions(options)) {
       return await super._delete(table, where, options);
@@ -4623,5 +5024,5 @@ const $relationMutate = {
   belongsToMany
 };
 
-export { $Dto, $locale, $relation, $relationDynamic, $relationMutate, AopMethodTransaction, BeanDatabase, BeanModel, BeanModelBase, BeanModelMeta, BroadcastColumnsClear, DatabaseDialect, DtoQueryBase, DtoQueryPageBase, Entity, EntityBase, EntityBaseEmpty, EntityBaseInner, EntityBaseSimple, EventClientNameReal, EventColumnsClear, ExtendKnex, ExtendSchemaBuilder, ExtendTableBuilder, HmrEntity, HmrModel, Main, Model, Op, OpAggrs, OpJoint, OpJointValues, OpNormal, OpNormalValues, OpValues, QueueDoubleDelete, ScheduleSoftDeletionPrune, ScopeModuleAOrm, ServiceCacheEntity, ServiceCacheQuery, ServiceColumns, ServiceColumnsCache, ServiceDatabase, ServiceDatabaseAsyncLocalStorage, ServiceDatabaseClient, ServiceDatabaseDialectBase, ServiceDb, ServiceEntityResolver, ServiceModelResolver, ServiceRelations, ServiceTransaction, ServiceTransactionAsyncLocalStorage, ServiceTransactionConsistency‌, ServiceTransactionFiber, ServiceTransactionState, SymbolCacheModelCacheInstances, SymbolCacheModelsClear, SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyFieldsMore, SymbolKeyModelOptions, TransactionIsolationLevelsMap, buildWhere, clearAllCacheModelsClear, clearCacheModelCacheInstance, config, configDefault, errors, getCacheModelCacheInstances, getCacheModelsClear, getClassEntityFromClassModel, getTableOrTableAlias, getTargetColumnName, isRaw, isRef, locales, prepareClassModel, prepareColumns };
+export { $Dto, $defineAnalysis, $executeAnalysisAggregate, $executeAnalysisGroup, $locale, $relation, $relationDynamic, $relationMutate, AnalysisError, AopMethodTransaction, BeanDatabase, BeanModel, BeanModelBase, BeanModelMeta, BroadcastColumnsClear, DatabaseDialect, DtoQueryBase, DtoQueryPageBase, Entity, EntityBase, EntityBaseEmpty, EntityBaseInner, EntityBaseSimple, EventClientNameReal, EventColumnsClear, ExtendKnex, ExtendSchemaBuilder, ExtendTableBuilder, HmrEntity, HmrModel, Main, Model, Op, OpAggrs, OpJoint, OpJointValues, OpNormal, OpNormalValues, OpValues, QueueDoubleDelete, ScheduleSoftDeletionPrune, ScopeModuleAOrm, ServiceCacheEntity, ServiceCacheQuery, ServiceColumns, ServiceColumnsCache, ServiceDatabase, ServiceDatabaseAsyncLocalStorage, ServiceDatabaseClient, ServiceDatabaseDialectBase, ServiceDb, ServiceEntityResolver, ServiceModelResolver, ServiceRelations, ServiceTransaction, ServiceTransactionAsyncLocalStorage, ServiceTransactionConsistency‌, ServiceTransactionFiber, ServiceTransactionState, SymbolCacheModelCacheInstances, SymbolCacheModelsClear, SymbolDtoMutateRelations, SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyFieldsMore, SymbolKeyModelOptions, TransactionIsolationLevelsMap, analysisCapabilities, analysisControlSchemas, analysisFailure, analysisFunctions, analysisReservedFields, buildWhere, clearAllCacheModelsClear, clearCacheModelCacheInstance, config, configDefault, errors, getCacheModelCacheInstances, getCacheModelsClear, getClassEntityFromClassModel, getTableOrTableAlias, getTargetColumnName, isRaw, isRef, locales, prepareClassModel, prepareColumns, resolveAnalysis };
 //# sourceMappingURL=index.js.map