vona-module-a-orm 5.0.37

package/dist/lib/columns.d.ts

@@ -0,0 +1,9 @@
+import type { Constructable } from 'vona';
+import type { ITableRecord, TypeEntityMeta } from '../types/index.ts';
+export declare function $column<T>(key: keyof T): keyof T;
+export declare function $columns<T>(key?: (keyof T) | Array<keyof T> | undefined): (keyof T) | Array<keyof T> | undefined;
+export declare function $columnsAll<T, TableName extends boolean, Meta extends boolean>(classEntity: (() => Constructable<T>) | Constructable<T>, withTableName?: TableName, withMeta?: Meta): TableName extends true ? (Meta extends true ? TypeEntityMeta<T> : Omit<TypeEntityMeta<T>, '$comment' | '$default'>) : (Meta extends true ? Omit<TypeEntityMeta<T>, '$table'> : Omit<TypeEntityMeta<T>, '$table' | '$comment' | '$default'>);
+export declare function $tableColumns<T>(classEntity: (() => Constructable<T>) | Constructable<T>, key?: (keyof T) | Array<keyof T> | undefined): Record<keyof ITableRecord, (keyof T) | Array<keyof T> | undefined>;
+export declare function $tableName<T>(classEntity: (() => Constructable<T>) | Constructable<T>): keyof ITableRecord;
+export declare function $tableComments<T>(classEntity: (() => Constructable<T>) | Constructable<T>): Record<string, string>;
+export declare function $tableDefaults<T>(classEntity: (() => Constructable<T>) | Constructable<T>): Record<string, any>;

package/dist/lib/database.d.ts

@@ -0,0 +1,6 @@
+import type { IAopMethodOptionsTransaction } from '../bean/aopMethod.transaction.ts';
+declare function Transaction(options?: Partial<IAopMethodOptionsTransaction>): MethodDecorator;
+export declare const Database: {
+    transaction: typeof Transaction;
+};
+export {};

package/dist/lib/databaseDialect.d.ts

@@ -0,0 +1 @@
+export declare function DatabaseDialect(): ClassDecorator;

package/dist/lib/dto/dto.d.ts

@@ -0,0 +1,12 @@
+import { DtoAggregate } from './dtoAggregate.ts';
+import { DtoCreate } from './dtoCreate.ts';
+import { DtoGet } from './dtoGet.ts';
+import { DtoGroup } from './dtoGroup.ts';
+import { DtoUpdate } from './dtoUpdate.ts';
+export declare const $Dto: {
+    create: typeof DtoCreate;
+    update: typeof DtoUpdate;
+    get: typeof DtoGet;
+    aggregate: typeof DtoAggregate;
+    group: typeof DtoGroup;
+};

package/dist/lib/dto/dtoAggregate.d.ts

@@ -0,0 +1,8 @@
+import type { Constructable } from 'vona';
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { TypeDtoAggrResult } from '../../types/dto/dtoAggregate.ts';
+import type { TypeModelSelectAggrParamsAggrs } from '../../types/modelAggr.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
+export declare function DtoAggregate<Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, aggrs: Aggrs): Constructable<TypeDtoAggrResult<Aggrs>>;
+export declare function _DtoAggregate_inner<Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(classTarget: Constructable, _modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, aggrs: Aggrs): Constructable<TypeDtoAggrResult<Aggrs>>;

package/dist/lib/dto/dtoCreate.d.ts

@@ -0,0 +1,5 @@
+import type { Constructable } from 'vona';
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoMutateParams, TypeDtoMutateResult } from '../../types/dto/dtoMutate.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+export declare function DtoCreate<T extends IDtoMutateParams<ModelLike>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, params?: T): Constructable<TypeDtoMutateResult<ModelLike, T>>;

package/dist/lib/dto/dtoGet.d.ts

@@ -0,0 +1,8 @@
+import type { Constructable } from 'vona';
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoGetParams, TypeDtoGetResult } from '../../types/dto/dtoGet.ts';
+import type { TypeDtoMutateType } from '../../types/dto/dtoMutate.ts';
+import type { IModelRelationIncludeWrapper } from '../../types/model.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+export declare function DtoGet<T extends IDtoGetParams<ModelLike>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, params?: T): Constructable<TypeDtoGetResult<ModelLike, T>>;
+export declare function _DtoGet_relations<TRecord extends {}, TModel extends BeanModelMeta>(modelClass: Constructable<TModel>, entityClass: Constructable<TRecord>, includeWrapper?: IModelRelationIncludeWrapper, mutateTypeTopLevel?: TypeDtoMutateType): void;

package/dist/lib/dto/dtoGroup.d.ts

@@ -0,0 +1,8 @@
+import type { Constructable } from 'vona';
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { TypeDtoGroupResult } from '../../types/dto/dtoGroup.ts';
+import type { TypeModelSelectAggrParamsAggrs } from '../../types/modelAggr.ts';
+import type { TypeModelColumnsStrict } from '../../types/modelWhere.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
+export declare function DtoGroup<Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>, Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>, Columns extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, groups: Groups, aggrs?: Aggrs, columns?: Columns): Constructable<TypeDtoGroupResult<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], Aggrs, Groups, Columns>>;

package/dist/lib/dto/dtoMutate.d.ts

@@ -0,0 +1,8 @@
+import type { Constructable } from 'vona';
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoMutateParams, TypeDtoMutateResult, TypeDtoMutateType } from '../../types/dto/dtoMutate.ts';
+import type { TypeModelColumnsStrict } from '../../types/modelWhere.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
+export declare function DtoMutate<T extends IDtoMutateParams<ModelLike>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, params?: T): Constructable<TypeDtoMutateResult<ModelLike, T>>;
+export declare function _DtoMutate_raw<T extends IDtoMutateParams<ModelLike>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord), ColumnsOmitDefault extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, params?: T, mutateTypeTopLevel?: TypeDtoMutateType, columnsOmitDefault?: ColumnsOmitDefault, topLevel?: boolean): Constructable<TypeDtoMutateResult<ModelLike, T>>;

package/dist/lib/dto/dtoUpdate.d.ts

@@ -0,0 +1,5 @@
+import type { Constructable } from 'vona';
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoMutateParams, TypeDtoMutateResult } from '../../types/dto/dtoMutate.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+export declare function DtoUpdate<T extends IDtoMutateParams<ModelLike>, ModelLike extends BeanModelMeta | (keyof IModelClassRecord)>(modelLike: ModelLike extends BeanModelMeta ? ((() => Constructable<ModelLike>) | Constructable<ModelLike>) : ModelLike, params?: T): Constructable<Partial<TypeDtoMutateResult<ModelLike, T>>>;

package/dist/lib/dto/index.d.ts

@@ -0,0 +1 @@
+export * from './dto.ts';

package/dist/lib/entity.d.ts

@@ -0,0 +1,3 @@
+import type { IDecoratorEntityOptions } from '../types/onion/entity.ts';
+export declare function Entity<T extends IDecoratorEntityOptions<any>>(options?: T): ClassDecorator;
+export declare function Entity<T extends IDecoratorEntityOptions<any>>(table?: string, options?: Omit<T, 'table'>): ClassDecorator;

package/dist/lib/index.d.ts

@@ -0,0 +1,10 @@
+export * from './columns.ts';
+export * from './database.ts';
+export * from './databaseDialect.ts';
+export * from './dto/index.ts';
+export * from './entity.ts';
+export * from './model.ts';
+export * from './relations.ts';
+export * from './relationsDynamic.ts';
+export * from './relationsMutate.ts';
+export * from './relationsStatic.ts';

package/dist/lib/model.d.ts

@@ -0,0 +1,2 @@
+import type { IDecoratorModelOptions } from '../types/onion/model.ts';
+export declare function Model<T extends IDecoratorModelOptions>(options?: T): ClassDecorator;

package/dist/lib/modelCacheBase.d.ts

@@ -0,0 +1,20 @@
+import type { IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
+import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
+import type { TypeModelCacheType } from '../types/model.ts';
+import type { ITableRecord } from '../types/onion/table.ts';
+import { BeanBase } from 'vona';
+declare const SymbolCacheOptions: unique symbol;
+export declare class ModelCacheBase extends BeanBase {
+    private [SymbolCacheOptions];
+    protected _model: BeanModelCache;
+    private _cacheType;
+    protected __init__(model: BeanModelCache, cacheType: TypeModelCacheType): void;
+    private get scopeOrm();
+    getInstance(table: keyof ITableRecord): import("vona-module-a-summer").BeanSummerCacheBase<any, any>;
+    getName(table: keyof ITableRecord): string;
+    get options(): false | IDecoratorSummerCacheOptions;
+    get enabled(): any;
+    private _getCacheEnabledInner;
+    private _getCacheOptionsInner;
+}
+export {};

package/dist/lib/relations.d.ts

@@ -0,0 +1,15 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelClassRecord } from '../types/onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from '../types/relations.ts';
+import type { IModelRelationOptionsManyStatic, IModelRelationOptionsOneStatic } from './relationsStatic.ts';
+declare function hasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneStatic<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS): any;
+declare function belongsTo<MODELSelf extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneStatic<TypeModelOfModelLike<MODEL>>>(_classModelSelf: TypeModelClassLike<MODELSelf>, classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity], options?: OPTIONS): any;
+declare function hasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyStatic<TypeModelOfModelLike<MODEL>, ModelJoins, Group>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS, _modelJoins?: ModelJoins, _group?: Group): any;
+declare function belongsToMany<MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyStatic<TypeModelOfModelLike<MODEL>, ModelJoins, Group>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined>(classModelMiddle: TypeModelClassLike<MODELMiddle>, classModel: TypeModelClassLike<MODEL>, keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], options?: OPTIONS, _modelJoins?: ModelJoins, _group?: Group): any;
+export declare const $relation: {
+    hasOne: typeof hasOne;
+    belongsTo: typeof belongsTo;
+    hasMany: typeof hasMany;
+    belongsToMany: typeof belongsToMany;
+};
+export {};

package/dist/lib/relationsDynamic.d.ts

@@ -0,0 +1,15 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelClassRecord } from '../types/onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from '../types/relations.ts';
+import type { IModelRelationBelongsToDynamic, IModelRelationBelongsToManyDynamic, IModelRelationHasManyDynamic, IModelRelationHasOneDynamic, IModelRelationOptionsManyDynamic, IModelRelationOptionsOneDynamic } from '../types/relationsDefDynamic.ts';
+declare function hasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, OPTIONS>;
+declare function belongsTo<MODELSelf extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>>>(_classModelSelf: TypeModelClassLike<MODELSelf>, classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationBelongsToDynamic<MODELSelf, MODEL, OPTIONS>;
+declare function hasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS, _modelJoins?: ModelJoins, _group?: Group): IModelRelationHasManyDynamic<MODEL, OPTIONS, ModelJoins, Group>;
+declare function belongsToMany<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>(classModelMiddle: TypeModelClassLike<MODELMiddle>, classModel: TypeModelClassLike<MODEL>, keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], options?: OPTIONS, _modelJoins?: ModelJoins, _group?: Group): IModelRelationBelongsToManyDynamic<MODELMiddle, MODEL, OPTIONS, ModelJoins, Group>;
+export declare const $relationDynamic: {
+    hasOne: typeof hasOne;
+    belongsTo: typeof belongsTo;
+    hasMany: typeof hasMany;
+    belongsToMany: typeof belongsToMany;
+};
+export {};

package/dist/lib/relationsMutate.d.ts

@@ -0,0 +1,14 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelClassRecord } from '../types/onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeSymbolKeyEntity } from '../types/relations.ts';
+import type { IModelRelationBelongsToManyDynamic, IModelRelationHasManyDynamic, IModelRelationHasOneDynamic } from '../types/relationsDefDynamic.ts';
+import type { IModelRelationOptionsBelongsToManyMutate, IModelRelationOptionsManyMutate, IModelRelationOptionsOneMutate } from '../types/relationsDefMutate.ts';
+declare function hasOne<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsOneMutate<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, OPTIONS>;
+declare function hasMany<MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsManyMutate<TypeModelOfModelLike<MODEL>>>(classModel: TypeModelClassLike<MODEL>, key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationHasManyDynamic<MODEL, OPTIONS>;
+declare function belongsToMany<MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord), MODEL extends BeanModelMeta | (keyof IModelClassRecord), OPTIONS extends IModelRelationOptionsBelongsToManyMutate<TypeModelOfModelLike<MODEL>>>(classModelMiddle: TypeModelClassLike<MODELMiddle>, classModel: TypeModelClassLike<MODEL>, keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity], options?: OPTIONS): IModelRelationBelongsToManyDynamic<MODELMiddle, MODEL, OPTIONS>;
+export declare const $relationMutate: {
+    hasOne: typeof hasOne;
+    hasMany: typeof hasMany;
+    belongsToMany: typeof belongsToMany;
+};
+export {};

package/dist/lib/relationsStatic.d.ts

@@ -0,0 +1,9 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { TypeModelsClassLikeGeneral } from '../types/relations.ts';
+import type { IModelRelationOptionsManyDynamic, IModelRelationOptionsOneDynamic } from '../types/relationsDefDynamic.ts';
+export interface IModelRelationOptionsManyStatic<MODEL extends BeanModelMeta, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined, Group extends boolean | undefined = undefined> extends Omit<IModelRelationOptionsManyDynamic<MODEL, ModelJoins, Group>, 'include' | 'with'> {
+    autoload?: boolean;
+}
+export interface IModelRelationOptionsOneStatic<MODEL extends BeanModelMeta> extends Omit<IModelRelationOptionsOneDynamic<MODEL>, 'include' | 'with'> {
+    autoload?: boolean;
+}

package/dist/main.d.ts

@@ -0,0 +1,9 @@
+import type { IModuleMain, PowerPartial, VonaApplication } from 'vona';
+import type { ConfigDatabase } from './types/config.ts';
+import { BeanSimple } from 'vona';
+export declare class Main extends BeanSimple implements IModuleMain {
+    moduleLoading(): Promise<void>;
+    moduleLoaded(): Promise<void>;
+    configLoaded(_config: any): Promise<void>;
+}
+export declare function configDefault(app: VonaApplication): Promise<PowerPartial<ConfigDatabase>>;

package/dist/service/cacheEntity_.d.ts

@@ -0,0 +1,10 @@
+import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
+import type { ITableRecord } from '../types/onion/table.ts';
+import type { TableIdentity } from '../types/tableIdentity.ts';
+import { ModelCacheBase } from '../lib/modelCacheBase.ts';
+export declare class ServiceCacheEntity extends ModelCacheBase {
+    protected __init__(model: BeanModelCache): void;
+    clear(table?: keyof ITableRecord): Promise<void>;
+    del(id: TableIdentity | TableIdentity[], table?: keyof ITableRecord): Promise<void>;
+    get keysAux(): import("vona-module-a-orm").TypeModelColumnsStrict<any> | undefined;
+}

package/dist/service/cacheQuery_.d.ts

@@ -0,0 +1,7 @@
+import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
+import type { ITableRecord } from '../types/onion/table.ts';
+import { ModelCacheBase } from '../lib/modelCacheBase.ts';
+export declare class ServiceCacheQuery extends ModelCacheBase {
+    protected __init__(model: BeanModelCache): void;
+    clear(table?: keyof ITableRecord): Promise<void>;
+}

package/dist/service/columnsCache_.d.ts

@@ -0,0 +1,22 @@
+import type { ITableColumns, ITableColumnsDefault } from '../types/columns.ts';
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import { BeanBase } from 'vona';
+declare const SymbolColumnsCache: unique symbol;
+declare const SymbolColumnsDefaultCache: unique symbol;
+export declare class ServiceColumnsCache extends BeanBase {
+    clientName: keyof IDatabaseClientRecord;
+    protected [SymbolColumnsCache]: Record<string, ITableColumns>;
+    protected [SymbolColumnsDefaultCache]: Record<string, ITableColumnsDefault>;
+    private _onColumnsClearCancel?;
+    /** real client name */
+    protected __init__(clientName: keyof IDatabaseClientRecord): void;
+    protected __dispose__(): Promise<void>;
+    getColumnsDefaultCache(table: string): ITableColumnsDefault;
+    setColumnsDefaultCache(table: string, data: ITableColumnsDefault): void;
+    deleteColumnsDefaultCache(table: string): void;
+    getColumnsCache(table: string): ITableColumns;
+    setColumnsCache(table: string, columns: ITableColumns): void;
+    deleteColumnsCache(table: string): void;
+    columnsClear(tableName?: string): boolean | ITableColumns;
+}
+export {};

package/dist/service/columns_.d.ts

@@ -0,0 +1,13 @@
+import type { ITableColumns, ITableColumnsDefault } from '../types/columns.ts';
+import type { ServiceDb } from './db_.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceColumns extends BeanBase {
+    private _db;
+    private _serviceColumnsCache;
+    protected __init__(db: ServiceDb): void;
+    private get db();
+    private get serviceColumnsCache();
+    columns(tableName?: string): Promise<ITableColumns>;
+    defaultData(tableName?: string): Promise<ITableColumnsDefault>;
+    columnsClear(tableName?: string): void;
+}

package/dist/service/database.d.ts

@@ -0,0 +1,17 @@
+import type { BeanDatabaseDialectBase } from '../bean/bean.databaseDialectBase.ts';
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IDatabaseClientDialectRecord, IDatabaseClientRecord, IDbInfo } from '../types/database.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceDatabase extends BeanBase {
+    getDialect(client: keyof IDatabaseClientDialectRecord): BeanDatabaseDialectBase;
+    prepareDbInfo(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): IDbInfo;
+    prepareClientNameSelector(dbInfo: IDbInfo): string;
+    parseClientNameSelector(clientNameSelector: string): IDbInfo;
+    prepareClientName(clientName?: keyof IDatabaseClientRecord): keyof IDatabaseClientRecord;
+    getDefaultClientName(): keyof IDatabaseClientRecord;
+    prepareClientNameReal(clientName?: keyof IDatabaseClientRecord): keyof IDatabaseClientRecord;
+    columnsClear(clientName?: keyof IDatabaseClientRecord, tableName?: string): void;
+    private __columnsClearRaw;
+    reloadClients(clientName?: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient, extraData?: any): Promise<void>;
+    private __reloadAllClientsRaw;
+}

package/dist/service/databaseAsyncLocalStorage_.d.ts

@@ -0,0 +1,10 @@
+import type { FunctionAsync } from 'vona';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BeanBase } from 'vona';
+import { ServiceDb } from '../service/db_.ts';
+export declare class ServiceDatabaseAsyncLocalStorage extends BeanBase {
+    dbStorage: AsyncLocalStorage<ServiceDb>;
+    protected __init__(): void;
+    get current(): ServiceDb;
+    run<RESULT>(store: ServiceDb, fn: FunctionAsync<RESULT>): Promise<RESULT>;
+}

package/dist/service/databaseClient_.d.ts

@@ -0,0 +1,30 @@
+import type { Knex } from 'knex';
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import { BeanBase } from 'vona';
+import { ServiceDb } from './db_.ts';
+export interface IPrepareDatabaseNameResult {
+    database?: string;
+    filename?: string;
+}
+export declare class ServiceDatabaseClient extends BeanBase {
+    level: number;
+    clientName: keyof IDatabaseClientRecord;
+    clientNameSelector: string;
+    clientConfig: ConfigDatabaseClient;
+    private _knex;
+    private _db;
+    private _onDatabaseClientReloadCancel?;
+    get configDatabase(): import("../types/config.ts").ConfigDatabase;
+    get connection(): Knex;
+    get db(): ServiceDb;
+    protected __init__(clientNameSelector: string, clientConfig?: ConfigDatabaseClient): void;
+    protected __dispose__(): Promise<void>;
+    private __load;
+    private __close;
+    reload(clientConfig?: ConfigDatabaseClient): Promise<void>;
+    getClientConfig(clientName: keyof IDatabaseClientRecord, original?: boolean): ConfigDatabaseClient;
+    getDatabaseName(): string;
+    private _prepareDatabaseName;
+    changeConfigAndReload(databaseName: string): Promise<void>;
+}

package/dist/service/db_.d.ts

@@ -0,0 +1,26 @@
+import type { FunctionAny } from 'vona';
+import type { BeanDatabaseDialectBase } from '../bean/bean.databaseDialectBase.ts';
+import type { IDatabaseClientDialectRecord, IDbInfo } from '../types/database.ts';
+import type { ITransactionConsistencyCommitOptions } from '../types/transaction.ts';
+import type { ServiceDatabaseClient } from './databaseClient_.ts';
+import { BeanBase } from 'vona';
+import { ServiceColumns } from './columns_.ts';
+import { ServiceTransaction } from './transaction_.ts';
+export declare class ServiceDb extends BeanBase {
+    private _client;
+    private _columns;
+    private _transaction;
+    protected __init__(client: ServiceDatabaseClient): void;
+    get info(): IDbInfo;
+    get level(): number;
+    get clientName(): keyof import("../types/database.ts").IDatabaseClientRecord;
+    get client(): ServiceDatabaseClient;
+    get columns(): ServiceColumns;
+    get transaction(): ServiceTransaction;
+    get inTransaction(): boolean;
+    get connection(): import("knex").Knex<any, any[]>;
+    get dialectName(): keyof IDatabaseClientDialectRecord;
+    get dialect(): BeanDatabaseDialectBase;
+    commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions): void;
+    compensate(cb: FunctionAny): void;
+}

package/dist/service/entityResolver_.d.ts

@@ -0,0 +1,9 @@
+import { BeanBase } from 'vona';
+declare const SymbolModuleScope: unique symbol;
+export declare class ServiceEntityResolver extends BeanBase {
+    protected [SymbolModuleScope]: string;
+    private __instances;
+    constructor(moduleScope: string);
+    protected __get__(prop: string): any;
+}
+export {};

package/dist/service/modelResolver_.d.ts

@@ -0,0 +1,8 @@
+import { BeanBase } from 'vona';
+declare const SymbolModuleScope: unique symbol;
+export declare class ServiceModelResolver extends BeanBase {
+    protected [SymbolModuleScope]: string;
+    constructor(moduleScope: string);
+    protected __get__(prop: string): any;
+}
+export {};

package/dist/service/relations_.d.ts

@@ -0,0 +1,19 @@
+import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
+import type { IModelMethodOptions, IModelRelationIncludeWrapper } from '../types/model.ts';
+import type { TableIdentity } from '../types/tableIdentity.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceRelations extends BeanBase {
+    protected _model: BeanModelCache;
+    protected __init__(model: BeanModelCache): void;
+    handleRelationsOne<TRecord extends {}>(entity: TRecord | undefined, includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<TRecord | undefined>;
+    handleRelationsMany<TRecord extends {}>(entities: TRecord[], includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<TRecord[]>;
+    handleRelationsMutate<TRecord extends {}>(entitiesResult: TRecord[], entities: TRecord[], includeWrapper: IModelRelationIncludeWrapper | undefined, methodOptions: IModelMethodOptions | undefined): Promise<TRecord[]>;
+    handleRelationsDelete(ids: TableIdentity[], includeWrapper?: IModelRelationIncludeWrapper, methodOptions?: IModelMethodOptions): Promise<void>;
+    private __handleRelationOne;
+    private __handleRelationMany;
+    private __handleRelationMutate;
+    private __handleRelationDelete;
+    private __prepareColumnsAndKey;
+    private __getModelTarget;
+    private __handleRelationsCollection;
+}

package/dist/service/transactionAsyncLocalStorage_.d.ts

@@ -0,0 +1,10 @@
+import type { FunctionAsync } from 'vona';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BeanBase } from 'vona';
+import { ServiceTransactionState } from './transactionState_.ts';
+export declare class ServiceTransactionAsyncLocalStorage extends BeanBase {
+    transactionStorage: AsyncLocalStorage<ServiceTransactionState>;
+    protected __init__(): void;
+    get transactionState(): ServiceTransactionState;
+    run<RESULT>(fn: FunctionAsync<RESULT>): Promise<RESULT>;
+}

package/dist/service/transactionConsistency/342/200/214_.d.ts

@@ -0,0 +1,10 @@
+import type { FunctionAny } from 'vona';
+import { BeanBase } from 'vona';
+export declare class ServiceTransactionConsistency‌ extends BeanBase {
+    private _commitCallbacks;
+    private _compensateCallbacks;
+    commit(cb: FunctionAny): void;
+    compensate(cb: FunctionAny): void;
+    commitDone(): Promise<void>;
+    compensateDone(): Promise<void>;
+}

package/dist/service/transactionFiber_.d.ts

@@ -0,0 +1,13 @@
+import type knex from 'knex';
+import type { FunctionAny } from 'vona';
+import { BeanBase } from 'vona';
+export declare class ServiceTransactionFiber extends BeanBase {
+    private _connection;
+    private _transactionConsistency;
+    protected __init__(connection: knex.Knex.Transaction): void;
+    get connection(): knex.Knex.Transaction<any, any[]>;
+    commit(cb: FunctionAny): void;
+    compensate(cb: FunctionAny): void;
+    doCommit(): Promise<void>;
+    doRollback(): Promise<void>;
+}

package/dist/service/transactionState_.d.ts

@@ -0,0 +1,11 @@
+import type knex from 'knex';
+import type { IDbInfo } from '../types/index.ts';
+import { BeanBase } from 'vona';
+import { ServiceTransactionFiber } from './transactionFiber_.ts';
+export declare class ServiceTransactionState extends BeanBase {
+    private _fibers;
+    private get serviceDatabase();
+    get(dbInfo: IDbInfo): ServiceTransactionFiber | undefined;
+    add(dbInfo: IDbInfo, connection: knex.Knex.Transaction): ServiceTransactionFiber;
+    remove(dbInfo: IDbInfo): void;
+}

package/dist/service/transaction_.d.ts

@@ -0,0 +1,18 @@
+import type knex from 'knex';
+import type { FunctionAny, FunctionAsync } from 'vona';
+import type { ITransactionConsistencyCommitOptions, ITransactionOptions } from '../types/transaction.ts';
+import type { ServiceDb } from './db_.ts';
+import type { ServiceTransactionFiber } from './transactionFiber_.ts';
+import { BeanBase } from 'vona';
+export declare class ServiceTransaction extends BeanBase {
+    private _db;
+    protected __init__(db: ServiceDb): void;
+    get transactionState(): import("vona-module-a-orm").ServiceTransactionState;
+    get transactionFiber(): ServiceTransactionFiber | undefined;
+    get inTransaction(): boolean;
+    get connection(): knex.Knex.Transaction | undefined;
+    commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions): void;
+    compensate(cb: FunctionAny): void;
+    begin<RESULT>(fn: FunctionAsync<RESULT>, options?: ITransactionOptions): Promise<RESULT>;
+    private _isolationLevelRequired;
+}

package/dist/types/columns.d.ts

@@ -0,0 +1,6 @@
+export interface ITableColumn {
+    type: string;
+    default: any;
+}
+export type ITableColumns = Record<string, ITableColumn>;
+export type ITableColumnsDefault = Record<string, any>;

package/dist/types/config.d.ts

@@ -0,0 +1,14 @@
+import type { Knex } from 'knex';
+import type { VonaContext } from 'vona';
+import type { IDatabaseClientDialectRecord, IDatabaseClientRecord } from './database.ts';
+export type TypeDefaultClientNameFn = (ctx: VonaContext) => keyof IDatabaseClientRecord;
+export type TypeDefaultClientName = TypeDefaultClientNameFn | keyof IDatabaseClientRecord;
+export interface ConfigDatabaseClient extends Omit<Knex.Config, 'client'> {
+    client: keyof IDatabaseClientDialectRecord;
+}
+export interface ConfigDatabase {
+    testDatabase: boolean;
+    defaultClient: TypeDefaultClientName;
+    clients: Record<keyof IDatabaseClientRecord, ConfigDatabaseClient>;
+    base: ConfigDatabaseClient;
+}

package/dist/types/database.d.ts

@@ -0,0 +1,47 @@
+import type { FunctionAny } from 'vona';
+import type { BeanModel } from '../bean/bean.model.ts';
+import type { ServiceDb } from '../service/db_.ts';
+import type { ConfigDatabase } from './config.ts';
+export interface IDbInfo {
+    level: number;
+    clientName: keyof IDatabaseClientRecord;
+}
+export interface IDatabaseClientRecord {
+    default: never;
+    pg: never;
+    mysql: never;
+}
+export interface IDatabaseClientDialectRecord {
+    pg: never;
+    mysql: never;
+    mysql2: never;
+}
+export interface IDatabaseSwitchOptions {
+    clientName?: keyof IDatabaseClientRecord;
+}
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        model: BeanModel;
+    }
+    interface VonaConfig {
+        database: ConfigDatabase;
+    }
+    interface VonaContext {
+        get db(): ServiceDb;
+        commit(cb: FunctionAny): void;
+        commitDone(): Promise<void>;
+    }
+    interface VonaConfigEnv {
+        DATABASE_DEFAULT_CLIENT: string | undefined;
+        DATABASE_CLIENT_PG_HOST: string | undefined;
+        DATABASE_CLIENT_PG_PORT: string | undefined;
+        DATABASE_CLIENT_PG_USER: string | undefined;
+        DATABASE_CLIENT_PG_PASSWORD: string | undefined;
+        DATABASE_CLIENT_PG_DATABASE: string | undefined;
+        DATABASE_CLIENT_MYSQL_HOST: string | undefined;
+        DATABASE_CLIENT_MYSQL_PORT: string | undefined;
+        DATABASE_CLIENT_MYSQL_USER: string | undefined;
+        DATABASE_CLIENT_MYSQL_PASSWORD: string | undefined;
+        DATABASE_CLIENT_MYSQL_DATABASE: string | undefined;
+    }
+}

package/dist/types/dialect.d.ts

@@ -0,0 +1,6 @@
+export interface IFetchDatabasesResultItem {
+    name: string;
+}
+export interface IFetchIndexesResultItem {
+    indexName: string;
+}

package/dist/types/dto/dtoAggregate.d.ts

@@ -0,0 +1,2 @@
+import type { TypeModelAggrRelationResultAggrs } from '../relationsAggr.ts';
+export type TypeDtoAggrResult<Aggrs> = TypeModelAggrRelationResultAggrs<Aggrs>;

package/dist/types/dto/dtoGet.d.ts

@@ -0,0 +1,12 @@
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper } from '../model.ts';
+import type { TypeModelColumns } from '../modelWhere.ts';
+import type { IModelClassRecord } from '../onion/model.ts';
+import type { TypeModelOfModelLike, TypeModelRelationResult, TypeSymbolKeyEntity } from '../relations.ts';
+export type IDtoGetParams<ModelLike extends BeanModelMeta | (keyof IModelClassRecord)> = IBuildDtoGetParams<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], TypeModelOfModelLike<ModelLike>>;
+export interface IBuildDtoGetParams<TRecord, Model extends BeanModelMeta> extends IModelRelationIncludeWrapper<Model>, IBuildDtoGetParamsBasic<TRecord> {
+}
+export interface IBuildDtoGetParamsBasic<TRecord> {
+    columns?: TypeModelColumns<TRecord>;
+}
+export type TypeDtoGetResult<ModelLike extends BeanModelMeta | (keyof IModelClassRecord), TOptionsRelation> = TypeModelRelationResult<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], TypeModelOfModelLike<ModelLike>, TOptionsRelation>;

package/dist/types/dto/dtoGroup.d.ts

@@ -0,0 +1,2 @@
+import type { TypeModelGroupRelationResultGroups } from '../relationsGroup.ts';
+export type TypeDtoGroupResult<TRecord, Aggrs, Groups, Columns> = TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, Columns>;

package/dist/types/dto/dtoMutate.d.ts

@@ -0,0 +1,14 @@
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper } from '../model.ts';
+import type { TypeModelColumnsStrict } from '../modelWhere.ts';
+import type { IModelClassRecord } from '../onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../relations.ts';
+import type { TypeModelMutateRelationData } from '../relationsMutate.ts';
+export type TypeDtoMutateType = 'create' | 'update' | 'mutate';
+export type IDtoMutateParams<ModelLike extends BeanModelMeta | (keyof IModelClassRecord)> = IBuildDtoMutateParams<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], TypeModelOfModelLike<ModelLike>>;
+export interface IBuildDtoMutateParams<TRecord, Model extends BeanModelMeta> extends IModelRelationIncludeWrapper<Model>, IBuildDtoMutateParamsBasic<TRecord> {
+}
+export interface IBuildDtoMutateParamsBasic<TRecord> {
+    columns?: TypeModelColumnsStrict<TRecord>;
+}
+export type TypeDtoMutateResult<ModelLike extends BeanModelMeta | (keyof IModelClassRecord), TOptionsRelation> = TypeModelMutateRelationData<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], TypeModelOfModelLike<ModelLike>, TOptionsRelation>;

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

@@ -0,0 +1,4 @@
+export * from './dtoAggregate.ts';
+export * from './dtoGet.ts';
+export * from './dtoGroup.ts';
+export * from './dtoMutate.ts';