vona-module-a-orm 5.1.39 → 5.1.41

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

@@ -18,6 +18,7 @@ import type {
   TypeModelWhere,
 } from '../../types/index.ts';
 
+import { normalizeAggregateRows, normalizeAggregateValue } from '../aggregateResult.ts';
 import { BeanModelView } from './bean.model_view.ts';
 
 export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecord> {
@@ -66,7 +67,8 @@ export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecor
   }
 
   protected async _select<
-    T extends IModelSelectParams<TRecord> | IBuildModelSelectParams<TRecord, undefined, never>,
+    T extends (IModelSelectParams<TRecord> | IBuildModelSelectParams<TRecord, undefined, never>) &
+      Pick<IModelSelectGeneralParams<TRecord>, 'aggrs'>,
   >(
     table?: keyof ITableRecord,
     params?: T,
@@ -89,7 +91,10 @@ export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecor
       }
       return `model.select: ${tip}, ${builder.toQuery()}`;
     });
-    return (await this.dialect.select(builder, datas, () => this.columns(table))) as TRecord[];
+    const rows = (await this.dialect.select(builder, datas, () =>
+      this.columns(table),
+    )) as TRecord[];
+    return normalizeAggregateRows(rows, params?.aggrs);
   }
 
   protected _select_buildParams<T extends IModelSelectGeneralParams<TRecord>>(
@@ -164,7 +169,7 @@ export class BeanModelCrudInner<TRecord extends {}> extends BeanModelView<TRecor
     // ready
     this.$loggerChild('model').debug(() => `model.count: ${builder.toQuery()}`);
     const res = await builder;
-    return this.extractFirstNumber(res);
+    return normalizeAggregateValue(this.extractFirstValue(res), 'count');
   }
 
   protected async _increment(

package/src/lib/dto/dto.ts

@@ -1,4 +1,5 @@
 import { DtoAggregate } from './dtoAggregate.ts';
+import { DtoAnalysisAggregate, DtoAnalysisGroup } from './dtoAnalysis.ts';
 import { DtoCreate } from './dtoCreate.ts';
 import { DtoGet } from './dtoGet.ts';
 import { DtoGroup } from './dtoGroup.ts';
@@ -15,6 +16,8 @@ export const $Dto = {
   mutate: DtoMutate,
   get: DtoGet,
   aggregate: DtoAggregate,
+  analysisGroup: DtoAnalysisGroup,
+  analysisAggregate: DtoAnalysisAggregate,
   group: DtoGroup,
   query: DtoQuery,
   queryPage: DtoQueryPage,

package/src/lib/dto/dtoAggregate.ts

@@ -56,7 +56,10 @@ export function _DtoAggregate_inner<
     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 as any;

package/src/lib/dto/dtoAnalysis.ts

@@ -0,0 +1,34 @@
+import type { Constructable } from 'vona';
+
+import { $Class } from 'vona';
+
+import type {
+  IAnalysisPolicy,
+  TypeAnalysisAggregateResult,
+  TypeAnalysisGroupResult,
+} from '../../types/analysis.ts';
+
+import { _DtoAggregate_inner } from './dtoAggregate.ts';
+import { DtoGroup } from './dtoGroup.ts';
+
+/** A finite optional superset: absent fields are unrequested, null retains SQL meaning. */
+export function DtoAnalysisGroup<Policy extends IAnalysisPolicy>(
+  policy: Policy,
+): Constructable<TypeAnalysisGroupResult<Policy>> {
+  if (!policy.defaults.group) throw new TypeError('Analysis group action is not enabled');
+  const base = DtoGroup(policy.modelLike as any, [...policy.groups] as any, policy.aggrs as any);
+  return $Class.partial(base) as Constructable<TypeAnalysisGroupResult<Policy>>;
+}
+
+export function DtoAnalysisAggregate<Policy extends IAnalysisPolicy>(
+  policy: Policy,
+): Constructable<TypeAnalysisAggregateResult<Policy>> {
+  if (!policy.defaults.aggregate) throw new TypeError('Analysis aggregate action is not enabled');
+  abstract class TargetClass {}
+  // Aggregate aliases deliberately do not copy field validators/renderers from source columns.
+  return _DtoAggregate_inner(
+    TargetClass as any,
+    policy.modelLike as any,
+    policy.aggrs as any,
+  ) as Constructable<TypeAnalysisAggregateResult<Policy>>;
+}

package/src/lib/dto/dtoCreate.ts

@@ -2,7 +2,7 @@ import type { Constructable } from 'vona';
 
 import { mergeTargetDecoratorDtoOpenapi } from 'vona-module-a-openapiutils';
 
-import type { IDtoMutateParams, TypeDtoMutateResult } from '../../types/dto/dtoMutate.ts';
+import type { IDtoMutateParams, TypeDtoMutateClass } from '../../types/dto/dtoMutate.ts';
 import type { IModelClassRecord } from '../../types/onion/model.ts';
 import type { BeanModelMeta } from '../bean.model/bean.model_meta.ts';
 
@@ -16,14 +16,12 @@ export function DtoCreate<
     ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
     : ModelLike,
   params?: T,
-): Constructable<
-  TypeDtoMutateResult<
-    ModelLike,
-    T,
-    'create',
-    'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt',
-    true
-  >
+): TypeDtoMutateClass<
+  ModelLike,
+  T,
+  'create',
+  'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt',
+  true
 > {
   const dtoClass = _DtoMutate_raw(
     modelLike,

package/src/lib/dto/dtoGet.ts

@@ -1,7 +1,7 @@
 import type { Constructable } from 'vona';
 
 import { ensureArray, hashkey } from '@cabloy/utils';
-import { $Class, appResource } from 'vona';
+import { $Class, appMetadata, appResource, registerMappedClassMetadataKey } from 'vona';
 import {
   addSchemaDynamic,
   Api,
@@ -24,6 +24,7 @@ import {
   prepareClassModel,
   prepareColumns,
 } from '../../common/utils.ts';
+import { SymbolDtoMutateRelations } from '../../types/dto/dtoMutate.ts';
 import { handleRelationsCollection } from '../utils.ts';
 import { DtoAggregate } from './dtoAggregate.ts';
 import { DtoGroup } from './dtoGroup.ts';
@@ -63,10 +64,33 @@ export function _DtoGet_relations<TRecord extends {}, TModel extends BeanModelMe
   includeWrapper?: IModelRelationIncludeWrapper,
   mutateTypeTopLevel?: TypeDtoMutateType,
 ) {
-  // 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<string, IRelationItem>(
+    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);
   }
 }

package/src/lib/dto/dtoMutate.ts

@@ -6,7 +6,7 @@ import { getTargetDecoratorRuleColumns } from 'vona-module-a-openapiutils';
 
 import type {
   IDtoMutateParams,
-  TypeDtoMutateResult,
+  TypeDtoMutateClass,
   TypeDtoMutateType,
 } from '../../types/dto/dtoMutate.ts';
 import type { TypeModelColumnsStrict } from '../../types/modelWhere.ts';
@@ -30,7 +30,7 @@ export function DtoMutate<
     ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
     : ModelLike,
   params?: T,
-): Constructable<TypeDtoMutateResult<ModelLike, T, 'mutate', undefined, true>> {
+): TypeDtoMutateClass<ModelLike, T, 'mutate', undefined, true> {
   return _DtoMutate_raw(modelLike, params, 'mutate', undefined, true, undefined);
 }
 

package/src/lib/dto/dtoUpdate.ts

@@ -2,7 +2,7 @@ import type { Constructable } from 'vona';
 
 import { mergeTargetDecoratorDtoOpenapi } from 'vona-module-a-openapiutils';
 
-import type { IDtoMutateParams, TypeDtoMutateResult } from '../../types/dto/dtoMutate.ts';
+import type { IDtoMutateParams, TypeDtoMutateClass } from '../../types/dto/dtoMutate.ts';
 import type { IModelClassRecord } from '../../types/onion/model.ts';
 import type { BeanModelMeta } from '../bean.model/bean.model_meta.ts';
 
@@ -16,14 +16,12 @@ export function DtoUpdate<
     ? (() => Constructable<ModelLike>) | Constructable<ModelLike>
     : ModelLike,
   params?: T,
-): Constructable<
-  TypeDtoMutateResult<
-    ModelLike,
-    T,
-    'update',
-    'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt',
-    true
-  >
+): TypeDtoMutateClass<
+  ModelLike,
+  T,
+  'update',
+  'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt',
+  true
 > {
   const dtoClass = _DtoMutate_raw(
     modelLike,

package/src/lib/index.ts

@@ -1,3 +1,4 @@
+export * from './analysis/index.ts';
 export * from './const.ts';
 export * from './databaseDialect.ts';
 export * from './dto/index.ts';

package/src/types/analysis.ts

@@ -0,0 +1,137 @@
+import type { Constructable } from 'vona';
+
+import type { BeanModelMeta } from '../lib/bean.model/bean.model_meta.ts';
+import type { TypeModelWhere } from './modelWhere.ts';
+import type { IModelClassRecord } from './onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from './relations.ts';
+
+export type TypeAnalysisMode = 'group' | 'aggregate';
+export type TypeAnalysisFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+export type TypeAnalysisModelLike =
+  | Constructable<BeanModelMeta>
+  | (() => Constructable<BeanModelMeta>)
+  | keyof IModelClassRecord;
+export type TypeAnalysisEntity<ModelLike extends TypeAnalysisModelLike> =
+  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity];
+export type TypeAnalysisField<Entity> = Extract<keyof Entity, string>;
+export type TypeAnalysisNumericField<Entity> = Exclude<
+  {
+    [K in keyof Entity]-?: NonNullable<Entity[K]> extends number ? K : never;
+  }[keyof Entity],
+  'id' | 'iid'
+> &
+  string;
+
+export type TypeAnalysisAggrs = Partial<Record<TypeAnalysisFunction, readonly string[]>>;
+export type TypeAnalysisAllowedAggrs<Entity> = {
+  readonly count?: readonly ('*' | TypeAnalysisField<Entity>)[];
+} & {
+  readonly [
+    K in Exclude<TypeAnalysisFunction, 'count'>
+  ]?: readonly TypeAnalysisNumericField<Entity>[];
+};
+export type TypeAnalysisSelectionAggrs<Aggrs extends TypeAnalysisAggrs> = {
+  readonly [K in keyof Aggrs]?: NonNullable<Aggrs[K]> extends readonly string[]
+    ? readonly NonNullable<Aggrs[K]>[number][]
+    : never;
+};
+export interface IAnalysisLimits {
+  readonly maxGroups: number;
+  readonly maxMetrics: number;
+  readonly maxGroupRows: number;
+}
+export interface IAnalysisSelection {
+  readonly groups?: readonly string[];
+  readonly aggrs: TypeAnalysisAggrs;
+}
+
+/** Structural server-owned policy surface; model references must not be serialized. */
+export interface IAnalysisPolicy {
+  readonly modelLike: TypeAnalysisModelLike;
+  readonly modelClass: Constructable<BeanModelMeta>;
+  readonly groups: readonly string[];
+  readonly aggrs: TypeAnalysisAggrs;
+  readonly defaults: {
+    readonly group?: IAnalysisSelection & { readonly groups: readonly string[] };
+    readonly aggregate?: { readonly aggrs: TypeAnalysisAggrs };
+  };
+  readonly limits: IAnalysisLimits;
+}
+export type TypeAnalysisPolicy<
+  ModelLike extends TypeAnalysisModelLike,
+  Groups extends readonly string[],
+  Aggrs extends TypeAnalysisAggrs,
+> = Omit<IAnalysisPolicy, 'modelLike' | 'groups' | 'aggrs'> & {
+  readonly modelLike: ModelLike;
+  readonly groups: Groups;
+  readonly aggrs: Aggrs;
+};
+export interface IAnalysisConfig<
+  Groups extends readonly string[],
+  Aggrs extends TypeAnalysisAggrs,
+> {
+  readonly groups: Groups;
+  readonly aggrs: Aggrs;
+  readonly defaults: {
+    readonly group?: {
+      readonly groups: readonly NoInfer<Groups[number]>[];
+      readonly aggrs: TypeAnalysisSelectionAggrs<NoInfer<Aggrs>>;
+    };
+    readonly aggregate?: { readonly aggrs: TypeAnalysisSelectionAggrs<NoInfer<Aggrs>> };
+  };
+  readonly limits?: Partial<IAnalysisLimits>;
+}
+
+interface IAnalysisParams<Policy extends IAnalysisPolicy> {
+  where?: TypeModelWhere<TypeAnalysisEntity<Policy['modelLike']>>;
+  aggrs?: TypeAnalysisSelectionAggrs<Policy['aggrs']>;
+  // Existing list controls remain accepted but never drive analysis execution.
+  columns?: unknown;
+  orders?: unknown;
+  limit?: number;
+  offset?: number;
+  pageNo?: number;
+  pageSize?: number;
+  joins?: never;
+  having?: never;
+  distinct?: never;
+  include?: never;
+  with?: never;
+}
+export type TypeAnalysisGroupParams<Policy extends IAnalysisPolicy> = IAnalysisParams<Policy> & {
+  groups?: readonly Policy['groups'][number][];
+};
+export type TypeAnalysisAggregateParams<Policy extends IAnalysisPolicy> =
+  IAnalysisParams<Policy> & {
+    groups?: never;
+  };
+
+type TypeAnalysisAlias<Column extends string> = Column extends '*' ? 'all' : Column;
+export type TypeAnalysisAggregateResult<Policy extends IAnalysisPolicy> = {
+  -readonly [
+    Fn in keyof Policy['aggrs'] &
+      TypeAnalysisFunction as Policy['aggrs'][Fn] extends readonly string[]
+      ? `${Fn}_${TypeAnalysisAlias<Policy['aggrs'][Fn][number]>}`
+      : never
+  ]?: Fn extends 'count' ? string : string | null;
+};
+export type TypeAnalysisGroupResult<Policy extends IAnalysisPolicy> = Partial<
+  Pick<
+    TypeAnalysisEntity<Policy['modelLike']>,
+    Extract<Policy['groups'][number], keyof TypeAnalysisEntity<Policy['modelLike']>>
+  >
+> &
+  TypeAnalysisAggregateResult<Policy>;
+
+export interface IAnalysisCapabilities {
+  readonly mode: TypeAnalysisMode;
+  readonly groups: readonly string[];
+  readonly aggrs: TypeAnalysisAggrs;
+  readonly defaults: IAnalysisSelection;
+  readonly limits: IAnalysisLimits;
+}
+
+export interface IResolvedAnalysis {
+  groups?: string[];
+  aggrs: Partial<Record<TypeAnalysisFunction, string[]>>;
+}

package/src/types/dto/dtoMutate.ts

@@ -25,8 +25,33 @@ import type {
   TypeUtilPrepareColumns,
 } from '../relations.ts';
 
+export const SymbolDtoMutateRelations = Symbol('SymbolDtoMutateRelations');
+
 export type TypeDtoMutateType = 'create' | 'update' | 'mutate';
 
+// Static phantom metadata survives ordinary subclassing without becoming a DTO field.
+// Runtime stores the corresponding resolved relation plans as mapped-class metadata.
+export type TypeDtoMutateClass<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  TOptionsRelation,
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  TColumnsOmitDefault extends string | string[] | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+> = Constructable<
+  TypeDtoMutateResult<
+    ModelLike,
+    TOptionsRelation,
+    TMutateTypeTopLevel,
+    TColumnsOmitDefault,
+    TTopLevel
+  >
+> & {
+  [SymbolDtoMutateRelations]?: TypeDtoMutateOwnedRelations<
+    TypeModelOfModelLike<ModelLike>,
+    TOptionsRelation
+  >;
+};
+
 export type IDtoMutateParams<ModelLike extends BeanModelMeta | keyof IModelClassRecord> =
   IBuildDtoMutateParams<
     TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
@@ -65,100 +90,112 @@ export type TypeDtoMutateRelationResult<
   TTopLevel extends boolean | undefined = undefined,
   TColumns = undefined,
   REFKEY = undefined,
-> = (TOptionsRelation extends { dtoClass: Constructable<infer TDto> }
-  ? TypeDtoMutateRelationResultDto<TDto, TMutateTypeTopLevel, TTopLevel, REFKEY>
-  : TypeDtoMutateRelationResultEntity<
-      TRecord,
-      TColumns extends string | string[] ? TColumns : TypeUtilGetParamsColumns<TOptionsRelation>,
-      TMutateTypeTopLevel,
-      TColumnsOmitDefault,
-      TTopLevel,
-      REFKEY
-    >) &
-  (TModel extends BeanModelMeta
-    ? OmitNever<
-        TypeDtoMutateRelationResultMergeInclude<
-          TMutateTypeTopLevel,
-          TypeUtilGetModelOptions<TModel>,
-          TypeUtilGetParamsInlcude<TOptionsRelation>
-        >
-      > &
-        OmitNever<
-          TypeDtoMutateModelRelationResultMergeWith<
-            TMutateTypeTopLevel,
-            TypeUtilGetParamsWith<TOptionsRelation>
-          >
-        >
-    : {});
-
-type TypeDtoMutateRelationResultMergeInclude<
-  TMutateTypeTopLevel extends TypeDtoMutateType,
-  TModelOptions extends IDecoratorModelOptions,
-  TInclude extends {} | undefined | unknown,
-> = {
-  [RelationName in keyof TModelOptions['relations']]: TInclude extends {}
-    ? TInclude[RelationName] extends {} | boolean
-      ? TypeDtoMutateRelationResultMergeIncludeWrapper<
-          TMutateTypeTopLevel,
-          TModelOptions['relations'][RelationName],
-          TInclude[RelationName]
-        >
-      : TypeDtoMutateRelationResultMergeAutoload<
-          TMutateTypeTopLevel,
-          TModelOptions['relations'][RelationName]
-        >
-    : TypeDtoMutateRelationResultMergeAutoload<
+> = TypeDtoMutateMergeRelations<
+  TOptionsRelation extends { dtoClass: Constructable<infer TDto> }
+    ? TypeDtoMutateRelationResultDto<TDto, TMutateTypeTopLevel, TTopLevel, REFKEY>
+    : TypeDtoMutateRelationResultEntity<
+        TRecord,
+        TColumns extends string | string[] ? TColumns : TypeUtilGetParamsColumns<TOptionsRelation>,
         TMutateTypeTopLevel,
-        TModelOptions['relations'][RelationName]
-      >;
-};
+        TColumnsOmitDefault,
+        TTopLevel,
+        REFKEY
+      >,
+  TypeDtoMutateRelationPlans<TModel, TOptionsRelation>,
+  TMutateTypeTopLevel
+>;
 
-type TypeDtoMutateModelRelationResultMergeWith<
-  TMutateTypeTopLevel extends TypeDtoMutateType,
-  TWith extends {} | undefined | unknown,
-> = TWith extends {}
-  ? {
-      [RelationName in keyof TWith]: TypeDtoMutateRelationResultMergeWithRelation<
-        TMutateTypeTopLevel,
-        TWith[RelationName]
-      >;
-    }
+// Plans describe only declared relations, never arbitrary object/array schema fields.
+// A fresh include/with/autoload selection replaces the whole retained plan of that name.
+type TypeDtoMutateIncludePlans<TModelOptions extends IDecoratorModelOptions, TInclude> = OmitNever<{
+  [Name in keyof TModelOptions['relations']]: TInclude extends {}
+    ? TInclude[Name] extends false
+      ? false
+      : TInclude[Name] extends true
+        ? [TModelOptions['relations'][Name], undefined]
+        : TInclude[Name] extends {}
+          ? [TModelOptions['relations'][Name], TInclude[Name]]
+          : TypeDtoMutateAutoloadPlan<TModelOptions['relations'][Name]>
+    : TypeDtoMutateAutoloadPlan<TModelOptions['relations'][Name]>;
+}>;
+
+type TypeDtoMutateAutoloadPlan<Relation> =
+  TypeUtilGetRelationOptionsAutoload<Relation> extends true ? [Relation, undefined] : never;
+
+type TypeDtoMutateWithPlans<TWith> = TWith extends {}
+  ? OmitNever<{
+      [Name in keyof TWith]: TWith[Name] extends boolean
+        ? never
+        : TWith[Name] extends {}
+          ? [TWith[Name], TypeUtilGetRelationOptions<TWith[Name]>]
+          : never;
+    }>
   : {};
 
-type TypeDtoMutateRelationResultMergeIncludeWrapper<
-  TMutateTypeTopLevel extends TypeDtoMutateType,
-  Relation,
-  IncludeWrapper,
-> = IncludeWrapper extends false
-  ? never
-  : IncludeWrapper extends true
-    ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, undefined>
-    : IncludeWrapper extends {}
-      ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, IncludeWrapper>
-      : never;
+type TypeDtoMutateFreshPlans<
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TWith = TypeDtoMutateWithPlans<TypeUtilGetParamsWith<TOptionsRelation>>,
+> = Omit<
+  TModel extends BeanModelMeta
+    ? TypeDtoMutateIncludePlans<
+        TypeUtilGetModelOptions<TModel>,
+        TypeUtilGetParamsInlcude<TOptionsRelation>
+      >
+    : {},
+  keyof TWith
+> &
+  TWith;
 
-type TypeDtoMutateRelationResultMergeAutoload<
-  TMutateTypeTopLevel extends TypeDtoMutateType,
-  Relation,
-> =
-  TypeUtilGetRelationOptionsAutoload<Relation> extends true
-    ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, undefined>
+type TypeDtoMutateRetainedPlans<TOptionsRelation> = TOptionsRelation extends {
+  dtoClass: infer TClass extends Constructable<unknown>;
+}
+  ? typeof SymbolDtoMutateRelations extends keyof TClass
+    ? Pick<
+        NonNullable<TClass[typeof SymbolDtoMutateRelations]>,
+        Extract<
+          keyof NonNullable<TClass[typeof SymbolDtoMutateRelations]>,
+          keyof InstanceType<TClass>
+        >
+      >
+    : {}
+  : {};
+
+type TypeDtoMutateRelationPlans<
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TFresh = TypeDtoMutateFreshPlans<TModel, TOptionsRelation>,
+> = Omit<TypeDtoMutateRetainedPlans<TOptionsRelation>, keyof TFresh> & TFresh;
+
+type TypeDtoMutateOwnedRelations<
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TPlans = TypeDtoMutateRelationPlans<TModel, TOptionsRelation>,
+> = OmitNever<{
+  [Name in keyof TPlans]: TPlans[Name] extends [infer Relation, unknown]
+    ? TypeUtilGetRelationType<Relation> extends 'hasOne' | 'hasMany'
+      ? TPlans[Name]
+      : never
     : never;
+}>;
 
-type TypeDtoMutateRelationResultMergeWithRelation<
-  TMutateTypeTopLevel extends TypeDtoMutateType,
-  WithRelation,
-> = WithRelation extends false
-  ? never
-  : WithRelation extends true
-    ? never
-    : WithRelation extends {}
-      ? TypeUtilGetDtoMutateRelationEntityByType<
-          TMutateTypeTopLevel,
-          WithRelation,
-          TypeUtilGetRelationOptions<WithRelation>
-        >
-      : never;
+type TypeDtoMutateProjectRelations<TPlans, TMutateType extends TypeDtoMutateType> = OmitNever<{
+  [Name in keyof TPlans]: TPlans[Name] extends [infer Relation, infer IncludeWrapper]
+    ? TypeUtilGetDtoMutateRelationEntityByType<TMutateType, Relation, IncludeWrapper>
+    : never;
+}>;
+
+type TypeDtoMutateDisabledRelations<TPlans> = {
+  [Name in keyof TPlans]: TPlans[Name] extends false ? Name : never;
+}[keyof TPlans];
+
+type TypeDtoMutateMergeRelations<
+  TBase,
+  TPlans,
+  TMutateType extends TypeDtoMutateType,
+  TRelations = TypeDtoMutateProjectRelations<TPlans, TMutateType>,
+  TDisabled extends keyof TBase = Extract<keyof TBase, TypeDtoMutateDisabledRelations<TPlans>>,
+> = Omit<TBase, keyof TRelations | TDisabled> & Partial<Pick<TBase, TDisabled>> & TRelations;
 
 // Relation options supply the default dtoClass; an include wrapper may override it.
 type TypeUtilGetDtoMutateRelationParams<Relation, IncludeWrapper> = IncludeWrapper extends {

package/src/types/index.ts

@@ -1,3 +1,4 @@
+export * from './analysis.ts';
 export * from './columns.ts';
 export * from './config.ts';
 export * from './database.ts';

package/src/types/relationsAggr.ts

@@ -27,7 +27,7 @@ export type TypeUtilAggrPrepareColumns<TColumns> = TColumns extends string[]
     : undefined;
 export type TypeRecordAggrsValues<TRecord extends Record<string, any>> = TRecord[keyof TRecord];
 export type TypeRecordAggrsValuesToObject<AggrValues extends string> = {
-  [K in AggrValues]: string | undefined;
+  [K in AggrValues]: K extends `count_${string}` ? string | undefined : string | null | undefined;
 };
 
 export type TypeUtilGetAggrsFromRelationAndIncludeWrapper<