vona-module-a-orm 5.0.96 → 5.1.2

package/src/types/onion/model.ts

@@ -0,0 +1,68 @@
+import type { Constructable, OmitNever, VonaContext } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+import type { IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
+
+import type { IDatabaseClientRecord } from '../database.ts';
+import type { EntityBaseEmpty } from '../entityBaseEmpty.ts';
+import type { TypeModelColumnsStrict } from '../modelWhere.ts';
+import type { TypeModelClassLikeGeneral } from '../relations.ts';
+import type { ITableRecord } from './table.ts';
+
+export interface IModelRecord {}
+export interface IModelClassRecord {}
+
+export type TypeDynamicTableName = (ctx: VonaContext, where: any | undefined, defaultTable: keyof ITableRecord, modelInstance: any) => string;
+
+export type TypeDynamicClientName = (ctx: VonaContext, modelInstance: any) => keyof IDatabaseClientRecord;
+
+export type TypeModelsClearedByFn = (ctx: VonaContext, modelTarget: any, modelSource: any) => Promise<void>;
+
+export type TypeSoftDeletionPruneHandler = (ctx: VonaContext, modelInstance: any, options: ISoftDeletionPruneHandlerOptions) => Promise<void>;
+
+export interface ISoftDeletionPruneHandlerOptions {
+  expired: number;
+}
+
+export interface ISoftDeletionPrune {
+  handler?: TypeSoftDeletionPruneHandler;
+  expired?: number;
+}
+
+export type TypeModelOptionsTable = TypeDynamicTableName | keyof ITableRecord;
+
+export interface IDecoratorModelOptions<TRecord extends EntityBaseEmpty = any> {
+  entity?: Constructable<TRecord>;
+  table?: TypeModelOptionsTable;
+  disableDeleted?: boolean;
+  disableInstance?: boolean;
+  disableCreateTime?: boolean;
+  disableUpdateTime?: boolean;
+  softDeletionPrune?: ISoftDeletionPrune | boolean;
+  cache?: {
+    query?: IDecoratorSummerCacheOptions | false;
+    entity?: IDecoratorSummerCacheOptions | false;
+    keysAux?: TypeModelColumnsStrict<TRecord>;
+    modelsClear?: TypeModelClassLikeGeneral | TypeModelClassLikeGeneral[];
+    modelsClearedBy?: keyof IModelClassRecord | (keyof IModelClassRecord)[]; // TypeModelClassLikeGeneral | TypeModelClassLikeGeneral[];
+    modelsClearedByFn?: TypeModelsClearedByFn;
+  };
+  client?: TypeDynamicClientName | keyof IDatabaseClientRecord;
+  // should not use TypeModelRelations or {}
+  relations?: Record<never, never>;
+}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    model: ServiceOnion<IModelRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    model: OmitNever<IModelRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    model: never;
+  }
+}

package/src/types/onion/table.ts

@@ -0,0 +1 @@
+export interface ITableRecord {}

package/src/types/relations.ts

@@ -0,0 +1,243 @@
+import type { Constructable, OmitNever } from 'vona';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { TypeDepthPrev, TypeDepthPrevMax } from './depth.ts';
+import type { IDecoratorModelOptions, IModelClassRecord } from './onion/model.ts';
+import type { TypeModelAggrRelationResultAggrs, TypeUtilGetAggrsFromRelationAndIncludeWrapper } from './relationsAggr.ts';
+import type { TypeModelGroupRelationResultGroups, TypeUtilGetGroupsFromRelationAndIncludeWrapper } from './relationsGroup.ts';
+
+export const SymbolKeyEntity = Symbol('$entity');
+export const SymbolKeyEntityMeta = Symbol('$entityMeta');
+export const SymbolKeyModelOptions = Symbol('$modelOptions');
+export type TypeSymbolKeyEntity = typeof SymbolKeyEntity;
+export type TypeSymbolKeyEntityMeta = typeof SymbolKeyEntityMeta;
+export type TypeSymbolKeyModelOptions = typeof SymbolKeyModelOptions;
+
+export type TypeModelOfModelLike<
+  ModelLike extends
+    | (() => Constructable<BeanModelMeta>)
+    | Constructable<BeanModelMeta>
+    | (() => BeanModelMeta)
+    | BeanModelMeta
+    | keyof IModelClassRecord,
+> = ModelLike extends keyof IModelClassRecord
+  ? IModelClassRecord[ModelLike]
+  : ModelLike extends () => Constructable<infer MODEL>
+    ? MODEL
+    : ModelLike extends Constructable<infer MODEL>
+      ? MODEL
+      : ModelLike extends () => infer MODEL
+        ? MODEL
+        : ModelLike;
+
+export type TypeModelClassLike<MODEL extends BeanModelMeta | keyof IModelClassRecord> = MODEL extends BeanModelMeta
+  ? (() => Constructable<MODEL>) | Constructable<MODEL>
+  : MODEL;
+
+export type TypeModelClassLikeGeneral<MODEL extends BeanModelMeta = BeanModelMeta> =
+  | (() => Constructable<MODEL>)
+  | Constructable<MODEL>
+  | (() => BeanModelMeta)
+  | BeanModelMeta
+  | keyof IModelClassRecord;
+
+export type TypeModelsClassLikeGeneral<MODEL extends BeanModelMeta = BeanModelMeta> =
+  | TypeModelClassLikeGeneral<MODEL>
+  | Array<TypeModelClassLikeGeneral<MODEL>>;
+
+export type TypeModelParamsInclude<MODEL extends BeanModelMeta | undefined> = TypeModelParamsIncludeByModelOptions<TypeUtilGetModelOptions<MODEL>>;
+
+export type TypeModelParamsIncludeByModelOptions<ModelOptions extends IDecoratorModelOptions | undefined> =
+  ModelOptions extends IDecoratorModelOptions
+    ? {
+        [relationName in keyof ModelOptions['relations']]?: TypeModelParamsRelationOptions<ModelOptions['relations'][relationName]>;
+      }
+    : never;
+
+export type TypeModelParamsRelationOptions<Relation> =
+  | boolean
+  | (Omit<TypeUtilGetRelationOptions<Relation>, 'autoload'> & {
+      include?: TypeModelParamsInclude<TypeUtilGetRelationModel<Relation>>;
+      with?: Record<string, unknown>;
+    });
+
+export type TypeUtilGetRelationType<Relation> = Relation extends { type?: infer TYPE } ? TYPE : undefined;
+export type TypeUtilGetRelationKey<Relation> = Relation extends { key?: infer KEY } ? KEY : undefined;
+export type TypeUtilGetRelationModel<Relation> = Relation extends {
+  model?: (() => Constructable<infer MODEL extends BeanModelMeta>) | Constructable<infer MODEL extends BeanModelMeta>;
+}
+  ? MODEL
+  : Relation extends { model?: (() => infer MODEL extends BeanModelMeta) | (infer MODEL extends BeanModelMeta) }
+    ? MODEL
+    : Relation extends { model?: () => Constructable<infer MODEL extends BeanModelMeta> }
+      ? MODEL
+      : Relation extends { model?: () => infer MODEL extends BeanModelMeta }
+        ? MODEL
+        : Relation extends { model?: Constructable<infer MODEL extends BeanModelMeta> }
+          ? MODEL
+          : Relation extends { model?: infer MODEL extends BeanModelMeta }
+            ? MODEL
+            : Relation extends { model?: infer MODELNAME extends keyof IModelClassRecord }
+              ? IModelClassRecord[MODELNAME]
+              : undefined;
+
+export type TypeUtilGetRelationModelOptions<Relation> = TypeUtilGetModelOptions<TypeUtilGetRelationModel<Relation>>;
+export type TypeUtilGetRelationEntity<Relation> = TypeUtilGetModelEntity<TypeUtilGetRelationModel<Relation>>;
+export type TypeUtilGetRelationEntityMeta<Relation> = TypeUtilGetModelEntityMeta<TypeUtilGetRelationModel<Relation>>;
+export type TypeUtilGetRelationOptions<Relation> = Relation extends { options?: infer OPTIONS } ? OPTIONS : undefined;
+export type TypeUtilGetRelationOptionsAutoload<Relation> = Relation extends { options?: { autoload?: infer AUTOLOAD } } ? AUTOLOAD : undefined;
+export type TypeUtilGetRelationOptionsColumns<Relation> = Relation extends { options?: { columns?: infer COLUMNS } } ? COLUMNS : undefined;
+export type TypeUtilGetRelationOptionsAggrs<Relation> = Relation extends { options?: { aggrs?: infer Aggrs } } ? Aggrs : undefined;
+export type TypeUtilGetRelationOptionsGroups<Relation> = Relation extends { options?: { groups?: infer Groups } } ? Groups : undefined;
+export type TypeUtilGetModelOptions<Model extends BeanModelMeta | undefined> = Model extends BeanModelMeta
+  ? Model[TypeSymbolKeyModelOptions]
+  : undefined;
+export type TypeUtilGetModelEntity<Model extends BeanModelMeta | undefined> = Model extends BeanModelMeta ? Model[TypeSymbolKeyEntity] : undefined;
+export type TypeUtilGetModelEntityMeta<Model extends BeanModelMeta | undefined> = Model extends BeanModelMeta
+  ? Model[TypeSymbolKeyEntityMeta]
+  : undefined;
+export type TypeUtilGetModelOnionName<Model extends BeanModelMeta | undefined> = Model extends BeanModelMeta ? Model['$onionName'] : undefined;
+
+export type TypeUtilGetRelationEntityByType<
+  Relation,
+  IncludeWrapper extends {} | undefined | unknown,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = TypeUtilGetEntityByType<
+  TypeUtilGetRelationEntity<Relation>,
+  TypeUtilGetRelationType<Relation>,
+  TypeUtilGetRelationModel<Relation>,
+  IncludeWrapper,
+  TypeUtilGetColumnsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>,
+  TypeUtilGetAggrsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>,
+  TypeUtilGetGroupsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>,
+  Depth
+>;
+
+export type TypeUtilGetEntityByType<
+  TRecord,
+  TYPE,
+  TModel extends BeanModelMeta | undefined,
+  IncludeWrapper extends {} | undefined | unknown,
+  Columns,
+  Aggrs,
+  Groups,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = TYPE extends 'hasMany' | 'belongsToMany'
+  ? Groups extends string | string[]
+    ? Array<TypeModelRelationResult<TRecord, TModel, IncludeWrapper, Columns, Aggrs, Groups>>
+    : Aggrs extends {}
+      ? TypeModelRelationResult<TRecord, TModel, IncludeWrapper, Columns, Aggrs> | undefined
+      : Array<TypeModelRelationResult<TRecord, TModel, IncludeWrapper, Columns>>
+  : [Depth] extends [never]
+    ? undefined
+    : TypeModelRelationResult<TRecord, TModel, IncludeWrapper, Columns, undefined, undefined, TypeDepthPrev[Depth]> | undefined;
+
+export type TypeUtilGetParamsAggrs<TParams> = TParams extends { aggrs?: infer Aggrs } ? Aggrs : undefined;
+export type TypeUtilGetParamsGroups<TParams> = TParams extends { groups?: infer Groups } ? Groups : undefined; // not use Groups extends string |string[]
+export type TypeUtilGetParamsInlcude<TParams> = TParams extends { include?: infer INCLUDE } ? INCLUDE : undefined;
+export type TypeUtilGetParamsWith<TParams> = TParams extends { with?: infer WITH } ? WITH : undefined;
+export type TypeUtilGetParamsColumns<TParams> = TParams extends { columns?: infer COLUMNS } ? COLUMNS : undefined;
+export type TypeUtilPrepareColumns<TColumns> = TColumns extends '*' | ['*']
+  ? undefined
+  : TColumns extends string[]
+    ? TColumns[number]
+    : TColumns extends string
+      ? TColumns
+      : undefined;
+export type TypeUtilEntitySelector<TRecord, TColumns> = [TColumns] extends [keyof TRecord] ? Pick<TRecord, TColumns> : TRecord;
+export type TypeUtilEntityOmit<TRecord, TColumns> = [TColumns] extends [keyof TRecord] ? Omit<TRecord, TColumns> : TRecord;
+export type TypeUtilEntityPartial<TRecord, TColumns> = [TColumns] extends [keyof TRecord]
+  ? Partial<Pick<TRecord, TColumns>> & Omit<TRecord, TColumns>
+  : TRecord;
+export type TypeUtilGetColumnsFromRelationAndIncludeWrapper<Relation, IncludeWrapper extends {} | undefined | unknown> =
+  TypeUtilGetParamsColumns<IncludeWrapper> extends string | string[]
+    ? TypeUtilGetParamsColumns<IncludeWrapper>
+    : TypeUtilGetRelationOptionsColumns<Relation>;
+
+export interface TypeModelSelectAndCount<
+  TRecord,
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TColumns = undefined,
+  Aggrs = undefined,
+  Groups = undefined,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> {
+  list: TypeModelRelationResult<TRecord, TModel, TOptionsRelation, TColumns, Aggrs, Groups, Depth>[];
+  total: string;
+  pageCount: number;
+  pageSize: number;
+  pageNo: number;
+}
+
+export type TypeModelRelationResult<
+  TRecord,
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TColumns = undefined,
+  Aggrs = undefined,
+  Groups = undefined,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = Groups extends string | string[]
+  ? TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, TColumns>
+  : Aggrs extends {}
+    ? TypeModelAggrRelationResultAggrs<Aggrs>
+    : TypeModelRelationResult_Normal<TRecord, TModel, TOptionsRelation, TColumns, Depth>;
+
+export type TypeModelRelationResult_Normal<
+  TRecord,
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TColumns = undefined,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = TypeUtilEntitySelector<
+  TRecord,
+  TypeUtilPrepareColumns<TColumns extends string | string[] ? TColumns : TypeUtilGetParamsColumns<TOptionsRelation>>
+> &
+  (TModel extends BeanModelMeta
+    ? OmitNever<TypeModelRelationResultMergeInclude<TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>, Depth>> &
+        OmitNever<TypeModelRelationResultMergeWith<TypeUtilGetParamsWith<TOptionsRelation>, Depth>>
+    : {});
+
+export type TypeModelRelationResultMergeInclude<
+  TModelOptions extends IDecoratorModelOptions,
+  TInclude extends {} | undefined | unknown,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = {
+  [RelationName in keyof TModelOptions['relations']]: TInclude extends {}
+    ? TInclude[RelationName] extends {} | boolean
+      ? TypeModelRelationResultMergeIncludeWrapper<TModelOptions['relations'][RelationName], TInclude[RelationName], Depth>
+      : TypeModelRelationResultMergeAutoload<TModelOptions['relations'][RelationName], Depth>
+    : TypeModelRelationResultMergeAutoload<TModelOptions['relations'][RelationName], Depth>;
+};
+
+export type TypeModelRelationResultMergeWith<
+  TWith extends {} | undefined | unknown,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = TWith extends {} ? { [RelationName in keyof TWith]: TypeModelRelationResultMergeWithRelation<TWith[RelationName], Depth> } : {};
+
+export type TypeModelRelationResultMergeAutoload<Relation, Depth extends TypeDepthPrev[number] = TypeDepthPrevMax> =
+  TypeUtilGetRelationOptionsAutoload<Relation> extends true ? TypeUtilGetRelationEntityByType<Relation, undefined, Depth> : never;
+
+export type TypeModelRelationResultMergeIncludeWrapper<
+  Relation,
+  IncludeWrapper,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = IncludeWrapper extends false
+  ? never
+  : IncludeWrapper extends true
+    ? TypeUtilGetRelationEntityByType<Relation, undefined, Depth>
+    : IncludeWrapper extends {}
+      ? TypeUtilGetRelationEntityByType<Relation, IncludeWrapper, Depth>
+      : never;
+
+export type TypeModelRelationResultMergeWithRelation<
+  WithRelation,
+  Depth extends TypeDepthPrev[number] = TypeDepthPrevMax,
+> = WithRelation extends false
+  ? never
+  : WithRelation extends true
+    ? never
+    : WithRelation extends {}
+      ? TypeUtilGetRelationEntityByType<WithRelation, TypeUtilGetRelationOptions<WithRelation>, Depth>
+      : never;

package/src/types/relationsAggr.ts

@@ -0,0 +1,31 @@
+import type { TypeUtilGetParamsAggrs, TypeUtilGetRelationOptionsAggrs } from './relations.ts';
+
+export type TypeModelAggrRelationResult<TOptions> =
+  TypeUtilGetParamsAggrs<TOptions> extends {} ? TypeModelAggrRelationResultAggrs<TypeUtilGetParamsAggrs<TOptions>> : {}; // not use undefined
+
+export type TypeModelAggrRelationResultAggrs<Aggrs> = Aggrs extends {}
+  ? TypeRecordAggrsValuesToObject<
+      TypeRecordAggrsValues<{
+        [K in keyof Aggrs]: K extends string ? TypeModelAggrRelationResultAggr<K, TypeUtilAggrPrepareColumns<Aggrs[K]>> : never;
+      }>
+    >
+  : {};
+
+export type TypeModelAggrRelationResultAggr<Aggr extends string, Columns extends string | number | symbol | undefined> = Columns extends string
+  ? `${Aggr}_${Columns extends '*' ? 'all' : Columns}`
+  : never;
+
+export type TypeUtilAggrPrepareColumns<TColumns> = TColumns extends string[] ? TColumns[number] : TColumns extends string ? TColumns : undefined;
+export type TypeRecordAggrsValues<TRecord extends Record<string, any>> = TRecord[keyof TRecord];
+export type TypeRecordAggrsValuesToObject<AggrValues extends string> = { [K in AggrValues]: string | undefined };
+
+export type TypeUtilGetAggrsFromRelationAndIncludeWrapper<Relation, IncludeWrapper extends {} | undefined | unknown> =
+  TypeUtilGetRelationOptionsAggrs<Relation> extends {}
+    ? TypeUtilGetParamsAggrs<IncludeWrapper> extends {}
+      ? TypeUtilGetAggrsFromRelationAndIncludeWrapper_Mixed<TypeUtilGetRelationOptionsAggrs<Relation>, TypeUtilGetParamsAggrs<IncludeWrapper>>
+      : TypeUtilGetRelationOptionsAggrs<Relation>
+    : undefined;
+
+export type TypeUtilGetAggrsFromRelationAndIncludeWrapper_Mixed<RelationAggrs extends {}, IncludeWrapperAggrs extends {}> = {
+  [K in keyof RelationAggrs]: K extends string ? (K extends keyof IncludeWrapperAggrs ? IncludeWrapperAggrs[K] : RelationAggrs[K]) : undefined;
+};

package/src/types/relationsColumns.ts

@@ -0,0 +1,116 @@
+import type { TypeConfirmArray, TypeRecordValues } from 'vona';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IDecoratorModelOptions } from './onion/model.ts';
+import type {
+  TypeModelOfModelLike,
+  TypeModelsClassLikeGeneral,
+  TypeSymbolKeyEntity,
+  TypeSymbolKeyEntityMeta,
+  TypeUtilGetModelOnionName,
+  TypeUtilGetModelOptions,
+  TypeUtilGetRelationEntityMeta,
+  TypeUtilGetRelationModel,
+} from './relations.ts';
+
+export type TypeEntityTableColumnNames<EntityMeta extends { $table: string } | undefined> = EntityMeta extends { $table: string }
+  ? keyof {
+      [K in keyof EntityMeta as K extends '$table' | '$comment' | '$default'
+        ? never
+        : K extends string
+          ? `${EntityMeta['$table']}.${K}`
+          : never]: EntityMeta[K];
+    }
+  : never;
+export type TypeEntityTableColumnNamesShort<Entity> = keyof Entity;
+
+export type TypeEntityTableColumns<Entity extends {} | undefined, EntityMeta extends { $table: string } | undefined> = Entity extends {}
+  ? EntityMeta extends { $table: string }
+    ? { [K in keyof Entity as K extends string ? `${EntityMeta['$table']}.${K}` : never]: Entity[K] }
+    : {}
+  : {};
+export type TypeEntityTableColumnsShort<Entity> = Entity;
+
+export type TypeEntityTableColumnsOfModelDirect<TModel extends BeanModelMeta | undefined> = TModel extends BeanModelMeta
+  ? TypeEntityTableColumns<TModel[TypeSymbolKeyEntity], TModel[TypeSymbolKeyEntityMeta]>
+  : {};
+
+export type TypeEntityTableColumnNamesOfModels<A extends BeanModelMeta[]> = TypeEntityTableColumnNames<A[number][TypeSymbolKeyEntityMeta]>;
+
+// export type TypeEntityTableColumnNamesOfModelOptions<TModelOptions extends IDecoratorModelOptions> = TypeEntityTableColumnNames<TypeRecordValues<{
+//   [RelationName in keyof TModelOptions['relations']]: TypeUtilGetRelationEntityMeta<TModelOptions['relations'][RelationName]>;
+// }>>;
+export type TypeEntityTableColumnNamesOfModelOptions<TModelOptions extends IDecoratorModelOptions> = TModelOptions['relations'] extends {}
+  ? TypeRecordValues<{
+      [RelationName in keyof TModelOptions['relations']]: TypeEntityTableColumnNames<
+        TypeUtilGetRelationEntityMeta<TModelOptions['relations'][RelationName]>
+      >;
+    }>
+  : never;
+
+export type TypeEntityTableColumnsOfModelOptions<TModelOptions extends IDecoratorModelOptions> = TModelOptions['relations'] extends {}
+  ? TypeEntityTableColumnsOfModelDirect<
+      TypeRecordModelValues<{
+        [RelationName in keyof TModelOptions['relations']]: TypeUtilGetRelationModel<TModelOptions['relations'][RelationName]>;
+      }>
+    >
+  : {};
+
+export type TypeModelsOfModelOptions<TModelOptions extends IDecoratorModelOptions> = TModelOptions['relations'] extends {}
+  ? TypeRecordModelValues<{
+      [RelationName in keyof TModelOptions['relations']]: TypeUtilGetRelationModel<TModelOptions['relations'][RelationName]>;
+    }>
+  : never;
+
+export type TypeModelOnionNamesOfModelOptions<TModelOptions extends IDecoratorModelOptions> = TModelOptions['relations'] extends {}
+  ? TypeRecordValues<{
+      [RelationName in keyof TModelOptions['relations']]: TypeUtilGetModelOnionName<
+        TypeUtilGetRelationModel<TModelOptions['relations'][RelationName]>
+      >;
+    }>
+  : undefined; // not use never
+
+export type TypeRecordModelValues<TRecord extends Record<string, BeanModelMeta | undefined>> = TRecord[keyof TRecord];
+
+export type TypeEntityTableColumnNamesOfModelClass<TModel extends BeanModelMeta> = TypeEntityTableColumnNamesOfModelOptions<
+  TypeUtilGetModelOptions<TModel>
+>;
+
+export type TypeEntityTableColumnsOfModelClass<TModel extends BeanModelMeta> = TypeEntityTableColumnsOfModelOptions<TypeUtilGetModelOptions<TModel>>;
+
+export type TypeModelsOfModelClass<TModel extends BeanModelMeta> = TypeModelsOfModelOptions<TypeUtilGetModelOptions<TModel>>;
+
+export type TypeModelOnionNamesOfModelClass<TModel extends BeanModelMeta> = TypeModelOnionNamesOfModelOptions<TypeUtilGetModelOptions<TModel>>;
+
+export type TypeEntityTableColumnNamesOfModelJoins<TModelJoins extends TypeModelsClassLikeGeneral> = TypeEntityTableColumnNames<
+  TypeModelOfModelLike<TypeConfirmArray<TModelJoins>[number]>[TypeSymbolKeyEntityMeta]
+>;
+
+export type TypeEntityTableColumnsOfModelJoins<TModelJoins extends TypeModelsClassLikeGeneral> = TypeEntityTableColumnsOfModelDirect<
+  TypeModelOfModelLike<TypeConfirmArray<TModelJoins>[number]>
+>;
+
+export type TypeEntityTableColumnNamesOfModelSelf<TModel extends BeanModelMeta> =
+  | TypeEntityTableColumnNames<TModel[TypeSymbolKeyEntityMeta]>
+  | TypeEntityTableColumnNamesShort<TModel[TypeSymbolKeyEntity]>;
+
+export type TypeEntityTableColumnsOfModelSelf<TModel extends BeanModelMeta> = TypeEntityTableColumnsOfModelDirect<TModel> &
+  TypeEntityTableColumnsShort<TModel[TypeSymbolKeyEntity]>;
+
+export type TypeEntityTableColumnNamesOfGeneral<
+  TModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  TModel extends BeanModelMeta | undefined,
+> = TModel extends BeanModelMeta
+  ? TModelJoins extends TypeModelsClassLikeGeneral
+    ? TypeEntityTableColumnNamesOfModelJoins<TModelJoins> | TypeEntityTableColumnNamesOfModelSelf<TModel>
+    : TypeEntityTableColumnNamesOfModelClass<TModel> | TypeEntityTableColumnNamesOfModelSelf<TModel>
+  : undefined;
+
+export type TypeEntityTableColumnsOfGeneral<
+  TModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  TModel extends BeanModelMeta | undefined,
+> = TModel extends BeanModelMeta
+  ? TModelJoins extends TypeModelsClassLikeGeneral
+    ? TypeEntityTableColumnsOfModelJoins<TModelJoins> & TypeEntityTableColumnsOfModelSelf<TModel>
+    : TypeEntityTableColumnsOfModelClass<TModel> & TypeEntityTableColumnsOfModelSelf<TModel>
+  : undefined;

package/src/types/relationsDef.ts

@@ -0,0 +1,152 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { ServiceDb } from '../service/db_.ts';
+import type { IDatabaseClientRecord } from './database.ts';
+import type { TypeModelSelectAggrParamsAggrs } from './modelAggr.ts';
+import type { IBuildModelSelectGeneralParamsBasic } from './modelGeneral.ts';
+import type { TypeModelColumn, TypeModelColumnsPatch, TypeModelColumnsStrict } from './modelWhere.ts';
+import type { IModelClassRecord, TypeModelOptionsTable } from './onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+export type TypeModelRelationType = 'hasOne' | 'belongsTo' | 'hasMany' | 'belongsToMany';
+// export interface TypeModelRelations {
+//   [key: string]: TypeModelRelation<any, any>;
+// }
+
+// export type TypeModelRelation<MODELSelf extends BeanModelMeta | undefined, MODELTarget extends BeanModelMeta> =
+//   IModelRelationHasOne<MODELTarget> |
+//   IModelRelationBelongsTo<MODELSelf, MODELTarget> |
+//   IModelRelationHasMany<MODELTarget>;
+
+// use optional ? for app config
+export interface IModelRelationHasOne<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity] | undefined = keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<
+    TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+  >,
+> {
+  type?: 'hasOne';
+  model?: TypeModelClassLike<MODEL>;
+  key?: KEY;
+  options?: IModelRelationOptionsOne<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS>;
+}
+
+export interface IModelRelationBelongsTo<
+  MODELSelf extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<
+    TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+  >,
+> {
+  type?: 'belongsTo';
+  model?: TypeModelClassLike<MODEL>;
+  key?: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity];
+  options?: IModelRelationOptionsOne<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS>;
+}
+
+export interface IModelRelationHasMany<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity] | undefined = keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<
+    TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+  >,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined,
+  Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined,
+> {
+  type?: 'hasMany';
+  model?: TypeModelClassLike<MODEL>;
+  key?: KEY;
+  options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>;
+}
+
+export interface IModelRelationBelongsToMany<
+  MODELMiddle extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<
+    TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+  >,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined,
+  Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> | undefined = undefined,
+> {
+  type?: 'belongsToMany';
+  modelMiddle?: TypeModelClassLike<MODELMiddle>;
+  model?: TypeModelClassLike<MODEL>;
+  keyFrom?: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity];
+  keyTo?: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity];
+  options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>;
+}
+
+export interface IModelRelationOptionsOne<
+  MODEL extends BeanModelMeta,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<MODEL[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<MODEL[TypeSymbolKeyEntity]>,
+> extends IModelRelationOptionsMetaWrapper {
+  autoload?: AUTOLOAD;
+  columns?: TypeModelColumnsPatch<MODEL[TypeSymbolKeyEntity], COLUMNS>;
+}
+
+export interface IModelRelationOptionsMany<
+  MODEL extends BeanModelMeta,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<MODEL[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<MODEL[TypeSymbolKeyEntity]>,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<MODEL[TypeSymbolKeyEntity]> | undefined = undefined,
+  Groups extends TypeModelColumnsStrict<MODEL[TypeSymbolKeyEntity]> | undefined = undefined,
+>
+  extends IModelRelationOptionsMetaWrapper, IModelRelationOptionsMany_Raw<MODEL, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups> {}
+
+export type IModelRelationOptionsMany_Raw<
+  MODEL extends BeanModelMeta,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<MODEL[TypeSymbolKeyEntity]> | undefined = TypeModelColumn<MODEL[TypeSymbolKeyEntity]>,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<MODEL[TypeSymbolKeyEntity]> | undefined = undefined,
+  Groups extends TypeModelColumnsStrict<MODEL[TypeSymbolKeyEntity]> | undefined = undefined,
+> = IBuildModelRelationOptionsMany<
+  MODEL[TypeSymbolKeyEntity],
+  AUTOLOAD,
+  COLUMNS,
+  TypeEntityTableNamesOfGeneral<ModelJoins, MODEL>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, MODEL>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, MODEL>,
+  Aggrs,
+  Groups
+>;
+
+export interface IBuildModelRelationOptionsMany<
+  TRecord,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<TRecord> | undefined = TypeModelColumn<TRecord>,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> | undefined = undefined,
+  Groups extends TypeModelColumnsStrict<TRecord> | undefined = undefined,
+> extends IBuildModelSelectGeneralParamsBasic<TRecord, COLUMNS, TableNames, ColumnNames, Columns, Aggrs, Groups> {
+  autoload?: AUTOLOAD;
+}
+
+export interface IModelRelationOptionsMetaBasic {
+  client?: TypeModelRelationOptionsMetaClient;
+  table?: TypeModelOptionsTable;
+}
+
+export interface IModelRelationOptionsMeta extends IModelRelationOptionsMetaBasic {
+  middle?: IModelRelationOptionsMetaBasic;
+}
+
+export interface IModelRelationOptionsMetaWrapper {
+  meta?: IModelRelationOptionsMeta;
+}
+
+export type TypeModelRelationOptionsMetaClient = '_auto_' | '_initial_' | '_inherit_' | keyof IDatabaseClientRecord | ServiceDb;
+
+export type IRelationItem = [string, any, any, any, boolean];