vona-module-a-orm 5.0.96 → 5.1.2

package/src/bean/bean.model/bean.model_utils.ts

@@ -0,0 +1,275 @@
+import type { Knex } from 'knex';
+
+import { ensureArray, isNil } from '@cabloy/utils';
+import { cast } from 'vona';
+import { $tableDefaults } from 'vona-module-a-ormutils';
+
+import type {
+  IModelMethodOptionsGeneral,
+  IModelSelectParamsJoin,
+  IModelSelectParamsPage,
+  ITableColumns,
+  ITableRecord,
+  TypeModelColumn,
+  TypeModelColumns,
+  TypeModelColumnsStrict,
+  TypeModelIncrementParamsColumns,
+  TypeModelSelectAggrParamsAggrs,
+  TypeModelSelectGroupParamsColumns,
+  TypeModelWhere,
+} from '../../types/index.ts';
+
+import { buildWhere } from '../../common/buildWhere.ts';
+import { isRaw } from '../../common/utils.ts';
+import { BeanModelMeta } from './bean.model_meta.ts';
+
+export class BeanModelUtils<TRecord extends {}> extends BeanModelMeta<TRecord> {
+  async prepareData(item?: Partial<TRecord>): Promise<[TRecord, TRecord]>;
+  async prepareData(table: keyof ITableRecord, item?: Partial<TRecord>): Promise<[TRecord, TRecord]>;
+  async prepareData(table?, item?): Promise<[TRecord, TRecord]> {
+    if (typeof table !== 'string') {
+      item = table;
+      table = undefined;
+    }
+    // table
+    table = table || this.getTable(item);
+    if (!table) return this.scopeOrm.error.ShouldSpecifyTable.throw();
+    // item
+    if (!item) return [{}, {}] as [TRecord, TRecord];
+    // columns
+    const columns = await this.columns(table);
+    // data
+    const data = {};
+    const dataOriginal = {};
+    for (const columnName in columns) {
+      const column = columns[columnName];
+      if (Object.prototype.hasOwnProperty.call(item, columnName)) {
+        let value = item[columnName];
+        dataOriginal[columnName] = value;
+        if (column.type === 'json' && value !== undefined) {
+          value = JSON.stringify(value);
+        }
+        data[columnName] = value;
+      }
+    }
+    return [data, dataOriginal] as [TRecord, TRecord];
+  }
+
+  async defaultData(table?: keyof ITableRecord): Promise<TRecord> {
+    if (this.options.entity) {
+      return $tableDefaults(this.options.entity) as any;
+    }
+    table = table || this.getTable(undefined);
+    return (await this.db.columns.defaultData(table)) as TRecord;
+  }
+
+  async columns(table?: keyof ITableRecord): Promise<ITableColumns> {
+    table = table || this.getTable(undefined);
+    return await this.db.columns.columns(table);
+  }
+
+  isRaw(raw) {
+    return isRaw(raw);
+  }
+
+  raw(value: Knex.Value): Knex.Raw<any>;
+  raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(sql: string, binding: Knex.RawBinding): Knex.Raw<TResult2>;
+  raw<TRecord2 extends {} = TRecord, TResult2 = TRecord2>(sql: string, bindings: readonly Knex.RawBinding[] | Knex.ValueDict): Knex.Raw<TResult2>;
+  raw(sql, bindings?) {
+    return this.connection.raw(sql, bindings);
+  }
+
+  ref<TSrc extends string>(src: TSrc): Knex.Ref<TSrc, { [K in TSrc]: TSrc }> {
+    return this.connection.ref<TSrc>(src);
+  }
+
+  toIdentifier(name: string | string[]): Knex.Raw<any> {
+    const parts = Array.isArray(name) ? name : name.split(',');
+    return this.raw(parts.map(_ => '??').join(','), parts);
+  }
+
+  // checkWhere(where: TypeModelWhere<TRecord>) {
+  //   return checkWhere(where);
+  // }
+
+  buildWhere(builder: Knex.QueryBuilder, wheres?: TypeModelWhere<TRecord>) {
+    if (!wheres) return;
+    return buildWhere(this.db, builder, wheres);
+  }
+
+  buildJoin(builder: Knex.QueryBuilder, join?: IModelSelectParamsJoin<TRecord, ''>) {
+    if (!join) return;
+    const [joinType, joinTable, joinOn] = join;
+    builder[joinType](joinTable, cast(joinOn));
+  }
+
+  buildJoins(builder: Knex.QueryBuilder, joins?: IModelSelectParamsJoin<TRecord, ''>[]) {
+    if (!joins) return;
+    for (const [joinType, joinTable, joinOn] of joins) {
+      if (Array.isArray(joinOn)) {
+        cast(builder)[joinType](joinTable, ...joinOn);
+      } else {
+        builder[joinType](joinTable, joinOn);
+      }
+    }
+  }
+
+  buildDistinct(builder: Knex.QueryBuilder, distinct?: boolean | keyof TRecord | (keyof TRecord)[]) {
+    if (distinct === undefined || distinct === false) return;
+    if (distinct === true) {
+      builder.distinct();
+    } else if (Array.isArray(distinct)) {
+      builder.distinct(...distinct);
+    } else {
+      builder.distinct(distinct);
+    }
+  }
+
+  buildCount(builder: Knex.QueryBuilder, column?: TypeModelColumn<TRecord>, distinct?: boolean | keyof TRecord | (keyof TRecord)[]) {
+    if (column !== undefined) {
+      builder.count(column);
+    } else if (distinct !== undefined && distinct !== false) {
+      builder.count(this.raw(`distinct ${this.toIdentifier(distinct as any)}`));
+    } else {
+      builder.count();
+    }
+  }
+
+  buildIncrement(builder: Knex.QueryBuilder, columns: TypeModelIncrementParamsColumns<TRecord>) {
+    builder.increment(columns as any);
+  }
+
+  buildOrders(builder: Knex.QueryBuilder, orders) {
+    if (!orders) return;
+    for (const [orderColumn, orderDirection, orderNulls] of orders) {
+      builder.orderBy(orderColumn, orderDirection, orderNulls);
+    }
+  }
+
+  buildLimit(builder: Knex.QueryBuilder, limit?: number) {
+    if (limit !== 0 && limit !== undefined) {
+      builder.limit(limit);
+    }
+  }
+
+  buildOffset(builder: Knex.QueryBuilder, offset?: number) {
+    if (offset !== undefined) {
+      builder.offset(offset);
+    }
+  }
+
+  buildColumns(builder: Knex.QueryBuilder, columns?: TypeModelColumns<TRecord>, groups?: (keyof TRecord)[] | undefined) {
+    if (columns) {
+      builder.select(columns as any);
+    } else if (groups) {
+      builder.select(groups);
+    }
+  }
+
+  buildGroups(builder: Knex.QueryBuilder, groups?: TypeModelColumnsStrict<TRecord>) {
+    if (!groups) return;
+    groups = ensureArray(groups)!;
+    builder.groupBy(groups);
+    return groups;
+  }
+
+  buildAggrs(builder: Knex.QueryBuilder, aggrs?: TypeModelSelectAggrParamsAggrs<TRecord>) {
+    if (!aggrs) return;
+    for (const key in aggrs) {
+      const columns = ensureArray(aggrs[key]);
+      if (!columns) continue;
+      for (const column of columns) {
+        const column2 = `${key}_${column === '*' ? 'all' : column}`;
+        builder[key](column, { as: column2 });
+      }
+    }
+  }
+
+  buildPage(builder: Knex.QueryBuilder, page?: IModelSelectParamsPage) {
+    if (!page) return;
+    this.buildLimit(builder, page.size);
+    this.buildOffset(builder, page.index);
+  }
+
+  prepareHaving(builder: Knex.QueryBuilder, having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>) {
+    if (!having) return;
+    this.buildHaving(builder, having);
+  }
+
+  buildHaving(builder: Knex.QueryBuilder, having: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>) {
+    return buildWhere(this.db, builder, having, true);
+  }
+
+  prepareWhere(builder: Knex.QueryBuilder, table?: keyof ITableRecord, where?: TypeModelWhere<TRecord>, options?: IModelMethodOptionsGeneral) {
+    // table
+    table = table || this.getTable(where);
+    if (!table) throw new Error('should specify the table name');
+    // disableInstance/disableDeleted
+    where = Object.assign({}, where);
+    where = this._prepareWhereByOptions(table, where, options);
+    // build
+    this.buildWhere(builder, where);
+  }
+
+  extractCount(result: Array<object> | object, columnName?: string): string {
+    return this.extractFirstNumber(result, 0, columnName)!;
+  }
+
+  extractFirstNumber<T = number | string | undefined>(
+    result: Array<object> | object,
+    defaultValue?: T,
+    columnName?: string,
+  ): T extends undefined ? string | undefined : string {
+    const value = this.extractFirstValue(result, defaultValue, columnName);
+    if (value === undefined || value === null) return undefined as any;
+    return String(value);
+  }
+
+  extractFirstValue(result: Array<object> | object, defaultValue?: any, columnName?: string): any | undefined {
+    const value = this._extractFirstValue(result, columnName);
+    if (value === undefined || value === null) return defaultValue;
+    return value;
+  }
+
+  private _extractFirstValue(result: Array<object> | object, columnName?: string): any | undefined {
+    const res = Array.isArray(result) ? result[0] : result;
+    if (!res) return undefined;
+    if (columnName) return res[columnName];
+    const keys = Object.keys(res);
+    if (keys.length === 0) return undefined;
+    return res[keys[0]];
+  }
+
+  protected _prepareWhereByOptions(table: keyof ITableRecord, where, options?: IModelMethodOptionsGeneral) {
+    // disableInstance: should not check if specified
+    where = this._prepareDisableInstanceByOptions(table, where, options);
+    // disableDeleted: should not check if specified
+    where = this._prepareDisableDeletedByOptions(table, where, options);
+    // ok
+    return where;
+  }
+
+  protected _prepareInsertDataByOptions(table: keyof ITableRecord, data, options?: IModelMethodOptionsGeneral) {
+    let result = Object.assign({}, data);
+    // disableInstance: should not check if specified
+    result = this._prepareDisableInstanceByOptions(table, result, options, true);
+    // disableDeleted: should not check if specified
+    result = this._prepareDisableDeletedByOptions(table, result, options, true);
+    // createdAt/updatedAt
+    if (isNil(result.createdAt)) {
+      if (!this._checkDisableCreateTimeByOptions(options)) {
+        result.createdAt = new Date();
+      } else {
+        delete result.createdAt;
+      }
+    }
+    if (isNil(result.updatedAt)) {
+      if (!this._checkDisableUpdateTimeByOptions(options)) {
+        result.updatedAt = new Date();
+      } else {
+        delete result.updatedAt;
+      }
+    }
+    return result;
+  }
+}

package/src/bean/bean.model/bean.model_view.ts

@@ -0,0 +1,129 @@
+import type { ISwapDepsItem } from '@cabloy/deps';
+import type { Knex } from 'knex';
+
+import { swapDeps } from '@cabloy/deps';
+import { cast } from 'vona';
+
+import { BeanModelKnex } from './bean.model_knex.ts';
+
+export class BeanModelView<TRecord extends {}> extends BeanModelKnex<TRecord> {
+  async createView(viewName: string, callback?: (viewBuilder: Knex.ViewBuilder) => any): Promise<void> {
+    if (callback) {
+      // create view
+      let _view: Knex.ViewBuilder | null = null;
+      await this.schema.createView(viewName, view => {
+        _view = view;
+        return callback(view);
+      });
+      // view sql
+      const sql = cast(_view).toSQL();
+      const viewSql = sql[0].sql;
+      // record view
+      const viewRecord = await this.modelViewRecord.get({ viewName });
+      if (viewRecord) {
+        await this.modelViewRecord.update({ id: viewRecord.id, viewSql });
+      } else {
+        await this.modelViewRecord.insert({ viewName, viewSql });
+      }
+    } else {
+      // get record
+      const viewRecord = await this.modelViewRecord.get({ viewName });
+      if (!viewRecord) throw new Error(`not found view record: ${viewName}`);
+      await this.raw(viewRecord.viewSql);
+    }
+  }
+
+  async dropView(viewName: string, disableRemoveRecord?: boolean) {
+    // drop view: use dropViewIfExists
+    await this.schema.dropViewIfExists(viewName);
+    // remove record
+    if (!disableRemoveRecord) {
+      await this.modelViewRecord.delete({ viewName });
+    }
+  }
+
+  async alterView(viewName: string, callback?: (viewBuilder: Knex.ViewBuilder) => any): Promise<void> {
+    await this._viewDependentsAll_handle(viewName, async () => {
+      // drop view
+      await this.dropView(viewName, true);
+      // create view
+      await this.createView(viewName, callback);
+    });
+  }
+
+  async createTable(tableName: string, callback: (tableBuilder: Knex.CreateTableBuilder) => any): Promise<void> {
+    await this.schema.createTable(tableName, callback);
+  }
+
+  async dropTable(tableName: string) {
+    await this.schema.dropTable(tableName);
+  }
+
+  async alterTable(tableName: string, callback: (tableBuilder: Knex.CreateTableBuilder) => any, alterViewAuto?: boolean): Promise<void> {
+    if (!alterViewAuto) {
+      // alter table
+      return await this.schema.alterTable(tableName, table => {
+        return callback(table);
+      });
+    }
+    await this._viewDependentsAll_handle(tableName, async () => {
+      await this.schema.alterTable(tableName, table => {
+        return callback(table);
+      });
+    });
+  }
+
+  async viewDependents(viewName: string): Promise<string[]> {
+    // builder
+    const builder = this.builder();
+    // dialect
+    return await this.dialect.viewDependents(builder, viewName);
+  }
+
+  async viewDependentsAll(viewName: string): Promise<string[]> {
+    // views
+    const views: ISwapDepsItem[] = [{ name: viewName, dependencies: [] }];
+    // dependencies all
+    await this._viewDependentsAll_inner(viewName, views);
+    // swap
+    swapDeps(views);
+    // shift
+    views.shift();
+    // ready
+    return views.map(view => view.name);
+  }
+
+  private async _viewDependentsAll_inner(viewName: string, views: ISwapDepsItem[]) {
+    const dependents = await this.viewDependents(viewName);
+    for (const dependent of dependents) {
+      // dependencies
+      const view = views.find(view => view.name === dependent);
+      if (view) {
+        const dep = cast(view.dependencies).find(dep => dep.toLowerCase() === viewName.toLowerCase());
+        if (!dep) {
+          cast(view.dependencies).push(viewName);
+        }
+      } else {
+        views.push({ name: dependent, dependencies: [viewName] });
+      }
+      // next
+      await this._viewDependentsAll_inner(dependent, views);
+    }
+  }
+
+  private async _viewDependentsAll_handle(viewName: string, callback: () => Promise<void>) {
+    // viewDependentsAll
+    const viewDependents = await this.viewDependentsAll(viewName);
+    // drop dependents
+    for (let i = viewDependents.length - 1; i >= 0; i--) {
+      const viewDependent = viewDependents[i];
+      await this.dropView(viewDependent, true);
+    }
+    // callback
+    await callback();
+    // create dependents
+    for (const viewDependent of viewDependents) {
+      await this.createView(viewDependent);
+    }
+  }
+}

package/src/bean/bean.model.ts

@@ -0,0 +1,8 @@
+import { Virtual } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import { BeanModelCrudTable } from './bean.model/bean.model_crud_table.ts';
+
+@Bean()
+@Virtual()
+export class BeanModel<TRecord extends {} = any> extends BeanModelCrudTable<TRecord> {}

package/src/bean/bean.modelBase.ts

@@ -0,0 +1,8 @@
+import { Virtual } from 'vona';
+import { Bean } from 'vona-module-a-bean';
+
+import { BeanModelCache } from './bean.model/bean.model_cache.ts';
+
+@Bean()
+@Virtual()
+export class BeanModelBase<TRecord extends {} = any> extends BeanModelCache<TRecord> {}

package/src/bean/broadcast.columnsClear.ts

@@ -0,0 +1,24 @@
+import type { IBroadcastExecute } from 'vona-module-a-broadcast';
+
+import { cast } from 'vona';
+import { BeanBroadcastBase, Broadcast } from 'vona-module-a-broadcast';
+
+import type { IDatabaseClientRecord } from '../types/database.ts';
+
+export interface TypeBroadcastColumnsClearJobData {
+  clientName?: keyof IDatabaseClientRecord;
+  tableName?: string;
+}
+
+@Broadcast()
+export class BroadcastColumnsClear
+  extends BeanBroadcastBase<TypeBroadcastColumnsClearJobData>
+  implements IBroadcastExecute<TypeBroadcastColumnsClearJobData>
+{
+  async execute(data: TypeBroadcastColumnsClearJobData, isEmitter?: boolean) {
+    const { clientName, tableName } = data;
+    if (!isEmitter) {
+      await cast(this.scope.service.database).columnsClearWorker(clientName, tableName);
+    }
+  }
+}

package/src/bean/event.clientNameReal.ts

@@ -0,0 +1,10 @@
+import { BeanEventBase, Event } from 'vona-module-a-event';
+
+import type { IDatabaseClientRecord } from '../types/database.ts';
+
+export type TypeEventClientNameRealData = keyof IDatabaseClientRecord;
+
+export type TypeEventClientNameRealResult = keyof IDatabaseClientRecord;
+
+@Event()
+export class EventClientNameReal extends BeanEventBase<TypeEventClientNameRealData, TypeEventClientNameRealResult> {}

package/src/bean/event.columnsClear.ts

@@ -0,0 +1,13 @@
+import { BeanEventBase, Event } from 'vona-module-a-event';
+
+import type { IDatabaseClientRecord } from '../types/database.ts';
+
+export interface TypeEventColumnsClearData {
+  clientName: keyof IDatabaseClientRecord;
+  tableName?: string;
+}
+
+export type TypeEventColumnsClearResult = void;
+
+@Event()
+export class EventColumnsClear extends BeanEventBase<TypeEventColumnsClearData, TypeEventColumnsClearResult> {}

package/src/bean/hmr.entity.ts

@@ -0,0 +1,12 @@
+import type { IDecoratorBeanOptionsBase } from 'vona';
+import type { IHmrReload } from 'vona-module-a-hmr';
+
+import { BeanBase } from 'vona';
+import { Hmr } from 'vona-module-a-hmrbase';
+
+@Hmr()
+export class HmrEntity extends BeanBase implements IHmrReload {
+  async reload(_beanOptions: IDecoratorBeanOptionsBase) {
+    this.app.bean.worker.reload();
+  }
+}

package/src/bean/hmr.model.ts

@@ -0,0 +1,16 @@
+import type { IDecoratorBeanOptionsBase } from 'vona';
+import type { IHmrReload } from 'vona-module-a-hmr';
+
+import { BeanBase } from 'vona';
+import { Hmr } from 'vona-module-a-hmrbase';
+// import { clearAllCacheModelsClear, clearCacheModelCacheInstance } from '../lib/const.ts';
+
+@Hmr()
+export class HmrModel extends BeanBase implements IHmrReload {
+  async reload(_beanOptions: IDecoratorBeanOptionsBase) {
+    // more deps: dto/model
+    this.app.bean.worker.reload();
+    // clearAllCacheModelsClear(this.app);
+    // await clearCacheModelCacheInstance(this.app, beanOptions.beanFullName);
+  }
+}

package/src/bean/queue.doubleDelete.ts

@@ -0,0 +1,29 @@
+import type { IQueueExecute, IQueuePushOptions } from 'vona-module-a-queue';
+
+import { BeanQueueBase, Queue } from 'vona-module-a-queue';
+
+import type { IDatabaseClientRecord } from '../types/database.ts';
+import type { ITableRecord } from '../types/onion/table.ts';
+
+export interface TypeQueueDoubleDeleteJobData {
+  beanFullName: string;
+  clientName: keyof IDatabaseClientRecord;
+  table?: keyof ITableRecord;
+  method: 'cacheEntityDelInner' | 'cacheEntityClearInner' | 'cacheQueryClearInner';
+  args: any[];
+}
+
+export type TypeQueueDoubleDeleteJobResult = void;
+
+@Queue({
+  options: { job: { delay: 3 * 1000 } },
+})
+export class QueueDoubleDelete
+  extends BeanQueueBase<TypeQueueDoubleDeleteJobData, TypeQueueDoubleDeleteJobResult>
+  implements IQueueExecute<TypeQueueDoubleDeleteJobData, TypeQueueDoubleDeleteJobResult>
+{
+  async execute(data: TypeQueueDoubleDeleteJobData, _options?: IQueuePushOptions): Promise<TypeQueueDoubleDeleteJobResult> {
+    const beanInstance = this.app.bean._newBean(data.beanFullName as any, data.clientName, data.table);
+    await beanInstance[data.method](...data.args);
+  }
+}

package/src/bean/schedule.softDeletionPrune.ts

@@ -0,0 +1,45 @@
+import type { IOnionSlice } from 'vona-module-a-onion';
+import type { IScheduleExecute } from 'vona-module-a-schedule';
+
+import { BeanBase } from 'vona';
+import { Schedule } from 'vona-module-a-schedule';
+
+import type { IModelRecord, ISoftDeletionPrune } from '../types/onion/model.ts';
+import type { BeanModelCache } from './bean.model/bean.model_cache.ts';
+
+@Schedule({ repeat: { every: 24 * 3600 * 1000 } })
+export class ScheduleSoftDeletionPrune extends BeanBase implements IScheduleExecute {
+  async execute() {
+    const onionSlices = this.bean.onion.model.getOnionsEnabledCached();
+    for (const onionSlice of onionSlices) {
+      if (onionSlice.beanOptions.options?.disableDeleted) continue;
+      let softDeletionPrune = onionSlice.beanOptions.options?.softDeletionPrune ?? this.scope.config.softDeletionPrune.enable;
+      if (!softDeletionPrune) continue;
+      if (softDeletionPrune === true) softDeletionPrune = {};
+      await this._modulePrune(onionSlice, softDeletionPrune);
+    }
+  }
+
+  private async _modulePrune<MODULE extends BeanModelCache, T extends keyof IModelRecord>(
+    onionSlice: IOnionSlice<IModelRecord, T, unknown>,
+    softDeletionPrune: ISoftDeletionPrune,
+  ) {
+    const handler = softDeletionPrune.handler;
+    const expired = softDeletionPrune.expired ?? this.scope.config.softDeletionPrune.expired;
+    const modelTarget = this.bean._getBean<MODULE>(onionSlice.beanOptions.beanFullName as any);
+    if (handler) {
+      await handler(this.ctx, modelTarget, { expired });
+    } else {
+      const expiredTime = new Date(Date.now() - expired);
+      await modelTarget.delete(
+        {
+          deleted: true,
+          updatedAt: {
+            _lt_: expiredTime,
+          },
+        } as any,
+        { disableDeleted: true },
+      );
+    }
+  }
+}