vona-module-a-orm 5.0.37

package/dist/types/entity.d.ts

@@ -0,0 +1,15 @@
+export type TypeEntityMeta<T, N = string> = Required<{
+    [key in keyof T]: key;
+}> & {
+    $table: N;
+    $comment: Required<{
+        [key in keyof T]: string;
+    }> & {
+        $table: string;
+    };
+    $default: Required<{
+        [key in keyof T]: any;
+    }>;
+};
+export declare const SymbolKeyFieldsMore: unique symbol;
+export type TypeSymbolKeyFieldsMore = typeof SymbolKeyFieldsMore;

package/dist/types/entityBase.d.ts

@@ -0,0 +1,5 @@
+import type { TableIdentity } from './tableIdentity.ts';
+import { EntityBaseInner } from './entityBaseInner.ts';
+export declare class EntityBase extends EntityBaseInner {
+    id: TableIdentity;
+}

package/dist/types/entityBaseEmpty.d.ts

@@ -0,0 +1,2 @@
+export declare class EntityBaseEmpty {
+}

package/dist/types/entityBaseInner.d.ts

@@ -0,0 +1,7 @@
+import { EntityBaseEmpty } from './entityBaseEmpty.ts';
+export declare class EntityBaseInner extends EntityBaseEmpty {
+    createdAt: Date;
+    updatedAt: Date;
+    deleted: boolean;
+    iid: number;
+}

package/dist/types/entityBaseSimple.d.ts

@@ -0,0 +1,4 @@
+import { EntityBaseInner } from './entityBaseInner.ts';
+export declare class EntityBaseSimple extends EntityBaseInner {
+    id: number;
+}

package/dist/types/extra.d.ts

@@ -0,0 +1,11 @@
+declare module 'vona-module-a-orm' {
+    interface ServiceDb {
+    }
+    interface ServiceDatabaseClient {
+    }
+    interface ServiceColumns {
+    }
+    interface ServiceColumnsCache {
+    }
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,30 @@
+export * from './columns.ts';
+export * from './config.ts';
+export * from './database.ts';
+export * from './dialect.ts';
+export * from './dto/index.ts';
+export * from './entity.ts';
+export * from './entityBase.ts';
+export * from './entityBaseEmpty.ts';
+export * from './entityBaseInner.ts';
+export * from './entityBaseSimple.ts';
+export * from './extra.ts';
+export * from './logger.ts';
+export * from './model.ts';
+export * from './modelAggr.ts';
+export * from './modelCount.ts';
+export * from './modelGeneral.ts';
+export * from './modelGroup.ts';
+export * from './modelWhere.ts';
+export * from './onion/index.ts';
+export * from './relations.ts';
+export * from './relationsAggr.ts';
+export * from './relationsColumns.ts';
+export * from './relationsDef.ts';
+export * from './relationsDefDynamic.ts';
+export * from './relationsDefMutate.ts';
+export * from './relationsGroup.ts';
+export * from './relationsMutate.ts';
+export * from './relationsTables.ts';
+export * from './tableIdentity.ts';
+export * from './transaction.ts';

package/dist/types/logger.d.ts

@@ -0,0 +1,7 @@
+declare module 'vona' {
+    interface ILoggerClientChildRecord {
+        database: never;
+        model: never;
+    }
+}
+export {};

package/dist/types/model.d.ts

@@ -0,0 +1,79 @@
+import type { Knex } from 'knex';
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { TypeModelColumn, TypeModelColumns, TypeModelColumnsPatch, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelParamsInclude, TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeModelMutateParamsInclude } from './relationsMutate.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+export type TypeModelCacheType = 'query' | 'entity';
+export type IModelSelectParamsJoinType = 'join' | 'innerJoin' | 'leftJoin' | 'leftOuterJoin' | 'rightJoin' | 'rightOuterJoin' | 'fullOuterJoin' | 'crossJoin';
+export type IModelSelectParamsJoin<TRecord, TableNames = undefined, ColumnNames = keyof TRecord> = [
+    IModelSelectParamsJoinType,
+    TableNames,
+    [
+        ColumnNames,
+        ColumnNames
+    ] | Knex.JoinCallback
+];
+export type IModelSelectParamsOrderDirection = 'asc' | 'desc';
+export type IModelSelectParamsOrderNulls = 'first' | 'last';
+export type IModelSelectParamsOrder<ColumnNames> = [ColumnNames, IModelSelectParamsOrderDirection?, IModelSelectParamsOrderNulls?];
+export interface IBuildModelSelectParams<TRecord, Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> extends IModelRelationIncludeWrapper<Model>, IBuildModelSelectParamsBasic<TRecord, TypeModelColumn<TRecord>, TableNames, ColumnNames, Columns> {
+}
+export interface IBuildModelSelectParamsBasic<TRecord, COLUMNS extends TypeModelColumn<TRecord> = TypeModelColumn<TRecord>, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> {
+    distinct?: boolean | (keyof TRecord) | (keyof TRecord)[];
+    columns?: TypeModelColumnsPatch<TRecord, COLUMNS>;
+    where?: TypeModelWhere<TRecord, Columns>;
+    joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+    orders?: IModelSelectParamsOrder<ColumnNames>[];
+    limit?: number;
+    offset?: number;
+}
+export type IModelSelectParams<TRecord, Model extends BeanModelMeta = BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined> = IBuildModelSelectParams<TRecord, Model, TypeEntityTableNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnsOfGeneral<ModelJoins, Model>>;
+export interface IBuildModelCountParams<TRecord, _Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> {
+    distinct?: boolean | (keyof TRecord) | (keyof TRecord)[];
+    column?: TypeModelColumn<TRecord>;
+    where?: TypeModelWhere<TRecord, Columns>;
+    joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+}
+export type IModelCountParams<TRecord, Model extends BeanModelMeta = BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined> = IBuildModelCountParams<TRecord, Model, TypeEntityTableNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnsOfGeneral<ModelJoins, Model>>;
+export type IModelMethodOptions = Omit<IModelMethodOptionsGeneral, 'disableInstance'>;
+export type IModelInsertOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelInsertOptionsGeneral<TRecord, Model>, 'disableInstance'>;
+export type IModelUpdateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelUpdateOptionsGeneral<TRecord, Model>, 'disableInstance'>;
+export type IModelDeleteOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelDeleteOptionsGeneral<TRecord, Model>, 'disableInstance'>;
+export type IModelGetOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelGetOptionsGeneral<TRecord, Model>, 'disableInstance'>;
+export type IModelMutateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = Omit<IModelMutateOptionsGeneral<TRecord, Model>, 'disableInstance'>;
+export interface IModelMethodOptionsGeneral {
+    disableDeleted?: boolean;
+    disableInstance?: boolean;
+    disableCreateTime?: boolean;
+    disableUpdateTime?: boolean;
+    disableCacheQuery?: boolean;
+    disableCacheEntity?: boolean;
+    iid?: number;
+    deleted?: boolean;
+}
+export interface IModelInsertOptionsGeneral<_TRecord, Model extends BeanModelMeta | undefined = undefined> extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {
+}
+export interface IModelUpdateOptionsGeneral<TRecord, Model extends BeanModelMeta | undefined = undefined> extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {
+    where?: TypeModelWhere<TRecord>;
+}
+export interface IModelDeleteOptionsGeneral<_TRecord, Model extends BeanModelMeta | undefined = undefined> extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {
+}
+export interface IModelGetOptionsGeneral<TRecord, Model extends BeanModelMeta | undefined = undefined> extends IModelMethodOptionsGeneral, IModelRelationIncludeWrapper<Model> {
+    columns?: TypeModelColumns<TRecord>;
+}
+export interface IModelMutateOptionsGeneral<_TRecord, Model extends BeanModelMeta | undefined = undefined> extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {
+}
+export interface IModelSelectParamsPage {
+    index?: number;
+    size?: number;
+}
+export interface IModelRelationIncludeWrapper<Model extends BeanModelMeta | undefined = undefined> {
+    include?: TypeModelParamsInclude<Model>;
+    with?: Record<string, unknown>;
+}
+export interface IModelMutateRelationIncludeWrapper<Model extends BeanModelMeta | undefined = undefined> {
+    include?: TypeModelMutateParamsInclude<Model>;
+    with?: Record<string, unknown>;
+}

package/dist/types/modelAggr.d.ts

@@ -0,0 +1,26 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelSelectParamsJoin } from './model.ts';
+import type { TypeModelColumns, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+export interface TypeModelSelectAggrParamsAggrs<TRecord> {
+    count?: TypeModelColumns<TRecord>;
+    sum?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+    avg?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+    max?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+    min?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+}
+export type TypeEntityTableColumnNamesForAggrs<Entity> = keyof TypeEntityTableColumnsForAggrs<Entity>;
+export type TypeEntityTableColumnsForAggrs<Entity> = Omit<{
+    [K in keyof Entity as Entity[K] extends number | undefined ? K : never]: Entity[K];
+}, 'id' | 'iid'>;
+export interface IBuildModelSelectAggrParams<TRecord, Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> extends IBuildModelSelectAggrParamsBasic<TRecord, Model, TableNames, ColumnNames, Columns> {
+}
+export interface IBuildModelSelectAggrParamsBasic<TRecord, _Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> {
+    distinct?: boolean | (keyof TRecord) | (keyof TRecord)[];
+    aggrs: TypeModelSelectAggrParamsAggrs<TRecord>;
+    where?: TypeModelWhere<TRecord, Columns>;
+    joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+}
+export type IModelSelectAggrParams<TRecord, Model extends BeanModelMeta = BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined> = IBuildModelSelectAggrParams<TRecord, Model, TypeEntityTableNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnsOfGeneral<ModelJoins, Model>>;

package/dist/types/modelCount.d.ts

@@ -0,0 +1,15 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelSelectParamsJoin } from './model.ts';
+import type { TypeModelColumn, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+export interface IBuildModelSelectCountParams<TRecord, Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> extends IBuildModelSelectCountParamsBasic<TRecord, Model, TableNames, ColumnNames, Columns> {
+}
+export interface IBuildModelSelectCountParamsBasic<TRecord, _Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> {
+    distinct?: boolean | (keyof TRecord) | (keyof TRecord)[];
+    column?: TypeModelColumn<TRecord>;
+    where?: TypeModelWhere<TRecord, Columns>;
+    joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+}
+export type IModelSelectCountParams<TRecord, Model extends BeanModelMeta = BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined> = IBuildModelSelectCountParams<TRecord, Model, TypeEntityTableNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnsOfGeneral<ModelJoins, Model>>;

package/dist/types/modelGeneral.d.ts

@@ -0,0 +1,23 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper, IModelSelectParamsJoin, IModelSelectParamsOrder } from './model.ts';
+import type { TypeModelSelectAggrParamsAggrs } from './modelAggr.ts';
+import type { TypeModelColumn, TypeModelColumnsPatch, TypeModelColumnsStrict, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeModelSelectGroupParamsColumnNames, TypeModelSelectGroupParamsColumns } from './relationsGroup.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+export interface IBuildModelSelectGeneralParams<TRecord, Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> extends IModelRelationIncludeWrapper<Model>, IBuildModelSelectGeneralParamsBasic<TRecord, TypeModelColumn<TRecord>, TableNames, ColumnNames, Columns> {
+}
+export interface IBuildModelSelectGeneralParamsBasic<TRecord, TColumn 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> {
+    distinct?: boolean | (keyof TRecord) | (keyof TRecord)[];
+    columns?: Groups extends TypeModelColumnsStrict<TRecord> ? (TColumn extends string ? (TColumn | Array<TColumn>) : TColumn) : TypeModelColumnsPatch<TRecord, TColumn>;
+    aggrs?: Aggrs;
+    groups?: Groups;
+    having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord, Groups, Aggrs>>;
+    where?: TypeModelWhere<TRecord, Columns>;
+    joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+    orders?: Groups extends TypeModelColumnsStrict<TRecord> ? IModelSelectParamsOrder<TypeModelSelectGroupParamsColumnNames<TRecord, Groups, Aggrs>>[] : (Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> ? never : IModelSelectParamsOrder<ColumnNames>[]);
+    limit?: number;
+    offset?: number;
+}
+export type IModelSelectGeneralParams<TRecord, Model extends BeanModelMeta = BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined> = IBuildModelSelectGeneralParams<TRecord, Model, TypeEntityTableNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnsOfGeneral<ModelJoins, Model>>;

package/dist/types/modelGroup.d.ts

@@ -0,0 +1,23 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelSelectParamsJoin, IModelSelectParamsOrder } from './model.ts';
+import type { TypeModelSelectAggrParamsAggrs } from './modelAggr.ts';
+import type { TypeModelColumnsStrict, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeModelSelectGroupParamsColumnNames, TypeModelSelectGroupParamsColumns } from './relationsGroup.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+export interface IBuildModelSelectGroupParams<TRecord, Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> extends IBuildModelSelectGroupParamsBasic<TRecord, Model, TableNames, ColumnNames, Columns> {
+}
+export interface IBuildModelSelectGroupParamsBasic<TRecord, _Model extends BeanModelMeta | undefined = undefined, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined> {
+    distinct?: boolean | (keyof TRecord) | (keyof TRecord)[];
+    aggrs?: TypeModelSelectAggrParamsAggrs<TRecord>;
+    groups: TypeModelColumnsStrict<TRecord>;
+    columns?: TypeModelColumnsStrict<TRecord>;
+    where?: TypeModelWhere<TRecord, Columns>;
+    joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+    having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>;
+    orders?: IModelSelectParamsOrder<TypeModelSelectGroupParamsColumnNames<TRecord>>[];
+    limit?: number;
+    offset?: number;
+}
+export type IModelSelectGroupParams<TRecord, Model extends BeanModelMeta = BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined> = IBuildModelSelectGroupParams<TRecord, Model, TypeEntityTableNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>, TypeEntityTableColumnsOfGeneral<ModelJoins, Model>>;

package/dist/types/modelWhere.d.ts

@@ -0,0 +1,86 @@
+import type { TypeRecordValues } from 'vona';
+export declare const OpAggrs: string[];
+export declare const OpJoint: {
+    readonly and: "_and_";
+    readonly or: "_or_";
+    readonly not: "_not_";
+    readonly exists: "_exists_";
+    readonly notExists: "_notExists_";
+};
+export declare const OpNormal: {
+    readonly eq: "_eq_";
+    readonly notEq: "_notEq_";
+    readonly gt: "_gt_";
+    readonly gte: "_gte_";
+    readonly lt: "_lt_";
+    readonly lte: "_lte_";
+    readonly in: "_in_";
+    readonly notIn: "_notIn_";
+    readonly is: "_is_";
+    readonly isNot: "_isNot_";
+    readonly between: "_between_";
+    readonly notBetween: "_notBetween_";
+    readonly startsWith: "_startsWith_";
+    readonly endsWith: "_endsWith_";
+    readonly includes: "_includes_";
+    readonly startsWithI: "_startsWithI_";
+    readonly endsWithI: "_endsWithI_";
+    readonly includesI: "_includesI_";
+    readonly ref: "_ref_";
+};
+export declare const Op: {
+    readonly eq: "_eq_";
+    readonly notEq: "_notEq_";
+    readonly gt: "_gt_";
+    readonly gte: "_gte_";
+    readonly lt: "_lt_";
+    readonly lte: "_lte_";
+    readonly in: "_in_";
+    readonly notIn: "_notIn_";
+    readonly is: "_is_";
+    readonly isNot: "_isNot_";
+    readonly between: "_between_";
+    readonly notBetween: "_notBetween_";
+    readonly startsWith: "_startsWith_";
+    readonly endsWith: "_endsWith_";
+    readonly includes: "_includes_";
+    readonly startsWithI: "_startsWithI_";
+    readonly endsWithI: "_endsWithI_";
+    readonly includesI: "_includesI_";
+    readonly ref: "_ref_";
+    readonly and: "_and_";
+    readonly or: "_or_";
+    readonly not: "_not_";
+    readonly exists: "_exists_";
+    readonly notExists: "_notExists_";
+    readonly skip: "_skip_";
+};
+export declare const OpJointValues: ("_and_" | "_or_" | "_not_" | "_exists_" | "_notExists_")[];
+export declare const OpNormalValues: ("_eq_" | "_notEq_" | "_gt_" | "_gte_" | "_lt_" | "_lte_" | "_in_" | "_notIn_" | "_is_" | "_isNot_" | "_between_" | "_notBetween_" | "_startsWith_" | "_endsWith_" | "_includes_" | "_startsWithI_" | "_endsWithI_" | "_includesI_" | "_ref_")[];
+export declare const OpValues: ("_and_" | "_or_" | "_not_" | "_exists_" | "_notExists_" | "_skip_" | "_eq_" | "_notEq_" | "_gt_" | "_gte_" | "_lt_" | "_lte_" | "_in_" | "_notIn_" | "_is_" | "_isNot_" | "_between_" | "_notBetween_" | "_startsWith_" | "_endsWith_" | "_includes_" | "_startsWithI_" | "_endsWithI_" | "_includesI_" | "_ref_")[];
+export type TypeOpsJointPostfix<Op> = {
+    [KEY in keyof Op]: Op[KEY] | (KEY extends string ? `_${KEY}_${number}` : never);
+};
+export type TypeOpsJoint = TypeRecordValues<typeof OpJoint>;
+export type TypeOpsNormal = TypeRecordValues<typeof OpNormal>;
+export type TypeOpsAll = TypeRecordValues<typeof Op>;
+export type TypeModelColumnValue<TRecord, Column> = keyof TRecord | Column | Column[] | null | '_skip_';
+export type TypeModelWhere<TRecord, Columns extends {} | undefined = undefined> = Columns extends {} ? TypeModelWhereInner<Columns> : TypeModelWhereInner<TRecord>;
+export type TypeModelWhereInner<TRecord> = {
+    [prop in keyof TRecord]?: TypeModelColumnValue<TRecord, TRecord[prop]> | TypeModelWhereFieldAll<TRecord, TRecord[prop]>;
+} & {
+    [key in TypeOpsJoint]?: TypeModelWhereInner<TRecord>;
+};
+export type TypeModelWhereFieldAll<TRecord, Column> = {
+    [key in TypeOpsJoint]?: TypeModelWhereFieldAll<TRecord, Column>;
+} & {
+    [key in TypeOpsNormal]?: TypeModelColumnValue<TRecord, Column>;
+};
+export type TypeModelWhereFieldJoint<TRecord, Column> = {
+    [key in TypeOpsJoint]?: TypeModelWhereFieldAll<TRecord, Column>;
+};
+export type TypeModelColumn<TRecord> = keyof TRecord | '*';
+export type TypeModelColumns<TRecord> = TypeModelColumn<TRecord> | Array<TypeModelColumn<TRecord>>;
+export type TypeModelColumnPatch<TRecord, TColumn> = TColumn extends '*' ? TypeModelColumn<TRecord> : TColumn;
+export type TypeModelColumnsPatch<TRecord, TColumn> = [TColumn] extends [string] ? (TypeModelColumnPatch<TRecord, TColumn> | Array<TypeModelColumnPatch<TRecord, TColumn>>) : TColumn;
+export type TypeModelColumnsStrict<TRecord> = keyof TRecord | Array<keyof TRecord>;

package/dist/types/onion/databaseDialect.d.ts

@@ -0,0 +1,17 @@
+import type { ServiceOnion } from 'vona-module-a-onion';
+export interface IDatabaseDialectRecord {
+}
+export interface IDecoratorDatabaseDialectOptions {
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        databaseDialect: ServiceOnion<IDecoratorDatabaseDialectOptions, keyof IDatabaseDialectRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+    }
+    interface IBeanSceneRecord {
+        databaseDialect: never;
+    }
+}

package/dist/types/onion/entity.d.ts

@@ -0,0 +1,26 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
+import type { SymbolKeyFieldsMore } from '../entity.ts';
+import type { ITableRecord } from './table.ts';
+export interface IEntityRecord {
+}
+export interface IDecoratorEntityOptions<FieldsMore = never> {
+    [SymbolKeyFieldsMore]?: FieldsMore;
+    table?: keyof ITableRecord;
+    independent?: boolean;
+    openapi?: TypeOpenapiMetadata;
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        entity: ServiceOnion<IDecoratorEntityOptions, keyof IEntityRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        entity: OmitNever<IEntityRecord>;
+    }
+    interface IBeanSceneRecord {
+        entity: never;
+    }
+}

package/dist/types/onion/index.d.ts

@@ -0,0 +1,4 @@
+export * from './databaseDialect.ts';
+export * from './entity.ts';
+export * from './model.ts';
+export * from './table.ts';

package/dist/types/onion/model.d.ts

@@ -0,0 +1,55 @@
+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, defaultTable: keyof ITableRecord, modelInstance: any) => string;
+export type TypeDynamicClientName = (ctx: VonaContext, modelInstance: any) => keyof IDatabaseClientRecord;
+export type TypeModelsClearedByFn = (ctx: VonaContext, modelInstance: 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 interface IDecoratorModelOptions<TRecord extends EntityBaseEmpty = any> {
+    entity?: Constructable<TRecord>;
+    table?: TypeDynamicTableName | keyof ITableRecord;
+    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)[];
+        modelsClearedByFn?: TypeModelsClearedByFn;
+    };
+    client?: TypeDynamicClientName | keyof IDatabaseClientRecord;
+    relations?: Record<never, never>;
+}
+declare module 'vona-module-a-onion' {
+    interface BeanOnion {
+        model: ServiceOnion<IDecoratorModelOptions, keyof IModelRecord>;
+    }
+}
+declare module 'vona' {
+    interface ConfigOnions {
+        model: OmitNever<IModelRecord>;
+    }
+    interface IBeanSceneRecord {
+        model: never;
+    }
+}

package/dist/types/onion/table.d.ts

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

package/dist/types/relations.d.ts

@@ -0,0 +1,102 @@
+import type { Constructable, OmitNever } from 'vona';
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IDecoratorModelOptions, IModelClassRecord } from './onion/model.ts';
+import type { TypeModelAggrRelationResultAggrs, TypeUtilGetAggrsFromRelationAndIncludeWrapper } from './relationsAggr.ts';
+import type { TypeModelGroupRelationResultGroups, TypeUtilGetGroupsFromRelationAndIncludeWrapper } from './relationsGroup.ts';
+export declare const SymbolKeyEntity: unique symbol;
+export declare const SymbolKeyEntityMeta: unique symbol;
+export declare const SymbolKeyModelOptions: unique symbol;
+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 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 extends {};
+} ? 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> = TypeUtilGetEntityByType<TypeUtilGetRelationEntity<Relation>, TypeUtilGetRelationType<Relation>, TypeUtilGetRelationModel<Relation>, IncludeWrapper, TypeUtilGetColumnsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>, TypeUtilGetAggrsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>, TypeUtilGetGroupsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>>;
+export type TypeUtilGetEntityByType<TRecord, TYPE, TModel extends BeanModelMeta | undefined, IncludeWrapper extends {} | undefined, Columns, Aggrs, Groups> = 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>>) : TypeModelRelationResult<TRecord, TModel, IncludeWrapper, Columns> | undefined;
+export type TypeUtilGetParamsAggrs<TParams> = TParams extends {
+    aggrs?: infer Aggrs extends {};
+} ? Aggrs : undefined;
+export type TypeUtilGetParamsGroups<TParams> = TParams extends {
+    groups?: infer Groups extends string | string[];
+} ? Groups : undefined;
+export type TypeUtilGetParamsInlcude<TParams> = TParams extends {
+    include?: infer INCLUDE extends {};
+} ? INCLUDE : undefined;
+export type TypeUtilGetParamsWith<TParams> = TParams extends {
+    with?: infer WITH extends {};
+} ? 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 TypeUtilGetColumnsFromRelationAndIncludeWrapper<Relation, IncludeWrapper extends {} | undefined> = TypeUtilGetParamsColumns<IncludeWrapper> extends string | string[] ? TypeUtilGetParamsColumns<IncludeWrapper> : TypeUtilGetRelationOptionsColumns<Relation>;
+export type TypeModelRelationResult<TRecord, TModel extends BeanModelMeta | undefined, TOptionsRelation, TColumns = undefined, Aggrs = undefined, Groups = undefined> = Groups extends string | string[] ? TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, TColumns> : Aggrs extends {} ? TypeModelAggrRelationResultAggrs<Aggrs> : TypeModelRelationResult_Normal<TRecord, TModel, TOptionsRelation, TColumns>;
+export type TypeModelRelationResult_Normal<TRecord, TModel extends BeanModelMeta | undefined, TOptionsRelation, TColumns = undefined> = TypeUtilEntitySelector<TRecord, TypeUtilPrepareColumns<TColumns extends string | string[] ? TColumns : TypeUtilGetParamsColumns<TOptionsRelation>>> & (TModel extends BeanModelMeta ? (OmitNever<TypeModelRelationResultMergeInclude<TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>>> & OmitNever<TypeModelRelationResultMergeWith<TypeUtilGetParamsWith<TOptionsRelation>>>) : {});
+export type TypeModelRelationResultMergeInclude<TModelOptions extends IDecoratorModelOptions, TInclude extends {} | undefined> = {
+    [RelationName in (keyof TModelOptions['relations'])]: TInclude[RelationName] extends {} | boolean ? TypeModelRelationResultMergeIncludeWrapper<TModelOptions['relations'][RelationName], TInclude[RelationName]> : TypeModelRelationResultMergeAutoload<TModelOptions['relations'][RelationName]>;
+};
+export type TypeModelRelationResultMergeWith<TWith extends {} | undefined> = TWith extends {} ? {
+    [RelationName in (keyof TWith)]: TypeModelRelationResultMergeWithRelation<TWith[RelationName]>;
+} : {};
+export type TypeModelRelationResultMergeAutoload<Relation> = TypeUtilGetRelationOptionsAutoload<Relation> extends true ? TypeUtilGetRelationEntityByType<Relation, undefined> : never;
+export type TypeModelRelationResultMergeIncludeWrapper<Relation, IncludeWrapper> = IncludeWrapper extends false ? never : IncludeWrapper extends true ? TypeUtilGetRelationEntityByType<Relation, undefined> : IncludeWrapper extends {} ? TypeUtilGetRelationEntityByType<Relation, IncludeWrapper> : never;
+export type TypeModelRelationResultMergeWithRelation<WithRelation> = WithRelation extends false ? never : WithRelation extends true ? never : WithRelation extends {} ? TypeUtilGetRelationEntityByType<WithRelation, TypeUtilGetRelationOptions<WithRelation>> : never;

package/dist/types/relationsAggr.d.ts

@@ -0,0 +1,16 @@
+import type BigNumber from 'bignumber.js';
+import type { TypeUtilGetParamsAggrs, TypeUtilGetRelationOptionsAggrs } from './relations.ts';
+export type TypeModelAggrRelationResult<TOptions> = TypeUtilGetParamsAggrs<TOptions> extends {} ? TypeModelAggrRelationResultAggrs<TypeUtilGetParamsAggrs<TOptions>> : {};
+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]: BigNumber | undefined;
+};
+export type TypeUtilGetAggrsFromRelationAndIncludeWrapper<Relation, IncludeWrapper extends {} | undefined> = 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;
+};