vona-module-a-orm 5.0.37

package/dist/types/relationsColumns.d.ts

@@ -0,0 +1,45 @@
+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> = 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;
+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/dist/types/relationsDef.d.ts

@@ -0,0 +1,59 @@
+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 } from './onion/model.ts';
+import type { ITableRecord } from './onion/table.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 IModelRelationHasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>> {
+    type?: 'hasOne';
+    model?: TypeModelClassLike<MODEL>;
+    key?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    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]> = 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), 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?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    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]> = 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?: keyof ITableRecord;
+}
+export interface IModelRelationOptionsMeta extends IModelRelationOptionsMetaBasic {
+    middle?: IModelRelationOptionsMetaBasic;
+}
+export interface IModelRelationOptionsMetaWrapper {
+    meta?: IModelRelationOptionsMeta;
+}
+export type TypeModelRelationOptionsMetaClient = 'auto' | 'initial' | 'inherit' | keyof IDatabaseClientRecord | ServiceDb;

package/dist/types/relationsDefDynamic.d.ts

@@ -0,0 +1,56 @@
+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 { IModelClassRecord } from './onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { IModelRelationOptionsMetaWrapper } from './relationsDef.ts';
+import type { TypeModelSelectGroupParamsColumnNames } from './relationsGroup.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+export interface IModelRelationHasOneDynamic<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> = {}> {
+    type?: 'hasOne';
+    model?: TypeModelClassLike<MODEL>;
+    key?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    options?: OPTIONS;
+}
+export interface IModelRelationBelongsToDynamic<MODELSelf extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> = {}> {
+    type?: 'belongsTo';
+    model?: TypeModelClassLike<MODEL>;
+    key?: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity];
+    options?: OPTIONS;
+}
+export interface IModelRelationHasManyDynamic<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> = {}, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> {
+    type?: 'hasMany';
+    model?: TypeModelClassLike<MODEL>;
+    key?: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity];
+    options?: OPTIONS;
+}
+export interface IModelRelationBelongsToManyDynamic<MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> = {}, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> {
+    type?: 'belongsToMany';
+    modelMiddle?: TypeModelClassLike<MODELMiddle>;
+    model?: TypeModelClassLike<MODEL>;
+    keyFrom?: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity];
+    keyTo?: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity];
+    options?: OPTIONS;
+}
+export interface IModelRelationOptionsOneDynamic<MODEL extends BeanModelMeta> extends IModelRelationOptionsMetaWrapper, IModelRelationIncludeWrapper<MODEL> {
+    columns?: TypeModelColumnsPatch<MODEL[TypeSymbolKeyEntity], TypeModelColumn<MODEL[TypeSymbolKeyEntity]>>;
+}
+export interface IModelRelationOptionsManyDynamic<MODEL extends BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> extends IModelRelationOptionsMetaWrapper, IModelRelationIncludeWrapper<MODEL>, Omit<IModelRelationOptionsManyDynamic_Raw<MODEL, false, TypeModelColumn<MODEL[TypeSymbolKeyEntity]>, ModelJoins, Group>, 'autoload'> {
+}
+export type IModelRelationOptionsManyDynamic_Raw<MODEL extends BeanModelMeta, AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<MODEL[TypeSymbolKeyEntity]> = TypeModelColumn<MODEL[TypeSymbolKeyEntity]>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> = IBuildModelRelationOptionsManyDynamic<MODEL[TypeSymbolKeyEntity], AUTOLOAD, COLUMNS, TypeEntityTableNamesOfGeneral<ModelJoins, MODEL>, TypeEntityTableColumnNamesOfGeneral<ModelJoins, MODEL>, TypeEntityTableColumnsOfGeneral<ModelJoins, MODEL>, Group>;
+export interface IBuildModelRelationOptionsManyDynamic<TRecord, AUTOLOAD extends boolean = false, COLUMNS extends TypeModelColumn<TRecord> = TypeModelColumn<TRecord>, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined, Group extends boolean | undefined = undefined> extends IBuildModelSelectGeneralParamsBasicDynamic<TRecord, COLUMNS, TableNames, ColumnNames, Columns, Group> {
+    autoload?: AUTOLOAD;
+}
+export interface IBuildModelSelectGeneralParamsBasicDynamic<TRecord, COLUMNS extends TypeModelColumn<TRecord> = TypeModelColumn<TRecord>, TableNames = undefined, ColumnNames = keyof TRecord, Columns extends {} | undefined = undefined, Group extends boolean | undefined = undefined> {
+    distinct?: boolean | (keyof TRecord) | (keyof TRecord)[];
+    columns?: TypeModelColumnsPatch<TRecord, COLUMNS>;
+    aggrs?: TypeModelSelectAggrParamsAggrs<TRecord>;
+    groups?: TypeModelColumnsStrict<TRecord>;
+    where?: TypeModelWhere<TRecord, Columns>;
+    joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+    orders?: Group extends true ? IModelSelectParamsOrder<TypeModelSelectGroupParamsColumnNames<TRecord>>[] : IModelSelectParamsOrder<ColumnNames>[];
+    limit?: number;
+    offset?: number;
+}

package/dist/types/relationsDefMutate.d.ts

@@ -0,0 +1,9 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper } from './model.ts';
+import type { IModelRelationOptionsMetaWrapper } from './relationsDef.ts';
+export interface IModelRelationOptionsOneMutate<MODEL extends BeanModelMeta> extends IModelRelationOptionsMetaWrapper, IModelRelationIncludeWrapper<MODEL> {
+}
+export interface IModelRelationOptionsManyMutate<MODEL extends BeanModelMeta> extends IModelRelationOptionsMetaWrapper, IModelRelationIncludeWrapper<MODEL> {
+}
+export interface IModelRelationOptionsBelongsToManyMutate<_MODEL extends BeanModelMeta> extends IModelRelationOptionsMetaWrapper {
+}

package/dist/types/relationsGroup.d.ts

@@ -0,0 +1,21 @@
+import type { TypeModelSelectAggrParamsAggrs } from './modelAggr.ts';
+import type { TypeModelColumnsStrict } from './modelWhere.ts';
+import type { TypeUtilGetParamsAggrs, TypeUtilGetParamsColumns, TypeUtilGetParamsGroups, TypeUtilGetRelationOptionsGroups } from './relations.ts';
+import type { TypeModelAggrRelationResultAggr, TypeModelAggrRelationResultAggrs, TypeRecordAggrsValues, TypeRecordAggrsValuesToObject, TypeUtilAggrPrepareColumns } from './relationsAggr.ts';
+export type TypeModelGroupRelationResult<TRecord, TOptions> = TypeModelGroupRelationResultGroups<TRecord, TypeUtilGetParamsAggrs<TOptions>, TypeUtilGetParamsGroups<TOptions>, TypeUtilGetParamsColumns<TOptions>>;
+export type TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, Columns> = Groups extends string | string[] ? TypeModelGroupRelationResultGroupsObject<TRecord, Groups, Columns> & (Aggrs extends {} ? TypeRecordAggrsValuesToObject<TypeRecordAggrsValues<{
+    [K in keyof Aggrs]: K extends string ? TypeModelAggrRelationResultAggr<K, TypeUtilAggrPrepareColumns<Aggrs[K]>> : never;
+}>> : {}) : {};
+export type TypeModelGroupRelationResultGroupsObject<TRecord, Groups, Columns> = Columns extends string | string[] ? {
+    [K in TypeUtilAggrPrepareColumns<Columns>]: K extends keyof TRecord ? TRecord[K] : never;
+} : Groups extends string | string[] ? {
+    [K in TypeUtilAggrPrepareColumns<Groups>]: K extends keyof TRecord ? TRecord[K] : never;
+} : {};
+export type TypeModelSelectGroupParamsColumnNames<TRecord, ColumnNames extends TypeModelColumnsStrict<TRecord> | undefined = TypeModelColumnsStrict<TRecord>, Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> | undefined = TypeModelSelectAggrParamsAggrs<TRecord>> = (ColumnNames extends TypeModelColumnsStrict<TRecord> ? TypeUtilAggrPrepareColumns<ColumnNames> : never) | (Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> ? keyof TypeModelAggrRelationResultAggrs<Aggrs> : never);
+export type TypeModelSelectGroupParamsColumns<TRecord, ColumnNames extends TypeModelColumnsStrict<TRecord> | undefined = TypeModelColumnsStrict<TRecord>, Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> | undefined = TypeModelSelectAggrParamsAggrs<TRecord>> = (TypeUtilAggrPrepareColumns<ColumnNames> extends string ? {
+    [K in TypeUtilAggrPrepareColumns<ColumnNames>]: K extends keyof TRecord ? TRecord[K] : never;
+} : {}) & TypeModelAggrRelationResultAggrsToNumberType<TypeModelAggrRelationResultAggrs<Aggrs>>;
+export type TypeModelAggrRelationResultAggrsToNumberType<Columns> = {
+    [K in keyof Columns]: number | string;
+};
+export type TypeUtilGetGroupsFromRelationAndIncludeWrapper<Relation, IncludeWrapper extends {} | undefined> = TypeUtilGetParamsGroups<IncludeWrapper> extends string | string[] ? TypeUtilGetParamsGroups<IncludeWrapper> : TypeUtilGetRelationOptionsGroups<Relation>;

package/dist/types/relationsMutate.d.ts

@@ -0,0 +1,25 @@
+import type { OmitNever } from 'vona';
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IDecoratorModelOptions } from './onion/model.ts';
+import type { TypeUtilGetModelOptions, TypeUtilGetParamsInlcude, TypeUtilGetParamsWith, TypeUtilGetRelationEntity, TypeUtilGetRelationModel, TypeUtilGetRelationOptions, TypeUtilGetRelationOptionsAutoload, TypeUtilGetRelationType } from './relations.ts';
+import type { IModelRelationOptionsMetaWrapper } from './relationsDef.ts';
+export type TypeModelMutateParamsInclude<MODEL extends BeanModelMeta | undefined> = TypeModelMutateParamsIncludeByModelOptions<TypeUtilGetModelOptions<MODEL>>;
+export type TypeModelMutateParamsIncludeByModelOptions<ModelOptions extends IDecoratorModelOptions | undefined> = ModelOptions extends IDecoratorModelOptions ? {
+    [relationName in keyof ModelOptions['relations']]?: TypeModelMutateParamsRelationOptions<ModelOptions['relations'][relationName]>;
+} : never;
+export type TypeModelMutateParamsRelationOptions<Relation> = boolean | (IModelRelationOptionsMetaWrapper & {
+    include?: TypeModelMutateParamsInclude<TypeUtilGetRelationModel<Relation>>;
+    with?: Record<string, unknown>;
+});
+export type TypeModelMutateRelationResultMergeInclude<TModelOptions extends IDecoratorModelOptions, TInclude extends {} | undefined> = {
+    [RelationName in (keyof TModelOptions['relations'])]: TInclude[RelationName] extends {} | boolean ? TypeModelMutateRelationResultMergeIncludeWrapper<TModelOptions['relations'][RelationName], TInclude[RelationName]> : TypeModelMutateRelationResultMergeAutoload<TModelOptions['relations'][RelationName]>;
+};
+export type TypeModelMutateRelationResultMergeAutoload<Relation> = TypeUtilGetRelationOptionsAutoload<Relation> extends true ? TypeUtilMutateGetRelationEntityByType<Relation, undefined> : never;
+export type TypeModelMutateRelationResultMergeIncludeWrapper<Relation, IncludeWrapper> = IncludeWrapper extends false ? never : IncludeWrapper extends true ? TypeUtilMutateGetRelationEntityByType<Relation, undefined> : IncludeWrapper extends {} ? TypeUtilMutateGetRelationEntityByType<Relation, IncludeWrapper> : never;
+export type TypeUtilMutateGetRelationEntityByType<Relation, IncludeWrapper extends {} | undefined> = TypeUtilMutateGetEntityByType<TypeUtilGetRelationEntity<Relation>, TypeUtilGetRelationType<Relation>, TypeUtilGetRelationModel<Relation>, IncludeWrapper>;
+export type TypeUtilMutateGetEntityByType<TRecord, TYPE, TModel extends BeanModelMeta | undefined, IncludeWrapper extends {} | undefined> = TYPE extends 'hasMany' | 'belongsToMany' ? Array<TypeModelMutateRelationData<TRecord, TModel, IncludeWrapper>> | undefined : TypeModelMutateRelationData<TRecord, TModel, IncludeWrapper> | undefined;
+export type TypeModelMutateRelationResultMergeWith<TWith extends {} | undefined> = TWith extends {} ? {
+    [RelationName in (keyof TWith)]: TypeModelMutateRelationResultMergeWithRelation<TWith[RelationName]>;
+} : {};
+export type TypeModelMutateRelationResultMergeWithRelation<WithRelation> = WithRelation extends false ? never : WithRelation extends true ? never : WithRelation extends {} ? TypeUtilMutateGetRelationEntityByType<WithRelation, TypeUtilGetRelationOptions<WithRelation>> : never;
+export type TypeModelMutateRelationData<TRecord, TModel extends BeanModelMeta | undefined, TOptionsRelation> = Partial<TRecord> & (TModel extends BeanModelMeta ? (Partial<OmitNever<TypeModelMutateRelationResultMergeInclude<TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>>>> & Partial<OmitNever<TypeModelMutateRelationResultMergeWith<TypeUtilGetParamsWith<TOptionsRelation>>>>) : {});

package/dist/types/relationsTables.d.ts

@@ -0,0 +1,15 @@
+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, TypeSymbolKeyEntityMeta, TypeUtilGetModelOptions, TypeUtilGetRelationEntityMeta } from './relations.ts';
+export type TypeEntityTableNames<EntityMeta extends {
+    $table: string;
+} | undefined> = EntityMeta extends {
+    $table: infer TableName;
+} ? TableName : never;
+export type TypeEntityTableNamesOfModelOptions<TModelOptions extends IDecoratorModelOptions> = TModelOptions['relations'] extends {} ? TypeRecordValues<{
+    [RelationName in keyof TModelOptions['relations']]: TypeEntityTableNames<TypeUtilGetRelationEntityMeta<TModelOptions['relations'][RelationName]>>;
+}> : never;
+export type TypeEntityTableNamesOfModelJoins<TModelJoins extends TypeModelsClassLikeGeneral> = TypeEntityTableNames<TypeModelOfModelLike<TypeConfirmArray<TModelJoins>[number]>[TypeSymbolKeyEntityMeta]>;
+export type TypeEntityTableNamesOfModelClass<TModel extends BeanModelMeta> = TypeEntityTableNamesOfModelOptions<TypeUtilGetModelOptions<TModel>>;
+export type TypeEntityTableNamesOfGeneral<TModelJoins extends TypeModelsClassLikeGeneral | undefined, TModel extends BeanModelMeta | undefined> = TModel extends BeanModelMeta ? TModelJoins extends TypeModelsClassLikeGeneral ? TypeEntityTableNamesOfModelJoins<TModelJoins> : TypeEntityTableNamesOfModelClass<TModel> : undefined;

package/dist/types/tableIdentity.d.ts

@@ -0,0 +1 @@
+export * from 'table-identity';

package/dist/types/transaction.d.ts

@@ -0,0 +1,18 @@
+export declare const TransactionIsolationLevelsMap: {
+    DEFAULT: undefined;
+    READ_UNCOMMITTED: string;
+    READ_COMMITTED: string;
+    REPEATABLE_READ: string;
+    SERIALIZABLE: string;
+    SNAPSHOT: string;
+};
+export type TypeTransactionIsolationLevels = 'DEFAULT' | 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE' | 'SNAPSHOT';
+export type TypeTransactionPropagation = 'REQUIRED' | 'SUPPORTS' | 'MANDATORY' | 'REQUIRES_NEW' | 'NOT_SUPPORTED' | 'NEVER';
+export interface ITransactionOptions {
+    isolationLevel?: TypeTransactionIsolationLevels;
+    readOnly?: boolean;
+    propagation?: TypeTransactionPropagation;
+}
+export interface ITransactionConsistencyCommitOptions {
+    ctxPrefer?: boolean;
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "vona-module-a-orm",
+  "type": "module",
+  "version": "5.0.37",
+  "title": "a-orm",
+  "vonaModule": {
+    "capabilities": {
+      "monkey": true
+    },
+    "dependencies": {},
+    "globalDependencies": {
+      "bignumber.js": true,
+      "knex": true,
+      "table-identity": true
+    },
+    "onions": {
+      "entity": {
+        "sceneIsolate": true,
+        "optionsGlobalInterfaceName": "IDecoratorEntityOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-orm",
+        "scopeResource": true,
+        "scopeResourceTypeTemplate": "{{className}}Meta",
+        "boilerplate": "cli/entity/boilerplate",
+        "metadataCustom": "cli/entity/metadata/generate.ts"
+      },
+      "model": {
+        "sceneIsolate": true,
+        "optionsGlobalInterfaceName": "IDecoratorModelOptions",
+        "optionsGlobalInterfaceFrom": "vona-module-a-orm",
+        "scopeResource": true,
+        "boilerplate": "cli/model/boilerplate",
+        "metadataCustom": "cli/model/metadata/generate.ts"
+      },
+      "databaseDialect": {
+        "beanGeneral": true,
+        "boilerplate": "cli/databaseDialect/boilerplate"
+      }
+    }
+  },
+  "description": "db",
+  "author": "zhennann",
+  "keywords": [
+    "Cabloy Module"
+  ],
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "cli",
+    "dist",
+    "static"
+  ],
+  "dependencies": {
+    "bignumber.js": "^9.3.1",
+    "knex": "^3.1.0",
+    "table-identity": "^1.0.10"
+  },
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.0.1"
+  },
+  "gitHead": "0eab9dc4a5622caffe89e7b1b3f02c08ccbc4c4b",
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && vona :bin:buildModule && tsc -p tsconfig.build.json"
+  }
+}