vona-module-a-orm 5.0.37

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016-present Vona
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/cli/databaseDialect/boilerplate/{{sceneName}}.{{beanName}}.ts_

@@ -0,0 +1,4 @@
+import { BeanDatabaseDialectBase, DatabaseDialect } from 'vona-module-a-orm';
+
+@DatabaseDialect()
+export class DatabaseDialect<%=argv.beanNameCapitalize%> extends BeanDatabaseDialectBase {}

package/cli/entity/boilerplate/{{beanName}}.ts_

@@ -0,0 +1,7 @@
+import type { IDecoratorEntityOptions } from 'vona-module-a-orm';
+import { Entity, EntityBase } from 'vona-module-a-orm';
+
+export interface IEntityOptions<%=argv.beanNameCapitalize%> extends IDecoratorEntityOptions {}
+
+@Entity<IEntityOptions<%=argv.beanNameCapitalize%>>('<%=argv.moduleResourceName%>')
+export class Entity<%=argv.beanNameCapitalize%> extends EntityBase {}

package/cli/entity/metadata/generate.ts

@@ -0,0 +1,52 @@
+import type { IMetadataCustomGenerateOptions } from '@cabloy/cli';
+import { toUpperCaseFirstChar } from '@cabloy/word-utils';
+
+export default async function (options: IMetadataCustomGenerateOptions): Promise<string> {
+  const { sceneName, moduleName, globFiles } = options;
+  const contentColumns: string[] = [];
+  const contentEntityMetas: string[] = [];
+  const contentRecords: string[] = [];
+  const contentFields: string[] = [];
+  for (const globFile of globFiles) {
+    const { className, beanName, fileContent } = globFile;
+    const opionsName = `IEntityOptions${toUpperCaseFirstChar(beanName)}`;
+    const tableName = __parseTableName(fileContent);
+    contentColumns.push(`export type ${className}TableName = '${tableName}';`);
+    contentEntityMetas.push(`export type ${className}Meta=TypeEntityMeta<${className},${className}TableName>;`);
+    const contentRecordItem = `'${tableName}': never;`;
+    if (!contentRecords.includes(contentRecordItem)) {
+      contentRecords.push(contentRecordItem);
+    }
+    contentFields.push(`
+    export interface ${opionsName} {
+      fields?: TypeEntityOptionsFields<${className}, ${opionsName}[TypeSymbolKeyFieldsMore]>;
+    }`);
+  }
+  if (contentColumns.length === 0 && contentEntityMetas.length === 0 && contentRecords.length === 0 && contentFields.length === 0) return '';
+  // combine
+  const content = `/** ${sceneName}: begin */
+${contentColumns.join('\n')}
+${contentEntityMetas.join('\n')}
+declare module 'vona-module-a-orm' {
+  export interface ITableRecord {
+    ${contentRecords.join('\n')}
+  }
+}
+declare module 'vona-module-${moduleName}' {
+  ${contentFields.join('\n')}
+}
+/** ${sceneName}: end */
+`;
+  return content;
+}
+
+function __parseTableName(fileContent: string): string | false {
+  let matched = fileContent.match(/@Entity<.*?>\(\{[\s\S]*?table: ('[^']*')[\s\S]*?\}[\s\S]*?\)\s*export class/);
+  if (!matched) {
+    matched = fileContent.match(/@Entity<.*?>\(([^)]*)\)/);
+  }
+  if (!matched) return false;
+  const tableName = matched[1];
+  if (tableName === '') return '';
+  return tableName.split(',')[0].replaceAll("'", '');
+}

package/cli/model/boilerplate/{{beanName}}.ts_

@@ -0,0 +1,8 @@
+import type { IDecoratorModelOptions } from 'vona-module-a-orm';
+import { BeanModelBase, Model } from 'vona-module-a-orm';
+import { Entity<%=argv.beanNameCapitalize%> } from '../entity/<%=argv.beanName%>.ts';
+
+export interface IModelOptions<%=argv.beanNameCapitalize%> extends IDecoratorModelOptions<Entity<%=argv.beanNameCapitalize%>> {}
+
+@Model<IModelOptions<%=argv.beanNameCapitalize%>>({ entity: Entity<%=argv.beanNameCapitalize%> })
+export class Model<%=argv.beanNameCapitalize%> extends BeanModelBase<Entity<%=argv.beanNameCapitalize%>> {}

package/cli/model/metadata/generate.ts

@@ -0,0 +1,285 @@
+import type { IMetadataCustomGenerateOptions } from '@cabloy/cli';
+import { types as t } from '@babel/core';
+
+export default async function (options: IMetadataCustomGenerateOptions): Promise<string> {
+  const { sceneName, moduleName, globFiles, cli } = options;
+  const contentRelations: string[] = [];
+  const contentRecords: string[] = [];
+  const contentModels: string[] = [];
+  // const contentModelsOptions: string[] = [];
+  for (const globFile of globFiles) {
+    const { className, beanName, fileContent, beanNameCapitalize } = globFile;
+    const ast = cli.helper.gogocode(fileContent);
+    const astNodes = ast.find(`@Model<$$$0>({$$$1})export class ${className} extends $$$2 {}`).match.$$$1;
+    const entityName = __parseEntityName(__getAstNode(astNodes as any, 'entity'));
+    const relations = __parseRelations(__getAstNode(astNodes as any, 'relations'));
+    const entityMetaName = `${entityName}Meta`;
+    const opionsName = `IModelOptions${beanNameCapitalize}`;
+    if (relations && relations.length > 0) {
+      contentRelations.push(`export interface ${opionsName} {
+        relations: {
+          ${relations.join('\n')}
+        };
+      }`);
+    }
+    contentRecords.push(`export interface ${className} {
+      [SymbolKeyEntity]: ${entityName};
+      [SymbolKeyEntityMeta]: ${entityMetaName};
+      [SymbolKeyModelOptions]: ${opionsName};
+      get<T extends IModelGetOptions<${entityName},${className}>>(where: TypeModelWhere<${entityName}>, options?: T): Promise<TypeModelRelationResult<${entityName}, ${className}, T> | undefined>;
+      mget<T extends IModelGetOptions<${entityName},${className}>>(ids: TableIdentity[], options?: T): Promise<TypeModelRelationResult<${entityName}, ${className}, T>[]>;
+      select<T extends IModelSelectParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelRelationResult<${entityName}, ${className}, T>[]>;
+      insert<T extends IModelInsertOptions<${entityName},${className}>>(data?: TypeModelMutateRelationData<${entityName},${className}, T>, options?: T): Promise<Required<TypeModelMutateRelationData<${entityName},${className}, T>>>;
+      insertBulk<T extends IModelInsertOptions<${entityName},${className}>>(items: TypeModelMutateRelationData<${entityName},${className}, T>[], options?: T): Promise<Required<TypeModelMutateRelationData<${entityName},${className}, T>>[]>;
+      update<T extends IModelUpdateOptions<${entityName},${className}>>(data: TypeModelMutateRelationData<${entityName},${className}, T>, options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>>;
+      updateBulk<T extends IModelUpdateOptions<${entityName},${className}>>(items: TypeModelMutateRelationData<${entityName},${className}, T>[], options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>[]>;
+      delete<T extends IModelDeleteOptions<${entityName},${className}>>(where?: TypeModelWhere<${entityName}>, options?: T): Promise<void>;
+      deleteBulk<T extends IModelDeleteOptions<${entityName},${className}>>(ids: TableIdentity[], options?: T): Promise<void>;
+      mutate<T extends IModelMutateOptions<${entityName},${className}>>(data?: TypeModelMutateRelationData<${entityName},${className}, T>, options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>>;
+      mutateBulk<T extends IModelMutateOptions<${entityName},${className}>>(items: TypeModelMutateRelationData<${entityName},${className}, T>[], options?: T): Promise<TypeModelMutateRelationData<${entityName},${className}, T>[]>;
+      count<T extends IModelSelectCountParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<BigNumber | undefined>;
+      aggregate<T extends IModelSelectAggrParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelAggrRelationResult<T>>;
+      group<T extends IModelSelectGroupParams<${entityName},${className},ModelJoins>, ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined>(params?: T, options?: IModelMethodOptions, modelJoins?: ModelJoins): Promise<TypeModelGroupRelationResult<${entityName}, T>[]>;
+    }`);
+    contentModels.push(`'${moduleName}:${beanName}': ${className};`);
+    // only override cache.keyAux which not enough
+    // contentModelsOptions.push(`export interface ${opionsName} {
+    //   cache?: {
+    //     keyAux?: keyof ${entityName};
+    //   };
+    // }`);
+  }
+  if (contentRelations.length === 0 && contentRecords.length === 0 && contentModels.length === 0) return '';
+  // combine
+  const content = `/** ${sceneName}: 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-${moduleName}' {
+  ${contentRelations.join('\n')}
+  ${contentRecords.join('\n')}
+}
+declare module 'vona-module-a-orm' {
+  export interface IModelClassRecord {
+    ${contentModels.join('\n')}
+  }
+}
+/** ${sceneName}: end */
+`;
+  return content;
+}
+
+function __getAstNode(astNodes: Array<t.ObjectProperty>, name: string) {
+  return astNodes.find(node => (node.key as t.Identifier).name === name) as t.ObjectProperty;
+}
+
+function __parseEntityName(node: t.ObjectProperty): string {
+  return (node.value as t.Identifier).name;
+  // const matched = fileContent.match(/@Model<.*?>\(\{[\s\S]*?entity: (Entity\S+)[\s\S]*?\}[\s\S]*?\)\s*export class/);
+  // if (!matched) return false;
+  // const entityName = matched[1];
+  // if (entityName === '') return '';
+  // return entityName.split(',')[0];
+}
+
+function __parseRelations(node?: t.ObjectProperty) {
+  if (!node) return;
+  const relations: string[] = [];
+  const nodeRelations = node.value as t.ObjectExpression;
+  for (const nodeRelation of nodeRelations.properties) {
+    relations.push(__parseRelation(nodeRelation as t.ObjectProperty));
+  }
+  return relations;
+}
+
+function __parseRelation(nodeRelation: t.ObjectProperty) {
+  const relationName = (nodeRelation.key as t.Identifier).name;
+  const callExpression = nodeRelation.value as t.CallExpression;
+  const relationType = ((callExpression.callee as t.MemberExpression).property as t.Identifier).name;
+  const args: t.Node[] = callExpression.arguments;
+  // relation
+  if (relationType === 'hasOne') {
+    return `${relationName}: ${__parseRelationHasOne(args)};`;
+  } else if (relationType === 'belongsTo') {
+    return `${relationName}: ${__parseRelationBelongsTo(args)};`;
+  } else if (relationType === 'hasMany') {
+    return `${relationName}: ${__parseRelationHasMany(args)};`;
+  } else if (relationType === 'belongsToMany') {
+    return `${relationName}: ${__parseRelationBelongsToMany(args)};`;
+  }
+  return '';
+}
+
+function __parseRelationHasOne(args: t.Node[]) {
+  // classModel
+  const classModel = __parseRelation_classModel(args[0]);
+  // options
+  const options = __parseRelation_options(args[2]);
+  // combine
+  return `IModelRelationHasOne<${classModel}, ${options.autoload}, ${options.columns}>`;
+}
+
+function __parseRelationBelongsTo(args: t.Node[]) {
+  // classModelSelf
+  const classModelSelf = __parseRelation_classModel(args[0]);
+  // classModel
+  const classModel = __parseRelation_classModel(args[1]);
+  // options
+  const options = __parseRelation_options(args[3]);
+  // combine
+  return `IModelRelationBelongsTo<${classModelSelf}, ${classModel}, ${options.autoload}, ${options.columns}>`;
+}
+
+function __parseRelationHasMany(args: t.Node[]) {
+  // classModel
+  const classModel = __parseRelation_classModel(args[0]);
+  // // key
+  // const key = __parseRelation_key(args[1]);
+  // options
+  const options = __parseRelation_options(args[2]);
+  // modelJoins
+  const modelJoins = __parseRelation_modelJoins(args[3]);
+  // combine
+  return `IModelRelationHasMany<${classModel}, ${options.autoload}, ${options.columns},${modelJoins},${options.aggrs},${options.groups}>`;
+}
+
+function __parseRelationBelongsToMany(args: t.Node[]) {
+  // classModelMiddle
+  const classModelMiddle = __parseRelation_classModel(args[0]);
+  // classModel
+  const classModel = __parseRelation_classModel(args[1]);
+  // options
+  const options = __parseRelation_options(args[4]);
+  // modelJoins
+  const modelJoins = __parseRelation_modelJoins(args[5]);
+  // combine
+  return `IModelRelationBelongsToMany<${classModelMiddle}, ${classModel}, ${options.autoload}, ${options.columns},${modelJoins},${options.aggrs},${options.groups}>`;
+}
+
+function __parseRelation_classModel(node: t.Node) {
+  if (t.isArrowFunctionExpression(node)) {
+    return (node.body as t.Identifier).name;
+  } else if (t.isIdentifier(node)) {
+    return node.name;
+  } else if (t.isStringLiteral(node)) {
+    return `'${node.value}'`;
+  }
+  throw new Error('invalid classModel');
+}
+
+function __parseRelation_key(node: t.Node) {
+  if (t.isStringLiteral(node)) {
+    return node.value;
+  }
+  throw new Error('invalid key');
+}
+
+function __parseRelation_modelJoins(node?: t.Node) {
+  if (!node) return 'undefined';
+  if (t.isIdentifier(node) && node.name === 'undefined') return 'undefined';
+  let modelJoins;
+  if (t.isArrayExpression(node)) {
+    modelJoins = node.elements.map(item => __parseRelation_classModel(item!));
+  } else {
+    modelJoins = [__parseRelation_classModel(node)];
+  }
+  return `[${modelJoins.join(',')}]`;
+  // const content = `${modelJoins.join('|')}`;
+  // return `${content} | Array<${content}>`;
+}
+
+function __parseRelation_aggrs(node?: t.Node) {
+  if (!node) return 'undefined';
+  if (t.isIdentifier(node) && node.name === 'undefined') return 'undefined';
+  const aggrs = __parseRelation_aggrs_inner(node as t.ObjectExpression);
+  return `{ ${aggrs.join(';')} }`;
+}
+
+function __parseRelation_aggrs_inner(node: t.ObjectExpression) {
+  const aggrs: string[] = [];
+  for (const _nodeProperty of node.properties) {
+    const nodeProperty = _nodeProperty as t.ObjectProperty;
+    const key = (nodeProperty.key as t.Identifier).name;
+    const value = __parseColumns(nodeProperty);
+    if (value) {
+      aggrs.push(`${key}?: ${__joinColumnsType(value, true)}`);
+    }
+  }
+  return aggrs;
+}
+
+function __parseRelation_options(node: t.Node) {
+  const options = __parseRelation_options_inner(node);
+  let autoload;
+  let columns;
+  let groups;
+  let aggrs;
+  // autoload
+  if (options?.autoload) {
+    autoload = 'true';
+  } else {
+    autoload = 'false';
+  }
+  // groups
+  if (!options?.groups) {
+    groups = 'undefined';
+  } else {
+    groups = __joinColumnsType(options?.groups, true);
+  }
+  // aggrs
+  if (!options?.aggrs) {
+    aggrs = 'undefined';
+  } else {
+    aggrs = options?.aggrs;
+  }
+  // columns
+  if (!options?.columns) {
+    if (options?.groups) {
+      columns = 'undefined';
+    } else {
+      columns = '\'*\'';
+    }
+  } else {
+    if (options?.columns.includes('*')) {
+      columns = '\'*\'';
+    } else {
+      columns = __joinColumnsType(options?.columns, false);
+    }
+  }
+  return { autoload, columns, groups, aggrs };
+}
+
+function __parseRelation_options_inner(node: t.Node) {
+  if (!node) return undefined;
+  if (!t.isObjectExpression(node)) throw new Error('invalid options');
+  let autoload;
+  let columns: string[] | undefined;
+  let groups;
+  let aggrs;
+  for (const _nodeProperty of node.properties) {
+    const nodeProperty = _nodeProperty as t.ObjectProperty;
+    const key = (nodeProperty.key as t.Identifier).name;
+    if (key === 'autoload') {
+      autoload = (nodeProperty.value as t.BooleanLiteral).value;
+    } else if (key === 'columns') {
+      columns = __parseColumns(nodeProperty);
+    } else if (key === 'groups') {
+      groups = __parseColumns(nodeProperty);
+    } else if (key === 'aggrs') {
+      aggrs = __parseRelation_aggrs(nodeProperty.value);
+    }
+  }
+  return { autoload, columns, groups, aggrs };
+}
+
+function __parseColumns(node: t.ObjectProperty) {
+  if (t.isArrayExpression(node.value)) {
+    return node.value.elements.map(item => (item as t.StringLiteral).value);
+  } else if (t.isStringLiteral(node.value)) {
+    return [node.value.value];
+  }
+}
+
+function __joinColumnsType(columns: string[], withArray: boolean) {
+  const temp = columns.map(item => `'${item}'`).join('|');
+  return withArray ? `${temp} | Array<${temp}>` : temp;
+}

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

@@ -0,0 +1,246 @@
+/** aopMethod: begin */
+export * from '../bean/aopMethod.transaction.ts';
+import type { IAopMethodOptionsTransaction } from '../bean/aopMethod.transaction.ts';
+import 'vona';
+declare module 'vona-module-a-aspect' {
+    interface IAopMethodRecord {
+        'a-orm:transaction': IAopMethodOptionsTransaction;
+    }
+}
+declare module 'vona-module-a-orm' {
+    interface AopMethodTransaction {
+    }
+    interface AopMethodTransaction {
+        get $beanFullName(): 'a-orm.aopMethod.transaction';
+        get $onionName(): 'a-orm:transaction';
+    }
+}
+/** aopMethod: end */
+/** bean: begin */
+export * from '../bean/bean.database.ts';
+export * from '../bean/bean.databaseDialectBase.ts';
+export * from '../bean/bean.model.ts';
+export * from '../bean/bean.modelBase.ts';
+import 'vona';
+declare module 'vona' {
+}
+declare module 'vona-module-a-orm' {
+    interface BeanDatabase {
+    }
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanDatabase } from '../bean/bean.database.ts';
+import 'vona';
+declare module 'vona' {
+    interface IBeanRecordGlobal {
+        'database': BeanDatabase;
+    }
+}
+/** bean: end */
+/** service: begin */
+export * from '../service/cacheEntity_.ts';
+export * from '../service/cacheQuery_.ts';
+export * from '../service/columnsCache_.ts';
+export * from '../service/columns_.ts';
+export * from '../service/database.ts';
+export * from '../service/databaseAsyncLocalStorage_.ts';
+export * from '../service/databaseClient_.ts';
+export * from '../service/db_.ts';
+export * from '../service/entityResolver_.ts';
+export * from '../service/modelResolver_.ts';
+export * from '../service/relations_.ts';
+export * from '../service/transactionAsyncLocalStorage_.ts';
+export * from '../service/transactionConsistency‌_.ts';
+export * from '../service/transactionFiber_.ts';
+export * from '../service/transactionState_.ts';
+export * from '../service/transaction_.ts';
+import 'vona';
+declare module 'vona-module-a-bean' {
+    interface IServiceRecord {
+        'a-orm:database': never;
+    }
+}
+declare module 'vona-module-a-orm' {
+    interface ServiceDatabase {
+    }
+    interface ServiceDatabase {
+        get $beanFullName(): 'a-orm.service.database';
+        get $onionName(): 'a-orm:database';
+    }
+}
+/** service: end */
+/** service: begin */
+import type { ServiceDatabase } from '../service/database.ts';
+export interface IModuleService {
+    'database': ServiceDatabase;
+}
+/** service: end */
+/** service: begin */
+import 'vona';
+declare module 'vona' {
+    interface IBeanRecordGeneral {
+        'a-orm.service.database': ServiceDatabase;
+    }
+}
+/** service: end */
+/** broadcast: begin */
+export * from '../bean/broadcast.columnsClear.ts';
+export * from '../bean/broadcast.databaseClientReload.ts';
+import { type IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
+declare module 'vona-module-a-broadcast' {
+    interface IBroadcastRecord {
+        'a-orm:columnsClear': IDecoratorBroadcastOptions;
+        'a-orm:databaseClientReload': IDecoratorBroadcastOptions;
+    }
+}
+declare module 'vona-module-a-orm' {
+    interface BroadcastColumnsClear {
+    }
+    interface BroadcastColumnsClear {
+        get $beanFullName(): 'a-orm.broadcast.columnsClear';
+        get $onionName(): 'a-orm:columnsClear';
+    }
+    interface BroadcastDatabaseClientReload {
+    }
+    interface BroadcastDatabaseClientReload {
+        get $beanFullName(): 'a-orm.broadcast.databaseClientReload';
+        get $onionName(): 'a-orm:databaseClientReload';
+    }
+}
+/** broadcast: end */
+/** broadcast: begin */
+import type { BroadcastColumnsClear } from '../bean/broadcast.columnsClear.ts';
+import type { BroadcastDatabaseClientReload } from '../bean/broadcast.databaseClientReload.ts';
+export interface IModuleBroadcast {
+    'columnsClear': BroadcastColumnsClear;
+    'databaseClientReload': BroadcastDatabaseClientReload;
+}
+/** broadcast: end */
+/** event: begin */
+export * from '../bean/event.clientNameReal.ts';
+export * from '../bean/event.columnsClear.ts';
+export * from '../bean/event.databaseClientReload.ts';
+import 'vona';
+declare module 'vona' {
+}
+declare module 'vona-module-a-orm' {
+    interface EventClientNameReal {
+    }
+    interface EventClientNameReal {
+        get $beanFullName(): 'a-orm.event.clientNameReal';
+        get $onionName(): 'a-orm:clientNameReal';
+    }
+    interface EventColumnsClear {
+    }
+    interface EventColumnsClear {
+        get $beanFullName(): 'a-orm.event.columnsClear';
+        get $onionName(): 'a-orm:columnsClear';
+    }
+    interface EventDatabaseClientReload {
+    }
+    interface EventDatabaseClientReload {
+        get $beanFullName(): 'a-orm.event.databaseClientReload';
+        get $onionName(): 'a-orm:databaseClientReload';
+    }
+}
+/** event: end */
+/** event: begin */
+import type { EventClientNameReal } from '../bean/event.clientNameReal.ts';
+import type { EventColumnsClear } from '../bean/event.columnsClear.ts';
+import type { EventDatabaseClientReload } from '../bean/event.databaseClientReload.ts';
+export interface IModuleEvent {
+    'clientNameReal': EventClientNameReal;
+    'columnsClear': EventColumnsClear;
+    'databaseClientReload': EventDatabaseClientReload;
+}
+/** event: end */
+/** event: begin */
+import type { TypeEventClientNameRealData, TypeEventClientNameRealResult } from '../bean/event.clientNameReal.ts';
+import type { TypeEventColumnsClearData, TypeEventColumnsClearResult } from '../bean/event.columnsClear.ts';
+import type { TypeEventDatabaseClientReloadData, TypeEventDatabaseClientReloadResult } from '../bean/event.databaseClientReload.ts';
+import type { EventOn } from 'vona-module-a-event';
+declare module 'vona-module-a-event' {
+    interface IEventRecord {
+        'a-orm:clientNameReal': EventOn<TypeEventClientNameRealData, TypeEventClientNameRealResult>;
+        'a-orm:columnsClear': EventOn<TypeEventColumnsClearData, TypeEventColumnsClearResult>;
+        'a-orm:databaseClientReload': EventOn<TypeEventDatabaseClientReloadData, TypeEventDatabaseClientReloadResult>;
+    }
+}
+/** event: end */
+/** schedule: begin */
+export * from '../bean/schedule.softDeletionPrune.ts';
+import { type IDecoratorScheduleOptions } from 'vona-module-a-schedule';
+declare module 'vona-module-a-schedule' {
+    interface IScheduleRecord {
+        'a-orm:softDeletionPrune': IDecoratorScheduleOptions;
+    }
+}
+declare module 'vona-module-a-orm' {
+    interface ScheduleSoftDeletionPrune {
+    }
+    interface ScheduleSoftDeletionPrune {
+        get $beanFullName(): 'a-orm.schedule.softDeletionPrune';
+        get $onionName(): 'a-orm:softDeletionPrune';
+    }
+}
+/** schedule: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+export declare const locales: {
+    'en-us': {
+        TableIdentity: string;
+        CreatedAt: string;
+        UpdatedAt: string;
+        Deleted: string;
+        InstanceId: string;
+        ShouldSpecifyTable: string;
+    };
+    'zh-cn': {
+        TableIdentity: string;
+        CreatedAt: string;
+        UpdatedAt: string;
+        Deleted: string;
+        InstanceId: string;
+        ShouldSpecifyTable: string;
+    };
+};
+/** locale: end */
+/** error: begin */
+export * from '../config/errors.ts';
+import type { Errors } from '../config/errors.ts';
+/** error: end */
+/** main: begin */
+export * from '../main.ts';
+/** main: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, type TypeModuleConfig, type TypeModuleErrors, type TypeModuleLocales, type TypeLocaleBase } from 'vona';
+export declare class ScopeModuleAOrm extends BeanScopeBase {
+}
+export interface ScopeModuleAOrm {
+    util: BeanScopeUtil;
+    config: TypeModuleConfig<typeof config>;
+    error: TypeModuleErrors<typeof Errors>;
+    locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+    service: IModuleService;
+    broadcast: IModuleBroadcast;
+    event: IModuleEvent;
+}
+import 'vona';
+declare module 'vona' {
+    interface IBeanScopeRecord {
+        'a-orm': ScopeModuleAOrm;
+    }
+    interface IBeanScopeContainer {
+        orm: ScopeModuleAOrm;
+    }
+    interface IBeanScopeConfig {
+        'a-orm': ReturnType<typeof config>;
+    }
+    interface IBeanScopeLocale {
+        'a-orm': (typeof locales)[TypeLocaleBase];
+    }
+}
+export declare function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `a-orm::${K}`;
+/** scope: end */

package/dist/.metadata/this.d.ts

@@ -0,0 +1,2 @@
+export declare const __ThisModule__ = "a-orm";
+export { ScopeModuleAOrm as ScopeModule } from './index.ts';

package/dist/bean/aopMethod.transaction.d.ts

@@ -0,0 +1,9 @@
+import type { Next, NextSync } from 'vona';
+import type { IAopMethodExecute, IDecoratorAopMethodOptions } from 'vona-module-a-aspect';
+import type { ITransactionOptions } from '../types/transaction.ts';
+import { BeanAopMethodBase } from 'vona';
+export interface IAopMethodOptionsTransaction extends IDecoratorAopMethodOptions, ITransactionOptions {
+}
+export declare class AopMethodTransaction extends BeanAopMethodBase implements IAopMethodExecute {
+    execute(options: IAopMethodOptionsTransaction, _args: [], next: Next | NextSync, _receiver: any, _prop: string): Promise<any> | any;
+}

package/dist/bean/bean.database.d.ts

@@ -0,0 +1,12 @@
+import type { FunctionAsync } from 'vona';
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IDatabaseClientRecord, IDbInfo } from '../types/database.ts';
+import { BeanBase } from 'vona';
+import { ServiceDatabaseClient } from '../service/databaseClient_.ts';
+export declare class BeanDatabase extends BeanBase {
+    get current(): import("vona-module-a-orm").ServiceDb;
+    getClient(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient): ServiceDatabaseClient;
+    getDb(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient): import("vona-module-a-orm").ServiceDb;
+    switchDbIsolate<RESULT>(fn: FunctionAsync<RESULT>, dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): Promise<RESULT>;
+    switchDb<RESULT>(fn: FunctionAsync<RESULT>, dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): Promise<RESULT>;
+}