vona-module-a-orm 5.0.96 → 5.1.2

package/src/.metadata/index.ts

@@ -0,0 +1,348 @@
+// eslint-disable
+/** aopMethod: begin */
+export * from '../bean/aopMethod.transaction.ts';
+import type { IAopMethodOptionsTransaction } from '../bean/aopMethod.transaction.ts';
+import 'vona-module-a-aspect';
+declare module 'vona-module-a-aspect' {
+  
+    export interface IAopMethodRecord {
+      'a-orm:transaction': IAopMethodOptionsTransaction;
+    }
+
+  
+}
+declare module 'vona-module-a-orm' {
+  
+        export interface AopMethodTransaction {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface AopMethodTransaction {
+            get $beanFullName(): 'a-orm.aopMethod.transaction';
+            get $onionName(): 'a-orm:transaction';
+            get $onionOptions(): IAopMethodOptionsTransaction;
+          } 
+}
+/** 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' {
+  
+        export interface BeanDatabase {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        } 
+}
+/** bean: end */
+/** bean: begin */
+import type { BeanDatabase } from '../bean/bean.database.ts';
+import 'vona';  
+declare module 'vona' {
+  export 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-module-a-bean';
+declare module 'vona-module-a-bean' {
+  
+    export interface IServiceRecord {
+      'a-orm:database': never;
+    }
+
+  
+}
+declare module 'vona-module-a-orm' {
+  
+        export interface ServiceDatabase {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export 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' {
+  export interface IBeanRecordGeneral {
+    'a-orm.service.database': ServiceDatabase;
+  }
+}
+/** service: end */
+/** broadcast: begin */
+export * from '../bean/broadcast.columnsClear.ts';
+
+import { type IDecoratorBroadcastOptions } from 'vona-module-a-broadcast';
+declare module 'vona-module-a-broadcast' {
+  
+    export interface IBroadcastRecord {
+      'a-orm:columnsClear': IDecoratorBroadcastOptions;
+    }
+
+  
+}
+declare module 'vona-module-a-orm' {
+  
+        export interface BroadcastColumnsClear {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface BroadcastColumnsClear {
+            get $beanFullName(): 'a-orm.broadcast.columnsClear';
+            get $onionName(): 'a-orm:columnsClear';
+            get $onionOptions(): IDecoratorBroadcastOptions;
+          } 
+}
+/** broadcast: end */
+/** broadcast: begin */
+import type { BroadcastColumnsClear } from '../bean/broadcast.columnsClear.ts';
+export interface IModuleBroadcast {
+  'columnsClear': BroadcastColumnsClear;
+}
+/** broadcast: end */
+/** event: begin */
+export * from '../bean/event.clientNameReal.ts';
+export * from '../bean/event.columnsClear.ts';
+
+import 'vona';
+declare module 'vona' {
+  
+  
+}
+declare module 'vona-module-a-orm' {
+  
+        export interface EventClientNameReal {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface EventClientNameReal {
+            get $beanFullName(): 'a-orm.event.clientNameReal';
+            get $onionName(): 'a-orm:clientNameReal';
+            
+          }
+
+        export interface EventColumnsClear {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface EventColumnsClear {
+            get $beanFullName(): 'a-orm.event.columnsClear';
+            get $onionName(): 'a-orm:columnsClear';
+            
+          } 
+}
+/** event: end */
+/** event: begin */
+import type { EventClientNameReal } from '../bean/event.clientNameReal.ts';
+import type { EventColumnsClear } from '../bean/event.columnsClear.ts';
+export interface IModuleEvent {
+  'clientNameReal': EventClientNameReal;
+'columnsClear': EventColumnsClear;
+}
+/** event: end */
+/** event: begin */
+import type { TypeEventClientNameRealData, TypeEventClientNameRealResult } from '../bean/event.clientNameReal.ts';
+import type { TypeEventColumnsClearData, TypeEventColumnsClearResult } from '../bean/event.columnsClear.ts';
+import type { EventOn } from 'vona-module-a-event'; 
+declare module 'vona-module-a-event' {
+  export interface IEventRecord {
+    'a-orm:clientNameReal': EventOn<TypeEventClientNameRealData, TypeEventClientNameRealResult>;
+'a-orm:columnsClear': EventOn<TypeEventColumnsClearData, TypeEventColumnsClearResult>;
+  }
+}
+/** event: end */
+/** queue: begin */
+export * from '../bean/queue.doubleDelete.ts';
+
+import { type IDecoratorQueueOptions } from 'vona-module-a-queue';
+declare module 'vona-module-a-queue' {
+  
+    export interface IQueueRecord {
+      'a-orm:doubleDelete': IDecoratorQueueOptions;
+    }
+
+  
+}
+declare module 'vona-module-a-orm' {
+  
+        export interface QueueDoubleDelete {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface QueueDoubleDelete {
+            get $beanFullName(): 'a-orm.queue.doubleDelete';
+            get $onionName(): 'a-orm:doubleDelete';
+            get $onionOptions(): IDecoratorQueueOptions;
+          } 
+}
+/** queue: end */
+/** queue: begin */
+import type { QueueDoubleDelete } from '../bean/queue.doubleDelete.ts';
+export interface IModuleQueue {
+  'doubleDelete': QueueDoubleDelete;
+}
+/** queue: end */
+/** schedule: begin */
+export * from '../bean/schedule.softDeletionPrune.ts';
+
+import { type IDecoratorScheduleOptions } from 'vona-module-a-schedule';
+declare module 'vona-module-a-schedule' {
+  
+    export interface IScheduleRecord {
+      'a-orm:softDeletionPrune': IDecoratorScheduleOptions;
+    }
+
+  
+}
+declare module 'vona-module-a-orm' {
+  
+        export interface ScheduleSoftDeletionPrune {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface ScheduleSoftDeletionPrune {
+            get $beanFullName(): 'a-orm.schedule.softDeletionPrune';
+            get $onionName(): 'a-orm:softDeletionPrune';
+            get $onionOptions(): IDecoratorScheduleOptions;
+          } 
+}
+/** schedule: end */
+/** hmr: begin */
+export * from '../bean/hmr.entity.ts';
+export * from '../bean/hmr.model.ts';
+
+import 'vona';
+declare module 'vona' {
+  
+    export interface IHmrRecord {
+      'a-orm:entity': never;
+'a-orm:model': never;
+    }
+
+  
+}
+declare module 'vona-module-a-orm' {
+  
+        export interface HmrEntity {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface HmrEntity {
+            get $beanFullName(): 'a-orm.hmr.entity';
+            get $onionName(): 'a-orm:entity';
+            
+          }
+
+        export interface HmrModel {
+          /** @internal */
+          get scope(): ScopeModuleAOrm;
+        }
+
+          export interface HmrModel {
+            get $beanFullName(): 'a-orm.hmr.model';
+            get $onionName(): 'a-orm:model';
+            
+          } 
+}
+/** hmr: end */
+/** config: begin */
+export * from '../config/config.ts';
+import type { config } from '../config/config.ts';
+/** config: end */
+/** locale: begin */
+import { locales } from './locales.ts';
+/** 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';
+import { Scope } from 'vona-module-a-bean';
+
+@Scope()
+export 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;
+queue: IModuleQueue;
+}
+
+import 'vona';
+declare module 'vona' {
+  export interface IBeanScopeRecord {
+    'a-orm': ScopeModuleAOrm;
+  }
+
+  export interface IBeanScopeContainer {
+    orm: ScopeModuleAOrm;
+  }
+  
+  export interface IBeanScopeConfig {
+    'a-orm': ReturnType<typeof config>;
+  }
+
+  export interface IBeanScopeLocale {
+    'a-orm': (typeof locales)[TypeLocaleBase];
+  }
+
+  export interface IBeanScopeErrors {
+    'a-orm': typeof errors;
+  }
+}
+/** scope: end */

package/src/.metadata/locales.ts

@@ -0,0 +1,13 @@
+import type { TypeLocaleBase } from 'vona';
+import { $makeLocaleMagic } from 'vona';
+import locale_en_us from '../config/locale/en-us.ts';
+import locale_zh_cn from '../config/locale/zh-cn.ts';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};
+
+export function $locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K, ...args: any[]): any {
+  return $makeLocaleMagic(`a-orm::${key}`, ...args);
+}

package/src/.metadata/this.ts

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

package/src/bean/aopMethod.transaction.ts

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

package/src/bean/bean.database.ts

@@ -0,0 +1,57 @@
+import type { FunctionAsync } from 'vona';
+
+import { BeanBase, beanFullNameFromOnionName } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IDatabaseClientDialectRecord, IDatabaseClientRecord, IDbInfo } from '../types/database.ts';
+import type { BeanDatabaseDialectBase } from './bean.databaseDialectBase.ts';
+
+import { ServiceDatabaseAsyncLocalStorage } from '../service/databaseAsyncLocalStorage_.ts';
+import { ServiceDatabaseClient } from '../service/databaseClient_.ts';
+import { ServiceTransactionAsyncLocalStorage } from '../service/transactionAsyncLocalStorage_.ts';
+
+@Bean()
+export class BeanDatabase extends BeanBase {
+  get current() {
+    return this.bean._getBean(ServiceDatabaseAsyncLocalStorage).current;
+  }
+
+  getClient(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient) {
+    const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
+    const clientConfigReal = this.scope.service.database.getClientConfig(dbInfo.clientName, clientConfig);
+    const selector = this.scope.service.database.prepareClientNameSelector(dbInfo, clientConfigReal.client);
+    return this.app.bean._getBeanSelector(ServiceDatabaseClient, selector, clientConfigReal);
+  }
+
+  getDb(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient) {
+    return this.getClient(dbInfoOrClientName, clientConfig).db;
+  }
+
+  getDialect(client: keyof IDatabaseClientDialectRecord): BeanDatabaseDialectBase {
+    if (!client) throw new Error('database dialect not specified');
+    const beanFullName = beanFullNameFromOnionName(this.scope.config.dialects[client], 'databaseDialect');
+    const dialect = this.app.bean._getBean(beanFullName) as BeanDatabaseDialectBase;
+    if (!dialect) throw new Error(`database dialect not found: ${client}`);
+    return dialect;
+  }
+
+  async switchDbIsolate<RESULT>(fn: FunctionAsync<RESULT>, dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): Promise<RESULT> {
+    const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
+    // const level = this.app.config.database.defaultClient === 'sqlite3' ? dbInfo.level : dbInfo.level + 1;
+    const level = dbInfo.level + 1;
+    return this.switchDb(fn, { level, clientName: dbInfo.clientName });
+  }
+
+  async switchDb<RESULT>(fn: FunctionAsync<RESULT>, dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): Promise<RESULT> {
+    const current = this.bean.database.current;
+    const dbInfo = this.scope.service.database.prepareDbInfo(dbInfoOrClientName);
+    if (dbInfo.level === current?.level && dbInfo.clientName === current?.clientName) {
+      return fn();
+    }
+    const db = this.getDb(dbInfo);
+    return this.bean._getBean(ServiceDatabaseAsyncLocalStorage).run(db, () => {
+      return this.bean._getBean(ServiceTransactionAsyncLocalStorage).run(fn);
+    });
+  }
+}

package/src/bean/bean.databaseDialectBase.ts

@@ -0,0 +1,149 @@
+import type { Knex } from 'knex';
+import type { TableIdentity } from 'table-identity';
+
+import { isNil, safeBoolean } from '@cabloy/utils';
+import { BeanBase, Virtual } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import type { ITableColumn } from '../types/columns.ts';
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type {
+  IDatabaseDialectCapabilities,
+  IFetchDatabasesResultItem,
+  IFetchIndexesResultItem,
+  TypeDatabaseDialectTableColumnsFn,
+} from '../types/dialect.ts';
+
+@Bean()
+@Virtual()
+export class BeanDatabaseDialectBase extends BeanBase {
+  protected _capabilities?: IDatabaseDialectCapabilities;
+  protected _configBase?: Partial<ConfigDatabaseClient>;
+
+  get capabilities() {
+    if (!this._capabilities) throw new Error('Should provide dialect capabilities');
+    return this._capabilities;
+  }
+
+  get configBase() {
+    return this._configBase;
+  }
+
+  async fetchDatabases(_schemaBuilder: Knex.SchemaBuilder, _databasePrefix: string): Promise<IFetchDatabasesResultItem[]> {
+    throw new Error('Not Implemented');
+  }
+
+  async createDatabase(_schemaBuilder: Knex.SchemaBuilder, _databaseName: string): Promise<string> {
+    throw new Error('Not Implemented');
+  }
+
+  async dropDatabase(_schemaBuilder: Knex.SchemaBuilder, _databaseName: string): Promise<void> {
+    throw new Error('Not Implemented');
+  }
+
+  async fetchIndexes(_schemaBuilder: Knex.SchemaBuilder, _tableName: string): Promise<IFetchIndexesResultItem[]> {
+    throw new Error('Not Implemented');
+  }
+
+  async insert(_builder: Knex.QueryBuilder, _datas: any[]): Promise<TableIdentity[]> {
+    throw new Error('Not Implemented');
+  }
+
+  async select(_builder: Knex.QueryBuilder, datas: any[], _fn: TypeDatabaseDialectTableColumnsFn): Promise<any[]> {
+    return datas;
+  }
+
+  query(_result) {
+    throw new Error('Not Implemented');
+  }
+
+  async viewDependents(_builder: Knex.QueryBuilder, _viewName: string): Promise<string[]> {
+    throw new Error('Not Implemented');
+  }
+
+  coerceColumn(column: Knex.ColumnInfo): ITableColumn {
+    // result
+    const result = { type: column.type } as ITableColumn;
+    // coerce
+    result.default = this._coerceColumnValue(column.type, column.defaultValue);
+    // ok
+    return result;
+  }
+
+  protected async selectAsSqlite3(_builder: Knex.QueryBuilder, datas: any[], fn: TypeDatabaseDialectTableColumnsFn): Promise<any[]> {
+    const columns = await fn();
+    // data
+    for (const data of datas) {
+      for (const columnName in columns) {
+        const column = columns[columnName];
+        if (Object.prototype.hasOwnProperty.call(data, columnName)) {
+          const value = data[columnName];
+          if (column.type === 'json' && !isNil(value) && typeof value === 'string') {
+            data[columnName] = JSON.parse(value);
+          } else if (column.type === 'datetime' && !isNil(value)) {
+            data[columnName] = new Date(value);
+          }
+        }
+      }
+    }
+    return datas;
+  }
+
+  protected async insertAsMysql(builder: Knex.QueryBuilder, datas: any[]): Promise<TableIdentity[]> {
+    if (datas.length === 0) return [];
+    if (isNil(datas[0].id)) {
+      const ids: TableIdentity[] = [];
+      for (const data of datas) {
+        const builder2 = builder.clone();
+        builder2.insert(data);
+        const items = await builder2;
+        ids.push(items[0]);
+      }
+      return ids;
+    } else {
+      builder.insert(datas);
+      await builder;
+      return datas.map(item => item.id);
+    }
+  }
+
+  protected async insertAsPg(builder: Knex.QueryBuilder, datas: any[]): Promise<TableIdentity[]> {
+    if (datas.length === 0) return [];
+    if (isNil(datas[0].id)) {
+      builder.insert(datas).returning('id');
+      const items = await builder;
+      return items.map(item => item.id);
+    } else {
+      builder.insert(datas);
+      await builder;
+      return datas.map(item => item.id);
+    }
+  }
+
+  protected _coerceColumnValue(type: string, value) {
+    // null
+    if (isNil(value)) return undefined;
+    // type
+    if (['bit', 'bool', 'boolean'].includes(type)) return safeBoolean(value);
+    if (['int'].includes(type)) return this._safeNumber(value);
+    if (this._columnTypePrefixes(type, ['timestamp']) && value === 'CURRENT_TIMESTAMP') return undefined; // new Date();
+    if (this._columnTypePrefixes(type, ['float', 'double'])) return this._safeNumber(value);
+    if (this._columnTypePrefixes(type, ['tinyint', 'smallint', 'mediumint', 'bigint', 'numeric', 'integer'])) {
+      return this._safeNumber(value);
+    }
+    // pg: NULL::character varying
+    if (value.indexOf('NULL::') === 0) return undefined;
+    // others
+    return value;
+  }
+
+  // pg: nextval
+  protected _safeNumber(value) {
+    const num = Number(value);
+    return Number.isNaN(num) ? undefined : num;
+  }
+
+  protected _columnTypePrefixes(type: string, prefixes: string[]) {
+    return prefixes.some(prefix => type.includes(prefix));
+  }
+}