vona-module-a-version 5.0.21 → 5.0.23

package/dist/.metadata/index.d.ts

@@ -1,4 +1,4 @@
-import type { TypeMetaEntity } from 'vona-module-a-database';
+import type { TypeEntityMeta, TypeModelsClassLikeGeneral, TypeSymbolKeyFieldsMore } from 'vona-module-a-orm';
 import type { TypeEntityOptionsFields } from 'vona-module-a-openapi';
 /** entity: begin */
 export * from '../entity/version.ts';
@@ -8,11 +8,11 @@ import type { IEntityOptionsVersion } from '../entity/version.ts';
 import type { IEntityOptionsVersionInit } from '../entity/versionInit.ts';
 import type { IEntityOptionsViewRecord } from '../entity/viewRecord.ts';
 import 'vona';
-declare module 'vona-module-a-database' {
+declare module 'vona-module-a-orm' {
     interface IEntityRecord {
-        'a-version:version': Omit<IEntityOptionsVersion, '_fieldsMore_'>;
-        'a-version:versionInit': Omit<IEntityOptionsVersionInit, '_fieldsMore_'>;
-        'a-version:viewRecord': Omit<IEntityOptionsViewRecord, '_fieldsMore_'>;
+        'a-version:version': IEntityOptionsVersion;
+        'a-version:versionInit': IEntityOptionsVersionInit;
+        'a-version:viewRecord': IEntityOptionsViewRecord;
     }
 }
 declare module 'vona-module-a-version' {
@@ -23,16 +23,19 @@ import type { EntityVersion } from '../entity/version.ts';
 import type { EntityVersionInit } from '../entity/versionInit.ts';
 import type { EntityViewRecord } from '../entity/viewRecord.ts';
 export interface IModuleEntity {
-    'version': TypeMetaEntity<EntityVersion, EntityVersionTableName>;
-    'versionInit': TypeMetaEntity<EntityVersionInit, EntityVersionInitTableName>;
-    'viewRecord': TypeMetaEntity<EntityViewRecord, EntityViewRecordTableName>;
+    'version': EntityVersionMeta;
+    'versionInit': EntityVersionInitMeta;
+    'viewRecord': EntityViewRecordMeta;
 }
 /** entity: end */
 /** entity: begin */
 export type EntityVersionTableName = 'aVersion';
 export type EntityVersionInitTableName = 'aVersionInit';
 export type EntityViewRecordTableName = 'aViewRecord';
-declare module 'vona-module-a-database' {
+export type EntityVersionMeta = TypeEntityMeta<EntityVersion, EntityVersionTableName>;
+export type EntityVersionInitMeta = TypeEntityMeta<EntityVersionInit, EntityVersionInitTableName>;
+export type EntityViewRecordMeta = TypeEntityMeta<EntityViewRecord, EntityViewRecordTableName>;
+declare module 'vona-module-a-orm' {
     interface ITableRecord {
         'aVersion': never;
         'aVersionInit': never;
@@ -41,35 +44,132 @@ declare module 'vona-module-a-database' {
 }
 declare module 'vona-module-a-version' {
     interface IEntityOptionsVersion {
-        fields?: TypeEntityOptionsFields<EntityVersion, IEntityOptionsVersion['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<EntityVersion, IEntityOptionsVersion[TypeSymbolKeyFieldsMore]>;
     }
     interface IEntityOptionsVersionInit {
-        fields?: TypeEntityOptionsFields<EntityVersionInit, IEntityOptionsVersionInit['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<EntityVersionInit, IEntityOptionsVersionInit[TypeSymbolKeyFieldsMore]>;
     }
     interface IEntityOptionsViewRecord {
-        fields?: TypeEntityOptionsFields<EntityViewRecord, IEntityOptionsViewRecord['_fieldsMore_']>;
+        fields?: TypeEntityOptionsFields<EntityViewRecord, IEntityOptionsViewRecord[TypeSymbolKeyFieldsMore]>;
     }
 }
 /** entity: end */
 /** model: begin */
+export * from '../model/version.ts';
+export * from '../model/versionInit.ts';
 export * from '../model/viewRecord.ts';
-import { type IDecoratorModelOptions } from 'vona-module-a-database';
-declare module 'vona-module-a-database' {
+import type { IModelOptionsVersion } from '../model/version.ts';
+import type { IModelOptionsVersionInit } from '../model/versionInit.ts';
+import type { IModelOptionsViewRecord } from '../model/viewRecord.ts';
+import 'vona';
+declare module 'vona-module-a-orm' {
     interface IModelRecord {
-        'a-version:viewRecord': IDecoratorModelOptions;
+        'a-version:version': IModelOptionsVersion;
+        'a-version:versionInit': IModelOptionsVersionInit;
+        'a-version:viewRecord': IModelOptionsViewRecord;
     }
 }
 declare module 'vona-module-a-version' {
+    interface ModelVersion {
+    }
+    interface ModelVersion {
+        get $beanFullName(): 'a-version.model.version';
+        get $onionName(): 'a-version:version';
+    }
+    interface ModelVersionInit {
+    }
+    interface ModelVersionInit {
+        get $beanFullName(): 'a-version.model.versionInit';
+        get $onionName(): 'a-version:versionInit';
+    }
+    interface ModelViewRecord {
+    }
     interface ModelViewRecord {
+        get $beanFullName(): 'a-version.model.viewRecord';
+        get $onionName(): 'a-version:viewRecord';
     }
 }
 /** model: end */
 /** model: begin */
+import type { ModelVersion } from '../model/version.ts';
+import type { ModelVersionInit } from '../model/versionInit.ts';
 import type { ModelViewRecord } from '../model/viewRecord.ts';
 export interface IModuleModel {
+    'version': ModelVersion;
+    'versionInit': ModelVersionInit;
     'viewRecord': ModelViewRecord;
 }
 /** model: end */
+/** model: begin */
+import type { IModelGetOptions, IModelMethodOptions, IModelSelectParams, TableIdentity, TypeModelRelationResult, TypeModelWhere, IModelInsertOptions, TypeModelMutateRelationData, IModelDeleteOptions, IModelUpdateOptions, IModelMutateOptions, IModelSelectCountParams, IModelSelectAggrParams, TypeModelAggrRelationResult, IModelSelectGroupParams, TypeModelGroupRelationResult } from 'vona-module-a-orm';
+import { SymbolKeyEntity, SymbolKeyEntityMeta, SymbolKeyModelOptions } from 'vona-module-a-orm';
+declare module 'vona-module-a-version' {
+    interface ModelVersion {
+        [SymbolKeyEntity]: EntityVersion;
+        [SymbolKeyEntityMeta]: EntityVersionMeta;
+        [SymbolKeyModelOptions]: IModelOptionsVersion;
+        get<T extends IModelGetOptions<EntityVersion, ModelVersion>>(where: TypeModelWhere<EntityVersion>, options?: T): Promise<TypeModelRelationResult<EntityVersion, ModelVersion, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityVersion, ModelVersion>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityVersion, ModelVersion, T>[]>;
+        select<T extends IModelSelectParams<EntityVersion, ModelVersion, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityVersion, ModelVersion, T>[]>;
+        insert<T extends IModelInsertOptions<EntityVersion, ModelVersion>>(data?: TypeModelMutateRelationData<EntityVersion, ModelVersion, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityVersion, ModelVersion, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityVersion, ModelVersion>>(items: TypeModelMutateRelationData<EntityVersion, ModelVersion, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityVersion, ModelVersion, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityVersion, ModelVersion>>(data: TypeModelMutateRelationData<EntityVersion, ModelVersion, T>, options?: T): Promise<TypeModelMutateRelationData<EntityVersion, ModelVersion, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityVersion, ModelVersion>>(items: TypeModelMutateRelationData<EntityVersion, ModelVersion, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityVersion, ModelVersion, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityVersion, ModelVersion>>(where?: TypeModelWhere<EntityVersion>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityVersion, ModelVersion>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityVersion, ModelVersion>>(data?: TypeModelMutateRelationData<EntityVersion, ModelVersion, T>, options?: T): Promise<TypeModelMutateRelationData<EntityVersion, ModelVersion, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityVersion, ModelVersion>>(items: TypeModelMutateRelationData<EntityVersion, ModelVersion, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityVersion, ModelVersion, T>[]>;
+        count<T extends IModelSelectCountParams<EntityVersion, ModelVersion, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityVersion, ModelVersion, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityVersion, ModelVersion, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityVersion, T>[]>;
+    }
+    interface ModelVersionInit {
+        [SymbolKeyEntity]: EntityVersionInit;
+        [SymbolKeyEntityMeta]: EntityVersionInitMeta;
+        [SymbolKeyModelOptions]: IModelOptionsVersionInit;
+        get<T extends IModelGetOptions<EntityVersionInit, ModelVersionInit>>(where: TypeModelWhere<EntityVersionInit>, options?: T): Promise<TypeModelRelationResult<EntityVersionInit, ModelVersionInit, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityVersionInit, ModelVersionInit>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityVersionInit, ModelVersionInit, T>[]>;
+        select<T extends IModelSelectParams<EntityVersionInit, ModelVersionInit, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityVersionInit, ModelVersionInit, T>[]>;
+        insert<T extends IModelInsertOptions<EntityVersionInit, ModelVersionInit>>(data?: TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityVersionInit, ModelVersionInit>>(items: TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityVersionInit, ModelVersionInit>>(data: TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>, options?: T): Promise<TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityVersionInit, ModelVersionInit>>(items: TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityVersionInit, ModelVersionInit>>(where?: TypeModelWhere<EntityVersionInit>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityVersionInit, ModelVersionInit>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityVersionInit, ModelVersionInit>>(data?: TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>, options?: T): Promise<TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityVersionInit, ModelVersionInit>>(items: TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityVersionInit, ModelVersionInit, T>[]>;
+        count<T extends IModelSelectCountParams<EntityVersionInit, ModelVersionInit, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityVersionInit, ModelVersionInit, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityVersionInit, ModelVersionInit, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityVersionInit, T>[]>;
+    }
+    interface ModelViewRecord {
+        [SymbolKeyEntity]: EntityViewRecord;
+        [SymbolKeyEntityMeta]: EntityViewRecordMeta;
+        [SymbolKeyModelOptions]: IModelOptionsViewRecord;
+        get<T extends IModelGetOptions<EntityViewRecord, ModelViewRecord>>(where: TypeModelWhere<EntityViewRecord>, options?: T): Promise<TypeModelRelationResult<EntityViewRecord, ModelViewRecord, T> | undefined>;
+        mget<T extends IModelGetOptions<EntityViewRecord, ModelViewRecord>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<EntityViewRecord, ModelViewRecord, T>[]>;
+        select<T extends IModelSelectParams<EntityViewRecord, ModelViewRecord, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<EntityViewRecord, ModelViewRecord, T>[]>;
+        insert<T extends IModelInsertOptions<EntityViewRecord, ModelViewRecord>>(data?: TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>, options?: T): Promise<Required<TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>>>;
+        insertBulk<T extends IModelInsertOptions<EntityViewRecord, ModelViewRecord>>(items: TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>>[]>;
+        update<T extends IModelUpdateOptions<EntityViewRecord, ModelViewRecord>>(data: TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>, options?: T): Promise<TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>>;
+        updateBulk<T extends IModelUpdateOptions<EntityViewRecord, ModelViewRecord>>(items: TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>[]>;
+        delete<T extends IModelDeleteOptions<EntityViewRecord, ModelViewRecord>>(where?: TypeModelWhere<EntityViewRecord>, options?: T): Promise<void>;
+        deleteBulk<T extends IModelDeleteOptions<EntityViewRecord, ModelViewRecord>>(ids: TableIdentity[], options?: T): Promise<void>;
+        mutate<T extends IModelMutateOptions<EntityViewRecord, ModelViewRecord>>(data?: TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>, options?: T): Promise<TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>>;
+        mutateBulk<T extends IModelMutateOptions<EntityViewRecord, ModelViewRecord>>(items: TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>[], options?: T): Promise<TypeModelMutateRelationData<EntityViewRecord, ModelViewRecord, T>[]>;
+        count<T extends IModelSelectCountParams<EntityViewRecord, ModelViewRecord, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+        aggregate<T extends IModelSelectAggrParams<EntityViewRecord, ModelViewRecord, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+        group<T extends IModelSelectGroupParams<EntityViewRecord, ModelViewRecord, ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<EntityViewRecord, T>[]>;
+    }
+}
+declare module 'vona-module-a-orm' {
+    interface IModelClassRecord {
+        'a-version:version': ModelVersion;
+        'a-version:versionInit': ModelVersionInit;
+        'a-version:viewRecord': ModelViewRecord;
+    }
+}
+/** model: end */
 /** service: begin */
 export * from '../service/database.ts';
 export * from '../service/version.ts';
@@ -83,7 +183,15 @@ declare module 'vona-module-a-bean' {
 declare module 'vona-module-a-version' {
     interface ServiceDatabase {
     }
+    interface ServiceDatabase {
+        get $beanFullName(): 'a-version.service.database';
+        get $onionName(): 'a-version:database';
+    }
+    interface ServiceVersion {
+    }
     interface ServiceVersion {
+        get $beanFullName(): 'a-version.service.version';
+        get $onionName(): 'a-version:version';
     }
 }
 /** service: end */
@@ -112,6 +220,10 @@ declare module 'vona' {
 declare module 'vona-module-a-version' {
     interface EventVersionDone {
     }
+    interface EventVersionDone {
+        get $beanFullName(): 'a-version.event.versionDone';
+        get $onionName(): 'a-version:versionDone';
+    }
 }
 /** event: end */
 /** event: begin */
@@ -140,6 +252,10 @@ declare module 'vona' {
 declare module 'vona-module-a-version' {
     interface MetaVersion {
     }
+    interface MetaVersion {
+        get $beanFullName(): 'a-version.meta.version';
+        get $onionName(): 'a-version:version';
+    }
 }
 /** meta: end */
 /** startup: begin */
@@ -157,16 +273,32 @@ declare module 'vona-module-a-startup' {
 declare module 'vona-module-a-version' {
     interface StartupDatabaseInit {
     }
+    interface StartupDatabaseInit {
+        get $beanFullName(): 'a-version.startup.databaseInit';
+        get $onionName(): 'a-version:databaseInit';
+    }
     interface StartupDatabaseName {
     }
+    interface StartupDatabaseName {
+        get $beanFullName(): 'a-version.startup.databaseName';
+        get $onionName(): 'a-version:databaseName';
+    }
+    interface StartupInstanceInit {
+    }
     interface StartupInstanceInit {
+        get $beanFullName(): 'a-version.startup.instanceInit';
+        get $onionName(): 'a-version:instanceInit';
     }
 }
 export declare const locales: {
     'en-us': {
+        Module: string;
+        Version: string;
         ModuleOld: string;
     };
     'zh-cn': {
+        Module: string;
+        Version: string;
         ModuleOld: string;
     };
 };

package/dist/config/locale/en-us.d.ts

@@ -1,4 +1,6 @@
 declare const _default: {
+    Module: string;
+    Version: string;
     ModuleOld: string;
 };
 export default _default;

package/dist/config/locale/zh-cn.d.ts

@@ -1,4 +1,6 @@
 declare const _default: {
+    Module: string;
+    Version: string;
     ModuleOld: string;
 };
 export default _default;

package/dist/entity/version.d.ts

@@ -1,5 +1,6 @@
-import type { IDecoratorEntityOptions } from 'vona-module-a-database';
-import { EntityBaseSimple } from 'vona-module-a-database';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { EntityBaseSimple } from 'vona-module-a-orm';
+import '../.metadata/index.ts';
 export interface IEntityOptionsVersion extends IDecoratorEntityOptions {
 }
 declare const EntityVersion_base: import("vona").Constructable<Omit<EntityBaseSimple, "iid" | "deleted">>;

package/dist/entity/versionInit.d.ts

@@ -1,5 +1,5 @@
-import type { IDecoratorEntityOptions } from 'vona-module-a-database';
-import { EntityBaseSimple } from 'vona-module-a-database';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { EntityBaseSimple } from 'vona-module-a-orm';
 export interface IEntityOptionsVersionInit extends IDecoratorEntityOptions {
 }
 declare const EntityVersionInit_base: import("vona").Constructable<Omit<EntityBaseSimple, "iid" | "deleted">>;

package/dist/entity/viewRecord.d.ts

@@ -1,5 +1,5 @@
-import type { IDecoratorEntityOptions } from 'vona-module-a-database';
-import { EntityBaseSimple } from 'vona-module-a-database';
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { EntityBaseSimple } from 'vona-module-a-orm';
 export interface IEntityOptionsViewRecord extends IDecoratorEntityOptions {
 }
 declare const EntityViewRecord_base: import("vona").Constructable<Omit<EntityBaseSimple, "iid">>;

package/dist/index.js

@@ -1,6 +1,6 @@
-import { BeanInfo, ClassMapped, BeanBase, BeanScopeBase } from 'vona';
-import { Entity, EntityBaseSimple, Model, BeanModelBase } from 'vona-module-a-database';
-import { Api } from 'vona-module-a-openapi';
+import { BeanInfo, $Class, BeanBase, BeanScopeBase } from 'vona';
+import { Api, v } from 'vona-module-a-openapi';
+import { Entity, EntityBaseSimple, Model, BeanModelBase } from 'vona-module-a-orm';
 import chalk from 'chalk';
 import moment from 'moment';
 import { Service, Scope } from 'vona-module-a-bean';
@@ -26,10 +26,10 @@ function _initializerDefineProperty(e, i, r, l) {
   });
 }
 
-var _dec$b, _dec2$b, _dec3$2, _dec4$2, _dec5$2, _dec6$2, _class$b, _class2$2, _descriptor$2, _descriptor2$2;
-let EntityVersion = (_dec$b = Entity('aVersion'), _dec2$b = BeanInfo({
+var _dec$d, _dec2$d, _dec3$2, _dec4$2, _dec5$2, _dec6$2, _class$d, _class2$2, _descriptor$2, _descriptor2$2;
+let EntityVersion = (_dec$d = Entity('aVersion'), _dec2$d = BeanInfo({
   module: "a-version"
-}), _dec3$2 = Api.field(), _dec4$2 = Reflect.metadata("design:type", String), _dec5$2 = Api.field(), _dec6$2 = Reflect.metadata("design:type", Number), _dec$b(_class$b = _dec2$b(_class$b = (_class2$2 = class EntityVersion extends ClassMapped.omit(EntityBaseSimple, ['iid', 'deleted']) {
+}), _dec3$2 = Api.field(v.title($locale('Module'))), _dec4$2 = Reflect.metadata("design:type", String), _dec5$2 = Api.field(v.title($locale('Version'))), _dec6$2 = Reflect.metadata("design:type", Number), _dec$d(_class$d = _dec2$d(_class$d = (_class2$2 = class EntityVersion extends $Class.omit(EntityBaseSimple, ['iid', 'deleted']) {
   constructor(...args) {
     super(...args);
     _initializerDefineProperty(this, "module", _descriptor$2, this);
@@ -45,12 +45,12 @@ let EntityVersion = (_dec$b = Entity('aVersion'), _dec2$b = BeanInfo({
   enumerable: true,
   writable: true,
   initializer: null
-}), _class2$2)) || _class$b) || _class$b);
+}), _class2$2)) || _class$d) || _class$d);
 
-var _dec$a, _dec2$a, _dec3$1, _dec4$1, _dec5$1, _dec6$1, _dec7, _dec8, _class$a, _class2$1, _descriptor$1, _descriptor2$1, _descriptor3;
-let EntityVersionInit = (_dec$a = Entity('aVersionInit'), _dec2$a = BeanInfo({
+var _dec$c, _dec2$c, _dec3$1, _dec4$1, _dec5$1, _dec6$1, _dec7, _dec8, _class$c, _class2$1, _descriptor$1, _descriptor2$1, _descriptor3;
+let EntityVersionInit = (_dec$c = Entity('aVersionInit'), _dec2$c = BeanInfo({
   module: "a-version"
-}), _dec3$1 = Api.field(), _dec4$1 = Reflect.metadata("design:type", String), _dec5$1 = Api.field(), _dec6$1 = Reflect.metadata("design:type", String), _dec7 = Api.field(), _dec8 = Reflect.metadata("design:type", Number), _dec$a(_class$a = _dec2$a(_class$a = (_class2$1 = class EntityVersionInit extends ClassMapped.omit(EntityBaseSimple, ['iid', 'deleted']) {
+}), _dec3$1 = Api.field(), _dec4$1 = Reflect.metadata("design:type", String), _dec5$1 = Api.field(), _dec6$1 = Reflect.metadata("design:type", String), _dec7 = Api.field(), _dec8 = Reflect.metadata("design:type", Number), _dec$c(_class$c = _dec2$c(_class$c = (_class2$1 = class EntityVersionInit extends $Class.omit(EntityBaseSimple, ['iid', 'deleted']) {
   constructor(...args) {
     super(...args);
     _initializerDefineProperty(this, "instanceName", _descriptor$1, this);
@@ -72,12 +72,12 @@ let EntityVersionInit = (_dec$a = Entity('aVersionInit'), _dec2$a = BeanInfo({
   enumerable: true,
   writable: true,
   initializer: null
-}), _class2$1)) || _class$a) || _class$a);
+}), _class2$1)) || _class$c) || _class$c);
 
-var _dec$9, _dec2$9, _dec3, _dec4, _dec5, _dec6, _class$9, _class2, _descriptor, _descriptor2;
-let EntityViewRecord = (_dec$9 = Entity('aViewRecord'), _dec2$9 = BeanInfo({
+var _dec$b, _dec2$b, _dec3, _dec4, _dec5, _dec6, _class$b, _class2, _descriptor, _descriptor2;
+let EntityViewRecord = (_dec$b = Entity('aViewRecord'), _dec2$b = BeanInfo({
   module: "a-version"
-}), _dec3 = Api.field(), _dec4 = Reflect.metadata("design:type", String), _dec5 = Api.field(), _dec6 = Reflect.metadata("design:type", String), _dec$9(_class$9 = _dec2$9(_class$9 = (_class2 = class EntityViewRecord extends ClassMapped.omit(EntityBaseSimple, ['iid']) {
+}), _dec3 = Api.field(), _dec4 = Reflect.metadata("design:type", String), _dec5 = Api.field(), _dec6 = Reflect.metadata("design:type", String), _dec$b(_class$b = _dec2$b(_class$b = (_class2 = class EntityViewRecord extends $Class.omit(EntityBaseSimple, ['iid']) {
   constructor(...args) {
     super(...args);
     _initializerDefineProperty(this, "viewName", _descriptor, this);
@@ -93,7 +93,25 @@ let EntityViewRecord = (_dec$9 = Entity('aViewRecord'), _dec2$9 = BeanInfo({
   enumerable: true,
   writable: true,
   initializer: null
-}), _class2)) || _class$9) || _class$9);
+}), _class2)) || _class$b) || _class$b);
+
+var _dec$a, _dec2$a, _class$a;
+let ModelVersion = (_dec$a = Model({
+  entity: EntityVersion,
+  disableInstance: true,
+  disableDeleted: true
+}), _dec2$a = BeanInfo({
+  module: "a-version"
+}), _dec$a(_class$a = _dec2$a(_class$a = class ModelVersion extends BeanModelBase {}) || _class$a) || _class$a);
+
+var _dec$9, _dec2$9, _class$9;
+let ModelVersionInit = (_dec$9 = Model({
+  entity: EntityVersionInit,
+  disableInstance: true,
+  disableDeleted: true
+}), _dec2$9 = BeanInfo({
+  module: "a-version"
+}), _dec$9(_class$9 = _dec2$9(_class$9 = class ModelVersionInit extends BeanModelBase {}) || _class$9) || _class$9);
 
 var _dec$8, _dec2$8, _class$8;
 let ModelViewRecord = (_dec$8 = Model({
@@ -391,7 +409,7 @@ let ServiceVersion = (_dec$6 = Service(), _dec2$6 = BeanInfo({
     });
     // insert record
     if (version > 0) {
-      await this.bean.model.builder('aVersion').insert({
+      await this.scope.model.version.insert({
         module: module.info.relativeName,
         version
       });
@@ -409,13 +427,10 @@ let ServiceVersion = (_dec$6 = Service(), _dec2$6 = BeanInfo({
     }
     // insert record
     if (version > 0) {
-      await this.bean.model.insert('aVersionInit', {
+      await this.scope.model.versionInit.insert({
         instanceName: options.instanceName,
         module: module.info.relativeName,
         version
-      }, {
-        disableInstance: true,
-        disableDeleted: true
       });
     }
   }
@@ -532,10 +547,14 @@ let StartupInstanceInit = (_dec$1 = Startup({
 }) || _class$1) || _class$1);
 
 var locale_en_us = {
+  Module: 'Module',
+  Version: 'Version',
   ModuleOld: 'Module %s is Old'
 };
 
 var locale_zh_cn = {
+  Module: '模块',
+  Version: '版本',
   ModuleOld: '模块 %s 过旧'
 };
 
@@ -557,4 +576,4 @@ function $locale(key) {
 }
 /** scope: end */
 
-export { $locale, EntityVersion, EntityVersionInit, EntityViewRecord, Errors, EventVersionDone, MetaVersion, ModelViewRecord, ScopeModuleAVersion, ServiceDatabase, ServiceVersion, StartupDatabaseInit, StartupDatabaseName, StartupInstanceInit, locales };
+export { $locale, EntityVersion, EntityVersionInit, EntityViewRecord, Errors, EventVersionDone, MetaVersion, ModelVersion, ModelVersionInit, ModelViewRecord, ScopeModuleAVersion, ServiceDatabase, ServiceVersion, StartupDatabaseInit, StartupDatabaseName, StartupInstanceInit, locales };

package/dist/model/version.d.ts

@@ -0,0 +1,7 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase } from 'vona-module-a-orm';
+import { EntityVersion } from '../entity/version.ts';
+export interface IModelOptionsVersion extends IDecoratorModelOptions<EntityVersion> {
+}
+export declare class ModelVersion extends BeanModelBase<EntityVersion> {
+}

package/dist/model/versionInit.d.ts

@@ -0,0 +1,7 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase } from 'vona-module-a-orm';
+import { EntityVersionInit } from '../entity/versionInit.ts';
+export interface IModelOptionsVersionInit extends IDecoratorModelOptions<EntityVersionInit> {
+}
+export declare class ModelVersionInit extends BeanModelBase<EntityVersionInit> {
+}

package/dist/model/viewRecord.d.ts

@@ -1,4 +1,7 @@
-import { BeanModelBase } from 'vona-module-a-database';
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase } from 'vona-module-a-orm';
 import { EntityViewRecord } from '../entity/viewRecord.ts';
+export interface IModelOptionsViewRecord extends IDecoratorModelOptions<EntityViewRecord> {
+}
 export declare class ModelViewRecord extends BeanModelBase<EntityViewRecord> {
 }

package/dist/service/database.d.ts

@@ -1,11 +1,11 @@
-import type { ServiceDatabaseClient } from 'vona-module-a-database';
+import type { ServiceDatabaseClient } from 'vona-module-a-orm';
 import { BeanBase } from 'vona';
 export declare class ServiceDatabase extends BeanBase {
-    get configDatabase(): import("vona-module-a-database").ConfigDatabase;
+    get configDatabase(): import("vona-module-a-orm").ConfigDatabase;
     get databasePrefix(): string;
     databaseInitStartup(): Promise<void>;
     databaseNameStartup(): Promise<void>;
-    __fetchDatabases(client: ServiceDatabaseClient): Promise<import("vona-module-a-database").IFetchDatabasesResultItem[]>;
+    __fetchDatabases(client: ServiceDatabaseClient): Promise<import("vona-module-a-orm").IFetchDatabasesResultItem[]>;
     __createDatabase(client: ServiceDatabaseClient): Promise<string>;
     __database(): Promise<void>;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "vona-module-a-version",
   "type": "module",
-  "version": "5.0.21",
+  "version": "5.0.23",
   "vonaModule": {
     "fileVersion": 1,
     "dependencies": {},