vona-module-a-orm 5.1.39 → 5.1.41

package/src/.metadata/index.ts

@@ -1,4 +1,30 @@
 // eslint-disable
+/** schedule: begin */
+export * from '../bean/schedule.softDeletionPrune.ts';
+
+import { type IDecoratorScheduleOptions } from 'vona-module-a-schedule';
+declare module 'vona-module-a-schedule' {
+
+    export interface IScheduleRecord {
+      'a-orm:softDeletionPrune': IDecoratorScheduleOptions;
+    }
+
+
+}
+declare module 'vona-module-a-orm' {
+
+        export interface ScheduleSoftDeletionPrune {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface ScheduleSoftDeletionPrune {
+            get $beanFullName(): 'a-orm.schedule.softDeletionPrune';
+            get $onionName(): 'a-orm:softDeletionPrune';
+            get $onionOptions(): IDecoratorScheduleOptions;
+          }
+}
+/** schedule: end */
 /** aopMethod: begin */
 export * from '../bean/aopMethod.transaction.ts';
 import type { IAopMethodOptionsTransaction } from '../bean/aopMethod.transaction.ts';
@@ -261,32 +287,6 @@ export interface IModuleQueue {
   'doubleDelete': QueueDoubleDelete;
 }
 /** queue: end */
-/** schedule: begin */
-export * from '../bean/schedule.softDeletionPrune.ts';
-
-import { type IDecoratorScheduleOptions } from 'vona-module-a-schedule';
-declare module 'vona-module-a-schedule' {
-
-    export interface IScheduleRecord {
-      'a-orm:softDeletionPrune': IDecoratorScheduleOptions;
-    }
-
-
-}
-declare module 'vona-module-a-orm' {
-
-        export interface ScheduleSoftDeletionPrune {
-          /** @internal */
-          get scope(): ScopeModuleAOrm;
-        }
-
-          export interface ScheduleSoftDeletionPrune {
-            get $beanFullName(): 'a-orm.schedule.softDeletionPrune';
-            get $onionName(): 'a-orm:softDeletionPrune';
-            get $onionOptions(): IDecoratorScheduleOptions;
-          }
-}
-/** schedule: end */
 /** config: begin */
 export * from '../config/config.ts';
 import type { config } from '../config/config.ts';

package/src/lib/aggregateResult.ts

@@ -0,0 +1,53 @@
+type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+type AggregateSpec = Partial<Record<AggregateFunction, PropertyKey | readonly PropertyKey[]>>;
+
+export function normalizeAggregateValue(value: unknown, fn: 'count'): string | undefined;
+export function normalizeAggregateValue(
+  value: unknown,
+  fn: AggregateFunction,
+): string | null | undefined;
+export function normalizeAggregateValue(
+  value: unknown,
+  fn: AggregateFunction,
+): string | null | undefined {
+  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`);
+}
+
+export function normalizeAggregateRows<T extends {}>(rows: T[], aggrs?: AggregateSpec): T[] {
+  if (!aggrs || rows.length === 0) return rows;
+  const aliases: [string, AggregateFunction][] = [];
+  for (const fn of ['count', 'sum', 'avg', 'min', 'max'] as const) {
+    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 as Record<string, unknown>)[alias];
+      const normalized = normalizeAggregateValue(value, fn);
+      if (value === normalized) continue;
+      if (target === row) target = { ...row };
+      (target as Record<string, unknown>)[alias] = normalized;
+    }
+    if (target === row) continue;
+    if (result === rows) result = [...rows];
+    result[index] = target;
+  }
+  return result;
+}

package/src/lib/analysis/controls.ts

@@ -0,0 +1,163 @@
+import z from 'zod';
+
+import type {
+  IAnalysisCapabilities,
+  IAnalysisPolicy,
+  IAnalysisSelection,
+  IResolvedAnalysis,
+  TypeAnalysisFunction,
+  TypeAnalysisMode,
+} from '../../types/analysis.ts';
+
+export const analysisFunctions = ['count', 'sum', 'avg', 'min', 'max'] as const;
+export 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. */
+export class AnalysisError extends Error {
+  readonly code = 422;
+  readonly status = 422;
+}
+
+export function analysisFailure(message: string): never {
+  throw new AnalysisError(message);
+}
+
+function actionDefaults(policy: IAnalysisPolicy, mode: TypeAnalysisMode): IAnalysisSelection {
+  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: readonly string[], max: number) {
+  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. */
+export function analysisControlSchemas(policy: IAnalysisPolicy, mode: TypeAnalysisMode) {
+  const defaults = actionDefaults(policy, mode);
+  const shape: Partial<Record<TypeAnalysisFunction, z.ZodType>> = {};
+  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<number>(
+        (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. */
+export function resolveAnalysis(
+  policy: IAnalysisPolicy,
+  mode: TypeAnalysisMode,
+  input?: unknown,
+): IResolvedAnalysis {
+  if (input !== undefined && (!input || typeof input !== 'object' || Array.isArray(input))) {
+    analysisFailure('Analysis parameters must be an object');
+  }
+  const params = (input ?? {}) as Record<string, unknown>;
+  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: unknown) => {
+    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: IResolvedAnalysis = { aggrs: {} };
+  if (mode === 'group') {
+    // Canonical policy order also stabilizes SQL/cache keys for equivalent selections.
+    const selected = parsed.data.groups as string[];
+    result.groups = policy.groups.filter(column => selected.includes(column));
+  }
+  for (const fn of analysisFunctions) {
+    const selected = parsed.data.aggrs[fn] as string[] | undefined;
+    if (selected) result.aggrs[fn] = policy.aggrs[fn]!.filter(column => selected.includes(column));
+  }
+  return result;
+}
+
+export function analysisCapabilities(
+  policy: IAnalysisPolicy,
+  mode: TypeAnalysisMode,
+): IAnalysisCapabilities {
+  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 },
+  };
+}

package/src/lib/analysis/execute.ts

@@ -0,0 +1,49 @@
+import type {
+  IAnalysisPolicy,
+  TypeAnalysisAggregateParams,
+  TypeAnalysisAggregateResult,
+  TypeAnalysisGroupParams,
+  TypeAnalysisGroupResult,
+} from '../../types/analysis.ts';
+import type { TypeModelOfModelLike } from '../../types/relations.ts';
+import type { BeanModelCache } from '../bean.model/bean.model_cache.ts';
+
+import { analysisFailure, resolveAnalysis } from './controls.ts';
+
+function assertModel(model: object, policy: IAnalysisPolicy) {
+  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. */
+export async function $executeAnalysisGroup<Policy extends IAnalysisPolicy>(
+  model: TypeModelOfModelLike<Policy['modelLike']>,
+  policy: Policy,
+  params?: TypeAnalysisGroupParams<Policy>,
+): Promise<TypeAnalysisGroupResult<Policy>[]> {
+  assertModel(model, policy);
+  const { groups, aggrs } = resolveAnalysis(policy, 'group', params);
+  const rows = await (model as unknown as BeanModelCache<any>).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 as TypeAnalysisGroupResult<Policy>[];
+}
+
+export async function $executeAnalysisAggregate<Policy extends IAnalysisPolicy>(
+  model: TypeModelOfModelLike<Policy['modelLike']>,
+  policy: Policy,
+  params?: TypeAnalysisAggregateParams<Policy>,
+): Promise<TypeAnalysisAggregateResult<Policy>> {
+  assertModel(model, policy);
+  const { aggrs } = resolveAnalysis(policy, 'aggregate', params);
+  return (await (model as unknown as BeanModelCache<any>).aggregate({
+    where: params?.where,
+    aggrs,
+  })) as TypeAnalysisAggregateResult<Policy>;
+}

package/src/lib/analysis/index.ts

@@ -0,0 +1,3 @@
+export * from './controls.ts';
+export * from './execute.ts';
+export * from './policy.ts';

package/src/lib/analysis/policy.ts

@@ -0,0 +1,140 @@
+import { ZodMetadata } from '@cabloy/zod-openapi';
+import { getTargetDecoratorRules } from 'vona-module-a-openapiutils';
+
+import type {
+  IAnalysisConfig,
+  IAnalysisPolicy,
+  TypeAnalysisAggrs,
+  TypeAnalysisAllowedAggrs,
+  TypeAnalysisEntity,
+  TypeAnalysisField,
+  TypeAnalysisFunction,
+  TypeAnalysisModelLike,
+  TypeAnalysisPolicy,
+} from '../../types/analysis.ts';
+
+import { getClassEntityFromClassModel, prepareClassModel } from '../../common/utils.ts';
+import { analysisFunctions, analysisReservedFields, resolveAnalysis } from './controls.ts';
+
+function invalid(message: string): never {
+  throw new TypeError(`Invalid analysis policy: ${message}`);
+}
+
+function assertColumns(
+  columns: unknown,
+  label: string,
+  allowEmpty = false,
+): asserts columns is string[] {
+  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: TypeAnalysisAggrs): TypeAnalysisAggrs {
+  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. */
+export function $defineAnalysis<
+  ModelLike extends TypeAnalysisModelLike,
+  const Groups extends readonly TypeAnalysisField<TypeAnalysisEntity<ModelLike>>[],
+  const Aggrs extends TypeAnalysisAllowedAggrs<TypeAnalysisEntity<ModelLike>>,
+>(
+  modelLike: ModelLike,
+  config: IAnalysisConfig<Groups, Aggrs> & {
+    aggrs: Aggrs & Record<Exclude<keyof Aggrs, TypeAnalysisFunction>, never>;
+  },
+): TypeAnalysisPolicy<ModelLike, Groups, Aggrs> {
+  const modelClass = prepareClassModel(modelLike as any);
+  const entityClass = getClassEntityFromClassModel(modelClass);
+  const rules = getTargetDecoratorRules(entityClass.prototype, true);
+  assertColumns(config.groups, 'groups', true);
+  const validateField = (column: string, numeric: boolean) => {
+    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<string>(config.groups);
+  let metricCount = 0;
+  for (const [fn, columns] of Object.entries(config.aggrs)) {
+    if (!analysisFunctions.includes(fn as TypeAnalysisFunction))
+      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: IAnalysisPolicy = {
+    modelLike,
+    modelClass,
+    groups: Object.freeze([...config.groups]),
+    aggrs: copyAggrs(config.aggrs),
+    defaults: {},
+    limits: Object.freeze(limits),
+  };
+  const defaults: {
+    group?: IAnalysisPolicy['defaults']['group'];
+    aggregate?: IAnalysisPolicy['defaults']['aggregate'];
+  } = {};
+  for (const mode of ['group', 'aggregate'] as const) {
+    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 } } as IAnalysisPolicy;
+    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 as Error).message}`);
+    }
+  }
+  return Object.freeze({ ...policy, defaults: Object.freeze(defaults) }) as TypeAnalysisPolicy<
+    ModelLike,
+    Groups,
+    Aggrs
+  >;
+}

package/src/lib/bean.model/bean.model_cache.ts

@@ -20,6 +20,7 @@ import type {
   IModelSelectAggrParams,
   IModelSelectCountParams,
   IModelSelectGroupParams,
+  IModelSelectGeneralParams,
   IModelSelectParams,
   IModelUpdateOptions,
   ITableRecord,
@@ -34,6 +35,7 @@ import type {
 } from '../../types/index.ts';
 
 import { getTargetColumnName } from '../../common/utils.ts';
+import { normalizeAggregateRows } from '../../lib/aggregateResult.ts';
 import { getCacheModelsClear } from '../../lib/const.ts';
 import { ServiceCacheEntity } from '../../service/cacheEntity_.ts';
 import { ServiceCacheQuery } from '../../service/cacheQuery_.ts';
@@ -152,7 +154,7 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     }
     // 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 });
@@ -160,10 +162,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
       .concat(itemsUpdate as any);
     let itemsMutateResult = itemsInsertNew.concat(itemsUpdate as any);
     const indexesMutate = indexesInsert.concat(indexesUpdate);
-    itemsMutateResult = await this.relations.handleRelationsMutate(
+    itemsMutateResult = await this.__handleRelationsMutateAdmitted(
       itemsMutateResult,
       itemsMutate as any,
-      options as any,
+      [...itemsInsertNew.map(item => [cast(item).id]), ...idsUpdate],
       options,
     );
     let result: TRecord[] = [];
@@ -425,7 +427,7 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
 
   private async __select_cache(
     table: keyof ITableRecord,
-    params?: IModelSelectParams<TRecord>,
+    params?: IModelSelectParams<TRecord> & Pick<IModelSelectGeneralParams<TRecord>, 'aggrs'>,
     options?: IModelMethodOptions,
   ): Promise<TRecord[]> {
     // check if cache
@@ -445,7 +447,7 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
       },
       db: this.db,
     });
-    return items;
+    return normalizeAggregateRows(items, params?.aggrs);
   }
 
   async get<T extends IModelGetOptions<TRecord>>(
@@ -586,19 +588,65 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     items: Partial<TRecord>[],
     options?: T,
   ): Promise<Partial<TRecord>[]> {
-    await this.__updateBulk_raw(undefined, items, options);
-    return await this.relations.handleRelationsMutate(items, items, options as any, options);
+    const ids = await this.__updateBulk_raw(undefined, items, options);
+    return await this.__handleRelationsMutateAdmitted(items, items, ids, options);
   }
 
   async __updateBulk_raw<T extends IModelUpdateOptions<TRecord>>(
     table: keyof ITableRecord | undefined,
     items: Partial<TRecord>[],
     options?: T,
-  ): Promise<void> {
-    if (items.length === 0) return;
+  ): Promise<(TableIdentity[] | void)[]> {
+    const ids: (TableIdentity[] | void)[] = [];
     for (const item of items) {
-      await this.__update_raw(table, item, options);
+      ids.push(await this.__update_raw(table, item, options));
     }
+    return ids;
+  }
+
+  private async __handleRelationsMutateAdmitted<TResult extends {}>(
+    results: TResult[],
+    items: Partial<TRecord>[],
+    ids: (TableIdentity[] | void)[],
+    options?: IModelMutateOptions<TRecord>,
+  ): Promise<TResult[]> {
+    const indexes: number[] = [];
+    const itemsAdmitted: Partial<TRecord>[] = [];
+    const resultsAdmitted: TResult[] = [];
+    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 as any,
+      options as any,
+      options,
+    );
+    const result = results.concat();
+    for (let index = 0; index < indexes.length; index++) {
+      result[indexes[index]] = resultsMutated[index];
+    }
+    return result;
+  }
+
+  private __hasWritableRelations(options?: IModelMutateOptions<TRecord>) {
+    return this.relations.handleRelationsCollection(options as any).some(([, relation]) => {
+      return relation !== false && relation.type !== 'belongsTo';
+    });
+  }
+
+  private async __selectMutationIds(
+    table: keyof ITableRecord,
+    where: TypeModelWhere<TRecord> | undefined,
+    options?: IModelMethodOptionsGeneral,
+  ): Promise<TableIdentity[]> {
+    // Admission must use current scoped rows, not cached entities or changed-row counts.
+    const items = await super._select(table, { where, columns: ['id'] as any }, options);
+    return items.map(item => cast(item).id);
   }
 
   async __update_raw(
@@ -609,6 +657,31 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     // 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);
@@ -677,8 +750,10 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     options?: T,
   ): Promise<void> {
     if (ids.length === 0) return;
-    await this.__delete_raw(table, { id: ids } as any, options);
-    await this.relations.handleRelationsDelete(ids, options as any, options);
+    const idsDeleted = await this.__delete_raw(table, { id: ids } as any, options);
+    if (idsDeleted) {
+      await this.relations.handleRelationsDelete(idsDeleted, options as any, options);
+    }
   }
 
   async __delete_raw(
@@ -689,6 +764,15 @@ export class BeanModelCache<TRecord extends {} = {}> extends BeanModelCrud<TReco
     // 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);