vona-module-a-orm 5.0.96 → 5.1.2

package/src/lib/modelCacheBase.ts

@@ -0,0 +1,98 @@
+import type { BeanSummerCacheBase, IDecoratorSummerCacheOptions } from 'vona-module-a-summer';
+
+import { BeanBase, deepExtend } from 'vona';
+
+import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
+import type { TypeModelCacheType } from '../types/model.ts';
+import type { ITableRecord } from '../types/onion/table.ts';
+
+import { getCacheModelCacheInstances } from './const.ts';
+
+const SymbolCacheOptions = Symbol('SymbolCacheOptions');
+const SymbolCacheEnabled = Symbol('SymbolCacheEnabled');
+
+export class ModelCacheBase extends BeanBase {
+  private [SymbolCacheOptions]: IDecoratorSummerCacheOptions | false;
+  protected _model: BeanModelCache;
+  private _cacheType: TypeModelCacheType;
+
+  protected __init__(model: BeanModelCache, cacheType: TypeModelCacheType) {
+    this._model = model;
+    this._cacheType = cacheType;
+  }
+
+  private get scopeOrm() {
+    return this.$scope.orm;
+  }
+
+  public getInstance(table: keyof ITableRecord): BeanSummerCacheBase {
+    if (this.options === false) throw new Error('cache disabled');
+    const beanFullName = this._model.$beanFullName;
+    const cacheName = this.getName(table);
+    const cacheModelCacheInstances = getCacheModelCacheInstances(this.app);
+    if (!cacheModelCacheInstances[beanFullName]) cacheModelCacheInstances[beanFullName] = {};
+    if (!cacheModelCacheInstances[beanFullName][cacheName]) {
+      cacheModelCacheInstances[beanFullName][cacheName] = this.app.bean.summer.cache<any, any>(cacheName, this.options);
+    }
+    return cacheModelCacheInstances[beanFullName][cacheName];
+  }
+
+  public getName(table: keyof ITableRecord) {
+    const clientNameReal = this.$scope.orm.service.database.prepareClientNameReal(this._model.db.clientName);
+    return `${this._model.$beanFullName}:${clientNameReal}:${table}:${this._cacheType}`;
+  }
+
+  public get options() {
+    if (this[SymbolCacheOptions] === undefined) {
+      this[SymbolCacheOptions] = this._getCacheOptionsInner();
+    }
+    return this[SymbolCacheOptions];
+  }
+
+  public get enabled() {
+    if (this[SymbolCacheEnabled] === undefined) {
+      this[SymbolCacheEnabled] = this._getCacheEnabledInner();
+    }
+    return this[SymbolCacheEnabled];
+  }
+
+  private _getCacheEnabledInner() {
+    if (this.options === false) return false;
+    // enable
+    if (!this.bean.onion.checkOnionOptionsEnabled(this.options)) return false;
+    // default
+    return true;
+  }
+
+  private _getCacheOptionsInner() {
+    if (this._model.options.cache?.[this._cacheType] === false) return false;
+    // options
+    let _cacheOptions = (this._model.options.cache?.[this._cacheType] ?? {}) as IDecoratorSummerCacheOptions;
+    // preset
+    let configPreset;
+    let preset = _cacheOptions.preset;
+    if (!preset && !_cacheOptions.mode) preset = this.scopeOrm.config.summer.presetDefault;
+    if (preset) {
+      configPreset = this.scopeOrm.config.summer.preset[preset];
+    }
+    // extend
+    _cacheOptions = deepExtend(
+      {
+        enable: this.scopeOrm.config.summer.enable,
+        meta: this.scopeOrm.config.summer.meta,
+        mem: {
+          disableInstance: this._model.disableInstance,
+        },
+        redis: {
+          disableInstance: this._model.disableInstance,
+          client: this.scopeOrm.config.summer.redis.client,
+        },
+      },
+      configPreset,
+      _cacheOptions,
+      { preset: undefined },
+    );
+    // ok
+    return _cacheOptions;
+  }
+}

package/src/lib/relations.ts

@@ -0,0 +1,118 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelClassRecord } from '../types/onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from '../types/relations.ts';
+import type { IModelRelationOptionsManyStatic, IModelRelationOptionsOneStatic } from './relationsStatic.ts';
+
+function hasOne<MODEL extends BeanModelMeta | keyof IModelClassRecord, OPTIONS extends IModelRelationOptionsOneStatic<TypeModelOfModelLike<MODEL>>>(
+  classModel: TypeModelClassLike<MODEL>,
+  key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  options?: OPTIONS,
+): any {
+  // :  IModelRelationHasOne<MODEL, AUTOLOAD, COLUMNS> {
+  return { type: 'hasOne', model: classModel, key, options };
+}
+
+function belongsTo<
+  MODELSelf extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  OPTIONS extends IModelRelationOptionsOneStatic<TypeModelOfModelLike<MODEL>>,
+>(
+  _classModelSelf: TypeModelClassLike<MODELSelf>,
+  classModel: TypeModelClassLike<MODEL>,
+  key: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity],
+  options?: OPTIONS,
+): any {
+  // : IModelRelationBelongsTo<MODELSelf, MODEL, AUTOLOAD, COLUMNS> {
+  return { type: 'belongsTo', model: classModel, key, options };
+}
+
+function hasMany<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  OPTIONS extends IModelRelationOptionsManyStatic<TypeModelOfModelLike<MODEL>, ModelJoins, Group>,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+>(
+  classModel: TypeModelClassLike<MODEL>,
+  key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  options?: OPTIONS,
+  _modelJoins?: ModelJoins,
+  _group?: Group,
+): any {
+  // : IModelRelationHasMany<MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+  return { type: 'hasMany', model: classModel, key, options };
+}
+
+function belongsToMany<
+  MODELMiddle extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  OPTIONS extends IModelRelationOptionsManyStatic<TypeModelOfModelLike<MODEL>, ModelJoins, Group>,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+>(
+  classModelMiddle: TypeModelClassLike<MODELMiddle>,
+  classModel: TypeModelClassLike<MODEL>,
+  keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+  keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+  options?: OPTIONS,
+  _modelJoins?: ModelJoins,
+  _group?: Group,
+): any {
+  // : IModelRelationBelongsToMany<MODELMiddle, MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+  return { type: 'belongsToMany', modelMiddle: classModelMiddle, model: classModel, keyFrom, keyTo, options };
+}
+
+export const $relation = {
+  hasOne,
+  belongsTo,
+  hasMany,
+  belongsToMany,
+};
+
+// function hasMany<
+//   MODEL extends BeanModelMeta | (keyof IModelClassRecord),
+//   AUTOLOAD extends boolean = boolean,
+//   COLUMNS
+//   extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+//   Aggrs extends TypeModelSelectAggrParamsAggrs<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   Groups extends TypeModelColumnsStrict<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+// >(
+//   classModel: TypeModelClassLike<MODEL>,
+//   key: keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+//   options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>,
+//   _modelJoins?: ModelJoins,
+//   _aggrs?: Aggrs,
+//   _groups?: Groups,
+// ): any { // : IModelRelationHasMany<MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+//   return { type: 'hasMany', model: classModel, key, options };
+// }
+
+// function belongsToMany<
+//   MODELMiddle extends BeanModelMeta | (keyof IModelClassRecord),
+//   MODEL extends BeanModelMeta | (keyof IModelClassRecord),
+//   AUTOLOAD extends boolean = boolean,
+//   COLUMNS
+//   extends TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]> = TypeModelColumn<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+//   Aggrs extends TypeModelSelectAggrParamsAggrs<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+//   Groups extends TypeModelColumnsStrict<
+//     TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]
+//   > | undefined = undefined, // TypeModelColumnsStrict<TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity]>,
+// >(
+//   classModelMiddle: TypeModelClassLike<MODELMiddle>,
+//   classModel: TypeModelClassLike<MODEL>,
+//   keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+//   keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+//   options?: IModelRelationOptionsMany<TypeModelOfModelLike<MODEL>, AUTOLOAD, COLUMNS, ModelJoins, Aggrs, Groups>,
+//   _modelJoins?: ModelJoins,
+//   _aggrs?: Aggrs,
+//   _groups?: Groups,
+// ): any { // : IModelRelationBelongsToMany<MODELMiddle, MODEL, AUTOLOAD, COLUMNS, ModelJoins> {
+//   return { type: 'belongsToMany', modelMiddle: classModelMiddle, model: classModel, keyFrom, keyTo, options };
+// }

package/src/lib/relationsDynamic.ts

@@ -0,0 +1,75 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelClassRecord } from '../types/onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from '../types/relations.ts';
+import type {
+  IModelRelationBelongsToDynamic,
+  IModelRelationBelongsToManyDynamic,
+  IModelRelationHasManyDynamic,
+  IModelRelationHasOneDynamic,
+  IModelRelationOptionsManyDynamic,
+  IModelRelationOptionsOneDynamic,
+} from '../types/relationsDefDynamic.ts';
+
+function hasOne<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined,
+>(classModel: TypeModelClassLike<MODEL>, key: KEY, options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, KEY, OPTIONS> {
+  return { type: 'hasOne', model: classModel, key, options };
+}
+
+function belongsTo<
+  MODELSelf extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined,
+>(
+  _classModelSelf: TypeModelClassLike<MODELSelf>,
+  classModel: TypeModelClassLike<MODEL>,
+  key: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity],
+  options?: OPTIONS,
+): IModelRelationBelongsToDynamic<MODELSelf, MODEL, OPTIONS> {
+  return { type: 'belongsTo', model: classModel, key, options };
+}
+
+function hasMany<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  // not use `| undefined = undefined` or `= {}`
+  OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+>(
+  classModel: TypeModelClassLike<MODEL>,
+  key: KEY,
+  options?: OPTIONS,
+  _modelJoins?: ModelJoins,
+  _group?: Group,
+): IModelRelationHasManyDynamic<MODEL, KEY, OPTIONS, ModelJoins, Group> {
+  return { type: 'hasMany', model: classModel, key, options };
+}
+
+function belongsToMany<
+  MODELMiddle extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  // not use `| undefined = undefined` or `= {}`
+  OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+>(
+  classModelMiddle: TypeModelClassLike<MODELMiddle>,
+  classModel: TypeModelClassLike<MODEL>,
+  keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+  keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+  options?: OPTIONS,
+  _modelJoins?: ModelJoins,
+  _group?: Group,
+): IModelRelationBelongsToManyDynamic<MODELMiddle, MODEL, OPTIONS, ModelJoins, Group> {
+  return { type: 'belongsToMany', modelMiddle: classModelMiddle, model: classModel, keyFrom, keyTo, options };
+}
+
+export const $relationDynamic = {
+  hasOne,
+  belongsTo,
+  hasMany,
+  belongsToMany,
+};

package/src/lib/relationsMutate.ts

@@ -0,0 +1,60 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelClassRecord } from '../types/onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeSymbolKeyEntity } from '../types/relations.ts';
+import type { IModelRelationBelongsToManyDynamic, IModelRelationHasManyDynamic, IModelRelationHasOneDynamic } from '../types/relationsDefDynamic.ts';
+import type {
+  IModelRelationOptionsBelongsToManyMutate,
+  IModelRelationOptionsManyMutate,
+  IModelRelationOptionsOneMutate,
+} from '../types/relationsDefMutate.ts';
+
+function hasOne<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  OPTIONS extends IModelRelationOptionsOneMutate<TypeModelOfModelLike<MODEL>>,
+>(classModel: TypeModelClassLike<MODEL>, key: KEY, options?: OPTIONS): IModelRelationHasOneDynamic<MODEL, KEY, OPTIONS> {
+  return { type: 'hasOne', model: classModel, key, options };
+}
+
+// function belongsTo<
+//   MODELSelf extends BeanModelMeta | (keyof IModelClassRecord),
+//   MODEL extends BeanModelMeta | (keyof IModelClassRecord),
+//   OPTIONS extends IModelRelationOptionsOneMutate<TypeModelOfModelLike<MODEL>>,
+// >(
+//   _classModelSelf: TypeModelClassLike<MODELSelf>,
+//   classModel: TypeModelClassLike<MODEL>,
+//   key: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity],
+//   options?: OPTIONS,
+// ): IModelRelationBelongsToDynamic<MODELSelf, MODEL, OPTIONS> {
+//   return { type: 'belongsTo', model: classModel, key, options };
+// }
+
+function hasMany<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  // not use `| undefined = undefined` or `= {}`
+  OPTIONS extends IModelRelationOptionsManyMutate<TypeModelOfModelLike<MODEL>>,
+>(classModel: TypeModelClassLike<MODEL>, key: KEY, options?: OPTIONS): IModelRelationHasManyDynamic<MODEL, KEY, OPTIONS> {
+  return { type: 'hasMany', model: classModel, key, options };
+}
+
+function belongsToMany<
+  MODELMiddle extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  OPTIONS extends IModelRelationOptionsBelongsToManyMutate<TypeModelOfModelLike<MODEL>>,
+>(
+  classModelMiddle: TypeModelClassLike<MODELMiddle>,
+  classModel: TypeModelClassLike<MODEL>,
+  keyFrom: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+  keyTo: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity],
+  options?: OPTIONS,
+): IModelRelationBelongsToManyDynamic<MODELMiddle, MODEL, OPTIONS> {
+  return { type: 'belongsToMany', modelMiddle: classModelMiddle, model: classModel, keyFrom, keyTo, options };
+}
+
+export const $relationMutate = {
+  hasOne,
+  // belongsTo,
+  hasMany,
+  belongsToMany,
+};

package/src/lib/relationsStatic.ts

@@ -0,0 +1,18 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { TypeModelsClassLikeGeneral } from '../types/relations.ts';
+import type { IModelRelationOptionsManyDynamic, IModelRelationOptionsOneDynamic } from '../types/relationsDefDynamic.ts';
+
+export interface IModelRelationOptionsManyStatic<
+  MODEL extends BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+> extends Omit<IModelRelationOptionsManyDynamic<MODEL, ModelJoins, Group>, 'include' | 'with'> {
+  autoload?: boolean;
+}
+
+export interface IModelRelationOptionsOneStatic<MODEL extends BeanModelMeta> extends Omit<
+  IModelRelationOptionsOneDynamic<MODEL>,
+  'include' | 'with'
+> {
+  autoload?: boolean;
+}

package/src/lib/utils.ts

@@ -0,0 +1,45 @@
+import { deepExtend } from 'vona';
+
+import type { IModelRelationIncludeWrapper } from '../types/model.ts';
+import type { IRelationItem } from '../types/relationsDef.ts';
+
+export function handleRelationsCollection(relationsStatic?: Record<string, any>, includeWrapper?: IModelRelationIncludeWrapper): IRelationItem[] {
+  // collect
+  const relations: IRelationItem[] = [];
+  // include
+  if (relationsStatic) {
+    for (const key in relationsStatic) {
+      const relationDef = relationsStatic[key];
+      const relationCur: any = includeWrapper?.include?.[key];
+      let relationReal;
+      let includeReal;
+      let withReal;
+      let autoload;
+      if (relationCur === false) {
+        continue;
+      } else if (relationCur === true) {
+        relationReal = relationDef;
+        autoload = relationDef.options?.autoload;
+      } else if (typeof relationCur === 'object') {
+        relationReal = deepExtend({}, relationDef, { options: relationCur });
+        includeReal = relationCur.include;
+        withReal = relationCur.with;
+      } else if (relationDef.options?.autoload) {
+        relationReal = relationDef;
+        autoload = relationDef.options?.autoload;
+      } else {
+        continue;
+      }
+      relations.push([key, relationReal, includeReal, withReal, autoload]);
+    }
+  }
+  // with
+  if (includeWrapper?.with) {
+    for (const key in includeWrapper.with) {
+      const relationReal: any = includeWrapper.with[key];
+      if (!relationReal) continue;
+      relations.push([key, relationReal, relationReal.options?.include, relationReal.options?.with, false]);
+    }
+  }
+  return relations;
+}

package/src/main.ts

@@ -0,0 +1,79 @@
+import type { FunctionAny, IModuleMain, PowerPartial, VonaApplication, VonaContext } from 'vona';
+
+import { BeanSimple, cast, combineConfigDefault, deepExtend } from 'vona';
+import { ServiceDatabaseAsyncLocalStorage, ServiceTransactionConsistency‌ } from 'vona-module-a-orm';
+
+import type { ConfigDatabase } from './types/config.ts';
+
+import { ExtendKnex } from './extend/index.ts';
+
+const SymbolTransactionConsistency = Symbol('SymbolTransactionConsistency');
+
+export class Main extends BeanSimple implements IModuleMain {
+  async moduleLoading() {
+    // config
+    const _configDefault = await combineConfigDefault<ConfigDatabase>(this.app, configDefault, configDev, configProd, configTest);
+    this.app.config.database = deepExtend({}, _configDefault, this.app.config.database);
+  }
+
+  async moduleLoaded() {
+    // ExtendKnex
+    ExtendKnex(this.app);
+    // db
+    Object.defineProperty(this.app.context, 'db', {
+      enumerable: false,
+      get(this: VonaContext) {
+        return this.app.bean._getBean(ServiceDatabaseAsyncLocalStorage).current;
+      },
+    });
+    // transactionConsistency
+    Object.defineProperty(this.app.context, 'transactionConsistency', {
+      enumerable: false,
+      get(this: VonaContext) {
+        if (!this[SymbolTransactionConsistency]) {
+          this[SymbolTransactionConsistency] = this.app.bean._newBean(ServiceTransactionConsistency‌);
+        }
+        return this[SymbolTransactionConsistency];
+      },
+    });
+    // commit
+    Object.defineProperty(this.app.context, 'commit', {
+      enumerable: false,
+      get() {
+        return function (this: VonaContext, cb: FunctionAny) {
+          if (this.ctxCaller) {
+            this.ctxCaller.commit(cb);
+          } else {
+            cast(this).transactionConsistency.commit(cb);
+          }
+        };
+      },
+    });
+    Object.defineProperty(this.app.context, 'commitsDone', {
+      enumerable: false,
+      get() {
+        return function (this: VonaContext) {
+          return cast(this).transactionConsistency.commitsDone();
+        };
+      },
+    });
+  }
+
+  async configLoaded(_config) {}
+}
+
+export async function configDefault(_app: VonaApplication): Promise<PowerPartial<ConfigDatabase>> {
+  return {};
+}
+
+async function configDev(_app: VonaApplication): Promise<PowerPartial<ConfigDatabase>> {
+  return {};
+}
+
+async function configProd(_app: VonaApplication): Promise<PowerPartial<ConfigDatabase>> {
+  return {};
+}
+
+async function configTest(_app: VonaApplication): Promise<PowerPartial<ConfigDatabase>> {
+  return {};
+}

package/src/service/cacheEntity_.ts

@@ -0,0 +1,37 @@
+import type { TableIdentity } from 'table-identity';
+
+import { Service } from 'vona-module-a-bean';
+
+import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
+import type { ITableRecord } from '../types/onion/table.ts';
+
+import { ModelCacheBase } from '../lib/modelCacheBase.ts';
+
+@Service()
+export class ServiceCacheEntity extends ModelCacheBase {
+  protected __init__(model: BeanModelCache) {
+    super.__init__(model, 'entity');
+  }
+
+  public async clear(table?: keyof ITableRecord) {
+    if (!this.enabled) return;
+    table = table || this._model.getTable(undefined);
+    const cache = this.getInstance(table);
+    await cache.clear();
+  }
+
+  public async del(id: TableIdentity | TableIdentity[], table?: keyof ITableRecord) {
+    if (!this.enabled) return;
+    table = table || this._model.getTable(undefined);
+    const cache = this.getInstance(table);
+    if (Array.isArray(id)) {
+      await cache.mdel(id);
+    } else {
+      await cache.del(id);
+    }
+  }
+
+  public get keysAux() {
+    return this._model.options.cache?.keysAux;
+  }
+}

package/src/service/cacheQuery_.ts

@@ -0,0 +1,20 @@
+import { Service } from 'vona-module-a-bean';
+
+import type { BeanModelCache } from '../bean/bean.model/bean.model_cache.ts';
+import type { ITableRecord } from '../types/onion/table.ts';
+
+import { ModelCacheBase } from '../lib/modelCacheBase.ts';
+
+@Service()
+export class ServiceCacheQuery extends ModelCacheBase {
+  protected __init__(model: BeanModelCache) {
+    super.__init__(model, 'query');
+  }
+
+  public async clear(table?: keyof ITableRecord) {
+    if (!this.enabled) return;
+    table = table || this._model.getTable(undefined);
+    const cache = this.getInstance(table);
+    await cache.clear();
+  }
+}

package/src/service/columnsCache_.ts

@@ -0,0 +1,69 @@
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { ITableColumns, ITableColumnsDefault } from '../types/columns.ts';
+import type { IDatabaseClientRecord } from '../types/database.ts';
+
+const SymbolColumnsCache = Symbol('SymbolColumnsCache');
+const SymbolColumnsDefaultCache = Symbol('SymbolColumnsDefaultCache');
+
+@Service()
+export class ServiceColumnsCache extends BeanBase {
+  clientName: keyof IDatabaseClientRecord;
+  protected [SymbolColumnsCache]: Record<string, ITableColumns> = {};
+  protected [SymbolColumnsDefaultCache]: Record<string, ITableColumnsDefault> = {};
+  private _onColumnsClearCancel?: Function;
+
+  /** real client name */
+  protected __init__(clientName: keyof IDatabaseClientRecord) {
+    this.clientName = clientName;
+    this._onColumnsClearCancel = this.scope.event.columnsClear.on(({ clientName, tableName }, next) => {
+      if (clientName === this.clientName) {
+        this.columnsClear(tableName);
+      }
+      next();
+    });
+  }
+
+  protected async __dispose__() {
+    this._onColumnsClearCancel?.();
+  }
+
+  getColumnsDefaultCache(table: string) {
+    return this[SymbolColumnsDefaultCache][table];
+  }
+
+  setColumnsDefaultCache(table: string, data: ITableColumnsDefault) {
+    this[SymbolColumnsDefaultCache][table] = data;
+  }
+
+  deleteColumnsDefaultCache(table: string) {
+    delete this[SymbolColumnsDefaultCache][table];
+  }
+
+  getColumnsCache(table: string) {
+    return this[SymbolColumnsCache][table];
+  }
+
+  setColumnsCache(table: string, columns: ITableColumns) {
+    this[SymbolColumnsCache][table] = columns;
+  }
+
+  deleteColumnsCache(table: string) {
+    delete this[SymbolColumnsCache][table];
+  }
+
+  columnsClear(tableName?: string) {
+    if (tableName) {
+      const exists = this.getColumnsCache(tableName);
+      this.deleteColumnsCache(tableName);
+      this.deleteColumnsDefaultCache(tableName);
+      return exists;
+    } else {
+      const exists = Object.keys(this[SymbolColumnsCache]).length > 0;
+      this[SymbolColumnsCache] = {};
+      this[SymbolColumnsDefaultCache] = {};
+      return exists;
+    }
+  }
+}