vona-module-a-orm 5.0.96 → 5.1.2

package/src/service/columns_.ts

@@ -0,0 +1,64 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { ITableColumns, ITableColumnsDefault } from '../types/columns.ts';
+import type { ServiceDb } from './db_.ts';
+
+import { ServiceColumnsCache } from './columnsCache_.ts';
+
+@Service()
+export class ServiceColumns extends BeanBase {
+  private _db: ServiceDb;
+  private _serviceColumnsCache: ServiceColumnsCache;
+
+  protected __init__(db: ServiceDb) {
+    this._db = db;
+  }
+
+  private get db() {
+    return this._db;
+  }
+
+  private get serviceColumnsCache() {
+    if (!this._serviceColumnsCache) {
+      const clientNameReal = this.scope.service.database.prepareClientNameReal(this.db.clientName);
+      this._serviceColumnsCache = this.bean._getBeanSelector(ServiceColumnsCache, clientNameReal);
+    }
+    return this._serviceColumnsCache;
+  }
+
+  async columns(tableName?: string): Promise<ITableColumns> {
+    if (!tableName) return {};
+    let columns = this.serviceColumnsCache.getColumnsCache(tableName);
+    if (!columns) {
+      const dialect = this.db.dialect;
+      const connection = this.db.connection;
+      const map = await connection(tableName).columnInfo();
+      columns = {};
+      for (const name in map) {
+        columns[name] = dialect.coerceColumn(map[name]);
+      }
+      this.serviceColumnsCache.setColumnsCache(tableName, columns);
+    }
+    return columns;
+  }
+
+  async defaultData(tableName?: string): Promise<ITableColumnsDefault> {
+    if (!tableName) return {};
+    let data = this.serviceColumnsCache.getColumnsDefaultCache(tableName);
+    if (!data) {
+      data = {};
+      // columns
+      const columns = await this.columns(tableName);
+      for (const columnName in columns) {
+        data[columnName] = columns[columnName].default;
+      }
+      this.serviceColumnsCache.setColumnsDefaultCache(tableName, data);
+    }
+    return data;
+  }
+
+  columnsClear(tableName?: string) {
+    return this.scope.service.database.columnsClear(this.db.clientName, tableName);
+  }
+}

package/src/service/database.ts

@@ -0,0 +1,126 @@
+import { isNil } from '@cabloy/utils';
+import { appResource, BeanBase, deepExtend } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+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 { ServiceDatabaseClient } from './databaseClient_.ts';
+
+@Service()
+export class ServiceDatabase extends BeanBase {
+  get configDatabase() {
+    return this.app.config.database;
+  }
+
+  getClientConfig(clientName: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient, original?: boolean): ConfigDatabaseClient {
+    // clientConfig
+    if (!clientConfig) {
+      clientConfig = this.configDatabase.clients[clientName];
+    }
+    // check
+    if (!clientConfig) {
+      throw new Error(`database config not found: ${clientName}`);
+    }
+    if (original) return clientConfig;
+    // configBaseClient
+    const dialect = this.bean.database.getDialect(clientConfig.client);
+    // combine
+    clientConfig = deepExtend({}, this.configDatabase.base, dialect.configBase, clientConfig);
+    // ready
+    return clientConfig!;
+  }
+
+  prepareDbInfo(dbInfoOrClientName?: Partial<IDbInfo> | keyof IDatabaseClientRecord): IDbInfo {
+    let level;
+    let clientName;
+    if (typeof dbInfoOrClientName === 'string') {
+      level = undefined;
+      clientName = dbInfoOrClientName;
+    } else {
+      level = dbInfoOrClientName?.level;
+      clientName = dbInfoOrClientName?.clientName;
+    }
+    // check if selector
+    if (clientName && clientName.includes(':')) return clientName;
+    // check if default
+    clientName = this.prepareClientName(clientName ?? this.bean.database.current?.clientName);
+    // level
+    level = level ?? this.bean.database.current?.level ?? 0;
+    return { level, clientName };
+  }
+
+  prepareClientNameSelector(dbInfo: IDbInfo, dialect: BeanDatabaseDialectBase | keyof IDatabaseClientDialectRecord) {
+    const dialect2 = typeof dialect === 'string' ? this.bean.database.getDialect(dialect) : dialect;
+    if (!dialect2.capabilities.level) return dbInfo.clientName;
+    // combine
+    return dbInfo.level === 0 ? dbInfo.clientName : `${dbInfo.clientName}:${dbInfo.level}`;
+  }
+
+  parseClientNameSelector(clientNameSelector: string): IDbInfo {
+    if (isNil(clientNameSelector)) throw new Error('invalid clientNameSelector');
+    const [clientName, level] = clientNameSelector.split(':');
+    if (!clientName) throw new Error('clientName must be specified');
+    return {
+      level: Number(level ?? 0),
+      clientName: clientName as keyof IDatabaseClientRecord,
+    };
+  }
+
+  prepareClientName(clientName?: keyof IDatabaseClientRecord): keyof IDatabaseClientRecord {
+    return !clientName || clientName === 'default' ? this.getDefaultClientName() : clientName;
+  }
+
+  getDefaultClientName(): keyof IDatabaseClientRecord {
+    const defaultClient = this.app.config.database.defaultClient;
+    if (typeof defaultClient === 'function') {
+      return defaultClient(this.ctx);
+    }
+    // check instance
+    const instanceName = this.ctx.instanceName;
+    if (!isNil(instanceName)) {
+      const configInstanceBase = this.$scope.instance.service.instance.getConfigInstanceBase(instanceName);
+      if (configInstanceBase?.isolate) {
+        return configInstanceBase.isolateClient!;
+      }
+    }
+    return defaultClient;
+  }
+
+  prepareClientNameReal(clientName?: keyof IDatabaseClientRecord): keyof IDatabaseClientRecord {
+    return this.scope.event.clientNameReal.emitSync(this.prepareClientName(clientName), clientName => {
+      return clientName;
+    });
+  }
+
+  columnsClear(clientName?: keyof IDatabaseClientRecord, tableName?: string) {
+    this.columnsClearWorker(clientName, tableName);
+    this.scope.broadcast.columnsClear.emit({ clientName, tableName });
+  }
+
+  private columnsClearWorker(clientName?: keyof IDatabaseClientRecord, tableName?: string) {
+    this.scope.event.columnsClear.emitSync({ clientName: this.prepareClientNameReal(clientName), tableName });
+  }
+
+  async reloadClients(clientName?: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient) {
+    clientName = this.prepareClientName(clientName);
+    await this.bean.mutate.reloadInstances(ServiceDatabaseClient, { clientName, clientConfig });
+    this.columnsClear(clientName);
+  }
+
+  async reloadClientsWorker(clientName?: keyof IDatabaseClientRecord, clientConfig?: ConfigDatabaseClient) {
+    clientName = this.prepareClientName(clientName);
+    await this.bean.mutate.reloadInstancesWorker({
+      beanFullName: appResource.getBeanFullName(ServiceDatabaseClient) as any,
+      data: { clientName, clientConfig },
+    });
+    this.columnsClearWorker(clientName);
+  }
+
+  async disposeClients(clientName?: keyof IDatabaseClientRecord) {
+    clientName = this.prepareClientName(clientName);
+    await this.bean.mutate.removeInstances(ServiceDatabaseClient, { clientName });
+    this.columnsClear(clientName);
+  }
+}

package/src/service/databaseAsyncLocalStorage_.ts

@@ -0,0 +1,29 @@
+import type { FunctionAsync } from 'vona';
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import { ServiceDb } from '../service/db_.ts';
+
+@Service()
+export class ServiceDatabaseAsyncLocalStorage extends BeanBase {
+  dbStorage: AsyncLocalStorage<ServiceDb>;
+
+  protected __init__() {
+    this.dbStorage = new AsyncLocalStorage();
+  }
+
+  get current(): ServiceDb {
+    return this.dbStorage.getStore()!;
+  }
+
+  async run<RESULT>(store: ServiceDb, fn: FunctionAsync<RESULT>): Promise<RESULT> {
+    if (store === this.current) {
+      return fn();
+    }
+    return this.dbStorage.run(store, () => {
+      return fn();
+    });
+  }
+}

package/src/service/databaseClient_.ts

@@ -0,0 +1,124 @@
+import type { Knex } from 'knex';
+
+import { catchError } from '@cabloy/utils';
+import knex from 'knex';
+import { deepExtend } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { BeanMutateBase } from 'vona-module-a-beanmutate';
+
+import type { ConfigDatabaseClient } from '../types/config.ts';
+import type { IDatabaseClientRecord } from '../types/database.ts';
+
+import { ServiceDb } from './db_.ts';
+
+export interface IPrepareDatabaseNameResult {
+  database?: string;
+  filename?: string;
+}
+
+@Service()
+export class ServiceDatabaseClient extends BeanMutateBase {
+  level: number;
+  clientName: keyof IDatabaseClientRecord;
+  clientNameSelector: string;
+  clientConfig: ConfigDatabaseClient;
+  private _knex: Knex;
+  private _db: ServiceDb;
+
+  get configDatabase() {
+    return this.app.config.database;
+  }
+
+  get connection(): Knex {
+    return this._knex;
+  }
+
+  get db(): ServiceDb {
+    return this._db;
+  }
+
+  protected __init__(clientNameSelector?: string, clientConfig?: ConfigDatabaseClient) {
+    super.__init__();
+    // db
+    this._db = this.bean._newBean(ServiceDb, this);
+    // load
+    this.__load(clientNameSelector!, clientConfig);
+  }
+
+  protected async __dispose__() {
+    await super.__dispose__();
+    this._db = undefined as any;
+    await this.__close();
+  }
+
+  protected async onReloadInstance({ clientName, clientConfig }) {
+    if (clientName === this.clientName) {
+      await this.reload(clientConfig);
+    }
+  }
+
+  protected async onRemoveInstance({ clientName }) {
+    if (clientName === this.clientName) {
+      await super.onRemoveInstance({ clientName });
+    }
+  }
+
+  private __load(clientNameSelector: string, clientConfig?: ConfigDatabaseClient) {
+    // name
+    this.clientNameSelector = clientNameSelector;
+    const dbInfo = this.scope.service.database.parseClientNameSelector(clientNameSelector);
+    this.level = dbInfo.level;
+    this.clientName = dbInfo.clientName;
+    // config: inited by bean.database.getClient
+    this.clientConfig = clientConfig!;
+    // knex
+    this._knex = knex(deepExtend({}, this.clientConfig));
+  }
+
+  private async __close() {
+    if (this._knex) {
+      await catchError(() => {
+        return this._knex.destroy();
+      });
+      this._knex = undefined as any;
+    }
+  }
+
+  async reload(clientConfig?: ConfigDatabaseClient) {
+    const clientConfigReal = this.scope.service.database.getClientConfig(this.clientName, clientConfig);
+    this.$mutate([this.clientNameSelector, clientConfigReal]);
+    await this.__close();
+    this.__load(this.clientNameSelector, clientConfigReal);
+  }
+
+  getDatabaseName(): string {
+    const connection = this.clientConfig.connection as any;
+    return connection.database || connection.filename;
+  }
+
+  private _prepareDatabaseName(databaseName: string): IPrepareDatabaseNameResult {
+    const result: IPrepareDatabaseNameResult = {};
+    const connection = this.clientConfig.connection as any;
+    if (connection.database !== undefined) {
+      result.database = databaseName;
+    } else if (connection.filename !== undefined) {
+      result.filename = databaseName;
+    }
+    return result;
+  }
+
+  // only used by startup, so no consider that workers broadcast
+  async changeConfigConnectionAndReloadWorker(databaseName: string): Promise<void> {
+    // set databaseName
+    const connDatabaseName = this._prepareDatabaseName(databaseName);
+    // set config
+    //   * should not use this.clientConfig.connection, because password is hidden
+    const config = this.scope.service.database.getClientConfig(this.clientName, undefined, true);
+    config.connection = Object.assign({}, config.connection, connDatabaseName);
+    // only used by startup, so no consider that workers broadcast
+    this.configDatabase.clients[this.clientName] = config;
+    // reload
+    await this.scope.service.database.reloadClientsWorker(this.clientName, config);
+    // await this.scope.service.database.reloadClients(this.clientName, config);
+  }
+}

package/src/service/db_.ts

@@ -0,0 +1,77 @@
+import type { FunctionAny } from 'vona';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+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 { ServiceColumns } from './columns_.ts';
+import { ServiceTransaction } from './transaction_.ts';
+
+@Service()
+export class ServiceDb extends BeanBase {
+  private _client: ServiceDatabaseClient;
+  private _columns: ServiceColumns;
+  private _transaction: ServiceTransaction;
+
+  protected __init__(client: ServiceDatabaseClient) {
+    this._client = client;
+  }
+
+  get info(): IDbInfo {
+    return { level: this.level, clientName: this.clientName };
+  }
+
+  get level() {
+    return this._client.level;
+  }
+
+  get clientName() {
+    return this._client.clientName;
+  }
+
+  get client() {
+    return this._client;
+  }
+
+  get columns() {
+    if (!this._columns) {
+      this._columns = this.app.bean._newBean(ServiceColumns, this);
+    }
+    return this._columns;
+  }
+
+  get transaction() {
+    if (!this._transaction) {
+      this._transaction = this.app.bean._newBean(ServiceTransaction, this);
+    }
+    return this._transaction;
+  }
+
+  get inTransaction() {
+    return this.transaction.inTransaction;
+  }
+
+  get connection() {
+    return this.transaction.connection ?? this.client.connection;
+  }
+
+  get dialectName(): keyof IDatabaseClientDialectRecord {
+    return this.client.clientConfig.client;
+  }
+
+  get dialect(): BeanDatabaseDialectBase {
+    return this.bean.database.getDialect(this.dialectName);
+  }
+
+  async commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions) {
+    return await this.transaction.commit(cb, options);
+  }
+
+  compensate(cb: FunctionAny) {
+    return this.transaction.compensate(cb);
+  }
+}

package/src/service/entityResolver_.ts

@@ -0,0 +1,25 @@
+import { appResource, BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+import { $columnsAll } from 'vona-module-a-ormutils';
+
+const SymbolModuleScope = Symbol('SymbolModuleScope');
+
+@Service()
+export class ServiceEntityResolver extends BeanBase {
+  protected [SymbolModuleScope]: string;
+  private __instances: Record<string, any> = {};
+
+  constructor(moduleScope: string) {
+    super();
+    this[SymbolModuleScope] = moduleScope;
+  }
+
+  protected __get__(prop: string) {
+    if (!this.__instances[prop]) {
+      const beanFullName = `${this[SymbolModuleScope]}.entity.${prop}`;
+      const beanOptions = appResource.getBean(beanFullName)!;
+      this.__instances[prop] = $columnsAll(beanOptions.beanClass, true, true);
+    }
+    return this.__instances[prop];
+  }
+}

package/src/service/modelResolver_.ts

@@ -0,0 +1,19 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+const SymbolModuleScope = Symbol('SymbolModuleScope');
+
+@Service()
+export class ServiceModelResolver extends BeanBase {
+  protected [SymbolModuleScope]: string;
+
+  constructor(moduleScope: string) {
+    super();
+    this[SymbolModuleScope] = moduleScope;
+  }
+
+  protected __get__(prop: string) {
+    const beanFullName = `${this[SymbolModuleScope]}.model.${prop}`;
+    return this.bean._getBean(beanFullName as any);
+  }
+}