vona-module-a-orm 5.0.96 → 5.1.2

package/src/types/entityBaseInner.ts

@@ -0,0 +1,18 @@
+import { Api, v } from 'vona-module-a-openapiutils';
+
+import { $locale } from '../.metadata/locales.ts';
+import { EntityBaseEmpty } from './entityBaseEmpty.ts';
+
+export class EntityBaseInner extends EntityBaseEmpty {
+  @Api.field(v.title($locale('CreatedAt')), v.order(-2, 'max'), v.filterDateRange(), v.component('date'))
+  createdAt: Date;
+
+  @Api.field(v.title($locale('UpdatedAt')), v.order(-1, 'max'), v.filterDateRange(), v.component('date'))
+  updatedAt: Date;
+
+  @Api.field(v.title($locale('Deleted')), v.visible(false), v.default(false))
+  deleted: boolean;
+
+  @Api.field(v.title($locale('InstanceId')), v.visible(false), v.default(0))
+  iid: number;
+}

package/src/types/entityBaseSimple.ts

@@ -0,0 +1,9 @@
+import { Api, v } from 'vona-module-a-openapiutils';
+
+import { $locale } from '../.metadata/locales.ts';
+import { EntityBaseInner } from './entityBaseInner.ts';
+
+export class EntityBaseSimple extends EntityBaseInner {
+  @Api.field(v.order(1, 'core'), v.title($locale('TableIdentity')))
+  id: number;
+}

package/src/types/extra.ts

@@ -0,0 +1,23 @@
+import type { ScopeModuleAOrm } from '../.metadata/index.ts';
+
+declare module 'vona-module-a-orm' {
+  export interface ServiceDb {
+    /** @internal */
+    get scope(): ScopeModuleAOrm;
+  }
+
+  export interface ServiceDatabaseClient {
+    /** @internal */
+    get scope(): ScopeModuleAOrm;
+  }
+
+  export interface ServiceColumns {
+    /** @internal */
+    get scope(): ScopeModuleAOrm;
+  }
+
+  export interface ServiceColumnsCache {
+    /** @internal */
+    get scope(): ScopeModuleAOrm;
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,30 @@
+export * from './columns.ts';
+export * from './config.ts';
+export * from './database.ts';
+export * from './dialect.ts';
+export * from './dto/index.ts';
+export * from './entity.ts';
+export * from './entityBase.ts';
+export * from './entityBaseEmpty.ts';
+export * from './entityBaseInner.ts';
+export * from './entityBaseSimple.ts';
+export * from './extra.ts';
+export * from './logger.ts';
+export * from './model.ts';
+export * from './modelAggr.ts';
+export * from './modelCount.ts';
+export * from './modelGeneral.ts';
+export * from './modelGroup.ts';
+export * from './modelIncrement.ts';
+export * from './modelWhere.ts';
+export * from './onion/index.ts';
+export * from './relations.ts';
+export * from './relationsAggr.ts';
+export * from './relationsColumns.ts';
+export * from './relationsDef.ts';
+export * from './relationsDefDynamic.ts';
+export * from './relationsDefMutate.ts';
+export * from './relationsGroup.ts';
+export * from './relationsMutate.ts';
+export * from './relationsTables.ts';
+export * from './transaction.ts';

package/src/types/logger.ts

@@ -0,0 +1,6 @@
+declare module 'vona' {
+  export interface ILoggerChildRecord {
+    database: never;
+    model: never;
+  }
+}

package/src/types/model.ts

@@ -0,0 +1,152 @@
+import type { Knex } from 'knex';
+import type { TSummerCacheActionOptions } from 'vona-module-a-summer';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { TypeModelColumn, TypeModelColumns, TypeModelColumnsPatch, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelOfModelLike, TypeModelParamsInclude, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeModelMutateParamsInclude } from './relationsMutate.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+export type TypeModelCacheType = 'query' | 'entity';
+
+// join
+export type IModelSelectParamsJoinType =
+  | 'join'
+  | 'innerJoin'
+  | 'leftJoin'
+  | 'leftOuterJoin'
+  | 'rightJoin'
+  | 'rightOuterJoin'
+  | 'fullOuterJoin'
+  | 'crossJoin';
+// export interface IModelSelectParamsJoinOnMap { [key: string]: string | number | boolean | Knex.Raw<any> }
+export type IModelSelectParamsJoin<TRecord, TableNames = undefined, ColumnNames = keyof TRecord> = [
+  IModelSelectParamsJoinType,
+  TableNames,
+  [ColumnNames, ColumnNames] | Knex.JoinCallback,
+];
+
+// order
+export type IModelSelectParamsOrderDirection = 'asc' | 'desc';
+export type IModelSelectParamsOrderNulls = 'first' | 'last';
+export type IModelSelectParamsOrder<ColumnNames> = [ColumnNames, IModelSelectParamsOrderDirection?, IModelSelectParamsOrderNulls?];
+
+export interface IBuildModelSelectParams<
+  TRecord,
+  Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+>
+  extends IModelRelationIncludeWrapper<Model>, IBuildModelSelectParamsBasic<TRecord, TypeModelColumn<TRecord>, TableNames, ColumnNames, Columns> {}
+
+export interface IBuildModelSelectParamsBasic<
+  TRecord,
+  COLUMNS extends TypeModelColumn<TRecord> = TypeModelColumn<TRecord>,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> {
+  distinct?: boolean | keyof TRecord | (keyof TRecord)[];
+  columns?: TypeModelColumnsPatch<TRecord, COLUMNS>;
+  where?: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+  orders?: IModelSelectParamsOrder<ColumnNames>[];
+  limit?: number;
+  offset?: number;
+}
+
+export type IQueryParams<
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IModelSelectParams<TypeModelOfModelLike<Model>[TypeSymbolKeyEntity], Model, ModelJoins>;
+
+export type IModelSelectParams<
+  TRecord,
+  // not use undefined as default value
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IBuildModelSelectParams<
+  TRecord,
+  Model,
+  TypeEntityTableNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, Model>
+>;
+
+export interface IBuildModelCountParams<
+  TRecord,
+  _Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> {
+  distinct?: boolean | keyof TRecord | (keyof TRecord)[];
+  column?: TypeModelColumn<TRecord>;
+  where?: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+}
+
+export type IModelCountParams<
+  TRecord,
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IBuildModelCountParams<
+  TRecord,
+  Model,
+  TypeEntityTableNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, Model>
+>;
+
+export type IModelMethodOptions = IModelMethodOptionsGeneral;
+export type IModelInsertOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelInsertOptionsGeneral<TRecord, Model>;
+export type IModelUpdateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelUpdateOptionsGeneral<TRecord, Model>;
+export type IModelDeleteOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelDeleteOptionsGeneral<TRecord, Model>;
+export type IModelGetOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelGetOptionsGeneral<TRecord, Model>;
+export type IModelMutateOptions<TRecord, Model extends BeanModelMeta | undefined = undefined> = IModelMutateOptionsGeneral<TRecord, Model>;
+
+export interface IModelMethodOptionsGeneral {
+  disableDeleted?: boolean;
+  disableCreateTime?: boolean;
+  disableUpdateTime?: boolean;
+  disableCacheQuery?: boolean;
+  disableCacheEntity?: boolean;
+  deleted?: boolean;
+  cache?: TSummerCacheActionOptions<unknown, unknown>;
+}
+
+export interface IModelInsertOptionsGeneral<_TRecord, Model extends BeanModelMeta | undefined = undefined>
+  extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {}
+
+export interface IModelUpdateOptionsGeneral<TRecord, Model extends BeanModelMeta | undefined = undefined>
+  extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {
+  where?: TypeModelWhere<TRecord>;
+}
+
+export interface IModelDeleteOptionsGeneral<_TRecord, Model extends BeanModelMeta | undefined = undefined>
+  extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {}
+
+export interface IModelGetOptionsGeneral<TRecord, Model extends BeanModelMeta | undefined = undefined>
+  extends IModelMethodOptionsGeneral, IModelRelationIncludeWrapper<Model> {
+  columns?: TypeModelColumns<TRecord>;
+}
+
+export interface IModelMutateOptionsGeneral<_TRecord, Model extends BeanModelMeta | undefined = undefined>
+  extends IModelMethodOptionsGeneral, IModelMutateRelationIncludeWrapper<Model> {}
+
+export interface IModelSelectParamsPage {
+  index?: number;
+  size?: number;
+}
+
+export interface IModelRelationIncludeWrapper<Model extends BeanModelMeta | undefined = undefined> {
+  include?: TypeModelParamsInclude<Model>;
+  with?: Record<string, unknown>;
+}
+
+export interface IModelMutateRelationIncludeWrapper<Model extends BeanModelMeta | undefined = undefined> {
+  include?: TypeModelMutateParamsInclude<Model>;
+  with?: Record<string, unknown>;
+}

package/src/types/modelAggr.ts

@@ -0,0 +1,69 @@
+import type { OmitNever } from 'vona';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelSelectParamsJoin } from './model.ts';
+import type { TypeModelColumns, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+// export interface TypeModelSelectAggrParamsAggrs<TRecord> {
+//   count?: TypeModelColumns<TRecord>;
+//   sum?: TypeModelColumnsStrict<TRecord>;
+//   avg?: TypeModelColumnsStrict<TRecord>;
+//   max?: TypeModelColumnsStrict<TRecord>;
+//   min?: TypeModelColumnsStrict<TRecord>;
+// }
+
+export interface TypeModelSelectAggrParamsAggrs<TRecord> {
+  count?: TypeModelColumns<TRecord>;
+  sum?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+  avg?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+  max?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+  min?: TypeEntityTableColumnNamesForAggrs<TRecord> | Array<TypeEntityTableColumnNamesForAggrs<TRecord>>;
+}
+
+export type TypeEntityTableColumnNamesForAggrs<Entity> = keyof TypeEntityTableColumnsForAggrs<Entity>;
+
+export type TypeEntityTableColumnsForAggrs<Entity> = OmitNever<
+  Omit<
+    {
+      [K in keyof Entity as Entity[K] extends number | undefined ? K : never]: Entity[K];
+    },
+    'id' | 'iid'
+  >
+>;
+
+export interface IBuildModelSelectAggrParams<
+  TRecord,
+  Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> extends IBuildModelSelectAggrParamsBasic<TRecord, Model, TableNames, ColumnNames, Columns> {}
+
+export interface IBuildModelSelectAggrParamsBasic<
+  TRecord,
+  _Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> {
+  distinct?: boolean | keyof TRecord | (keyof TRecord)[];
+  aggrs: TypeModelSelectAggrParamsAggrs<TRecord>;
+  where?: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+}
+
+export type IModelSelectAggrParams<
+  TRecord,
+  // not use undefined as default value
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IBuildModelSelectAggrParams<
+  TRecord,
+  Model,
+  TypeEntityTableNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, Model>
+>;

package/src/types/modelCount.ts

@@ -0,0 +1,40 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelSelectParamsJoin } from './model.ts';
+import type { TypeModelColumn, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+export interface IBuildModelSelectCountParams<
+  TRecord,
+  Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> extends IBuildModelSelectCountParamsBasic<TRecord, Model, TableNames, ColumnNames, Columns> {}
+
+export interface IBuildModelSelectCountParamsBasic<
+  TRecord,
+  _Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> {
+  distinct?: boolean | keyof TRecord | (keyof TRecord)[];
+  column?: TypeModelColumn<TRecord>;
+  where?: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+}
+
+export type IModelSelectCountParams<
+  TRecord,
+  // not use undefined as default value
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IBuildModelSelectCountParams<
+  TRecord,
+  Model,
+  TypeEntityTableNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, Model>
+>;

package/src/types/modelGeneral.ts

@@ -0,0 +1,61 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper, IModelSelectParamsJoin, IModelSelectParamsOrder } from './model.ts';
+import type { TypeModelSelectAggrParamsAggrs } from './modelAggr.ts';
+import type { TypeModelColumn, TypeModelColumnsPatch, TypeModelColumnsStrict, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeModelSelectGroupParamsColumnNames, TypeModelSelectGroupParamsColumns } from './relationsGroup.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+export interface IBuildModelSelectGeneralParams<
+  TRecord,
+  Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+>
+  extends
+    IModelRelationIncludeWrapper<Model>,
+    IBuildModelSelectGeneralParamsBasic<TRecord, TypeModelColumn<TRecord>, TableNames, ColumnNames, Columns> {}
+
+export interface IBuildModelSelectGeneralParamsBasic<
+  TRecord,
+  TColumn extends TypeModelColumn<TRecord> | undefined = TypeModelColumn<TRecord>,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> | undefined = undefined,
+  Groups extends TypeModelColumnsStrict<TRecord> | undefined = undefined,
+> {
+  distinct?: boolean | keyof TRecord | (keyof TRecord)[];
+  columns?: Groups extends TypeModelColumnsStrict<TRecord>
+    ? TColumn extends string
+      ? TColumn | Array<TColumn>
+      : TColumn
+    : TypeModelColumnsPatch<TRecord, TColumn>;
+  aggrs?: Aggrs;
+  groups?: Groups;
+  having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord, Groups, Aggrs>>;
+  where?: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+  orders?: Groups extends TypeModelColumnsStrict<TRecord>
+    ? IModelSelectParamsOrder<TypeModelSelectGroupParamsColumnNames<TRecord, Groups, Aggrs>>[]
+    : Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord>
+      ? never
+      : IModelSelectParamsOrder<ColumnNames>[];
+  limit?: number;
+  offset?: number;
+}
+
+export type IModelSelectGeneralParams<
+  TRecord,
+  // not use undefined as default value
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IBuildModelSelectGeneralParams<
+  TRecord,
+  Model,
+  TypeEntityTableNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, Model>
+>;

package/src/types/modelGroup.ts

@@ -0,0 +1,48 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelSelectParamsJoin, IModelSelectParamsOrder } from './model.ts';
+import type { TypeModelSelectAggrParamsAggrs } from './modelAggr.ts';
+import type { TypeModelColumnsStrict, TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeModelSelectGroupParamsColumnNames, TypeModelSelectGroupParamsColumns } from './relationsGroup.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+export interface IBuildModelSelectGroupParams<
+  TRecord,
+  Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> extends IBuildModelSelectGroupParamsBasic<TRecord, Model, TableNames, ColumnNames, Columns> {}
+
+export interface IBuildModelSelectGroupParamsBasic<
+  TRecord,
+  _Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> {
+  distinct?: boolean | keyof TRecord | (keyof TRecord)[];
+  aggrs?: TypeModelSelectAggrParamsAggrs<TRecord>;
+  groups: TypeModelColumnsStrict<TRecord>;
+  columns?: TypeModelColumnsStrict<TRecord>;
+  where?: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+  having?: TypeModelWhere<TRecord, TypeModelSelectGroupParamsColumns<TRecord>>;
+  orders?: IModelSelectParamsOrder<TypeModelSelectGroupParamsColumnNames<TRecord>>[];
+  limit?: number;
+  offset?: number;
+}
+
+export type IModelSelectGroupParams<
+  TRecord,
+  // not use undefined as default value
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IBuildModelSelectGroupParams<
+  TRecord,
+  Model,
+  TypeEntityTableNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, Model>
+>;

package/src/types/modelIncrement.ts

@@ -0,0 +1,50 @@
+import type { OmitNever } from 'vona';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelSelectParamsJoin } from './model.ts';
+import type { TypeModelWhere } from './modelWhere.ts';
+import type { TypeModelsClassLikeGeneral } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+export type TypeModelIncrementParamsColumns<Entity> = OmitNever<
+  Omit<
+    {
+      [K in keyof Entity as Entity[K] extends number | undefined ? K : never]?: number;
+    },
+    'id' | 'iid'
+  >
+>;
+
+export interface IBuildModelIncrementParams<
+  TRecord,
+  Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> extends IBuildModelIncrementParamsBasic<TRecord, Model, TableNames, ColumnNames, Columns> {}
+
+export interface IBuildModelIncrementParamsBasic<
+  TRecord,
+  _Model extends BeanModelMeta | undefined = undefined,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+> {
+  columns: TypeModelIncrementParamsColumns<TRecord>;
+  where: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+}
+
+export type IModelIncrementParams<
+  TRecord,
+  // not use undefined as default value
+  Model extends BeanModelMeta = BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+> = IBuildModelIncrementParams<
+  TRecord,
+  Model,
+  TypeEntityTableNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, Model>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, Model>
+>;

package/src/types/modelWhere.ts

@@ -0,0 +1,85 @@
+import type { TypeRecordValues } from 'vona';
+
+export const OpAggrs = ['count', 'sum', 'avg', 'max', 'min'];
+
+export const OpJoint = {
+  and: '_and_',
+  or: '_or_',
+  not: '_not_',
+  exists: '_exists_',
+  notExists: '_notExists_',
+} as const;
+export const OpNormal = {
+  eq: '_eq_',
+  notEq: '_notEq_',
+  eqI: '_eqI_',
+  notEqI: '_notEqI_',
+  gt: '_gt_',
+  gte: '_gte_',
+  lt: '_lt_',
+  lte: '_lte_',
+  in: '_in_',
+  notIn: '_notIn_',
+  is: '_is_',
+  isNot: '_isNot_',
+  between: '_between_',
+  notBetween: '_notBetween_',
+  startsWith: '_startsWith_',
+  endsWith: '_endsWith_',
+  includes: '_includes_',
+  startsWithI: '_startsWithI_',
+  endsWithI: '_endsWithI_',
+  includesI: '_includesI_',
+  ref: '_ref_',
+} as const;
+export const Op = {
+  skip: '_skip_',
+  ...OpJoint,
+  ...OpNormal,
+} as const;
+export const OpJointValues = Object.values(OpJoint);
+export const OpNormalValues = Object.values(OpNormal);
+export const OpValues = Object.values(Op);
+
+export type TypeOpsJointPostfix<Op> = {
+  [KEY in keyof Op]: Op[KEY] | (KEY extends string ? `_${KEY}_${number}` : never);
+};
+
+// not use TypeOpsJointPostfix, which cause type not take affect for table.field
+// export type TypeOpsJoint = TypeRecordValues<TypeOpsJointPostfix<Pick<typeof Op, 'and' | 'or' | 'not' | 'exists' | 'notExists'>>>;
+export type TypeOpsJoint = TypeRecordValues<typeof OpJoint>;
+export type TypeOpsNormal = TypeRecordValues<typeof OpNormal>;
+export type TypeOpsAll = TypeRecordValues<typeof Op>;
+
+// not use Knex.Raw
+export type TypeModelColumnValue<TRecord, Column> = keyof TRecord | Column | Column[] | null | '_skip_';
+
+export type TypeModelWhere<TRecord, Columns extends {} | undefined = undefined> = Columns extends {}
+  ? TypeModelWhereInner<Columns>
+  : TypeModelWhereInner<TRecord>;
+// not use Knex.Raw
+// Columns extends {} ? TypeModelWhereInner<Columns> | Knex.Raw : TypeModelWhereInner<TRecord> | Knex.Raw;
+
+export type TypeModelWhereInner<TRecord> = {
+  [prop in keyof TRecord]?: TypeModelColumnValue<TRecord, TRecord[prop]> | TypeModelWhereFieldAll<TRecord, TRecord[prop]>;
+} & {
+  [key in TypeOpsJoint]?: TypeModelWhereInner<TRecord>;
+};
+
+export type TypeModelWhereFieldAll<TRecord, Column> = {
+  [key in TypeOpsJoint]?: TypeModelWhereFieldAll<TRecord, Column>;
+} & {
+  [key in TypeOpsNormal]?: TypeModelColumnValue<TRecord, Column>;
+};
+
+export type TypeModelWhereFieldJoint<TRecord, Column> = {
+  [key in TypeOpsJoint]?: TypeModelWhereFieldAll<TRecord, Column>;
+};
+
+export type TypeModelColumn<TRecord> = keyof TRecord | '*';
+export type TypeModelColumns<TRecord> = TypeModelColumn<TRecord> | Array<TypeModelColumn<TRecord>>;
+export type TypeModelColumnPatch<TRecord, TColumn> = TColumn extends '*' ? TypeModelColumn<TRecord> : TColumn;
+export type TypeModelColumnsPatch<TRecord, TColumn> = [TColumn] extends [string]
+  ? TypeModelColumnPatch<TRecord, TColumn> | Array<TypeModelColumnPatch<TRecord, TColumn>>
+  : TColumn;
+export type TypeModelColumnsStrict<TRecord> = keyof TRecord | Array<keyof TRecord>;

package/src/types/onion/databaseDialect.ts

@@ -0,0 +1,22 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+
+export interface IDatabaseDialectRecord {}
+
+export interface IDecoratorDatabaseDialectOptions {}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    databaseDialect: ServiceOnion<IDatabaseDialectRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    databaseDialect: OmitNever<IDatabaseDialectRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    databaseDialect: never;
+  }
+}

package/src/types/onion/entity.ts

@@ -0,0 +1,33 @@
+import type { OmitNever } from 'vona';
+import type { ServiceOnion } from 'vona-module-a-onion';
+import type { TypeOpenapiMetadata } from 'vona-module-a-openapi';
+import type { SchemaLike } from 'vona-module-a-openapiutils';
+
+import type { SymbolKeyFieldsMore } from '../entity.ts';
+import type { ITableRecord } from './table.ts';
+
+export interface IEntityRecord {}
+
+export interface IDecoratorEntityOptions<FieldsMore = never> {
+  [SymbolKeyFieldsMore]?: FieldsMore;
+  table?: keyof ITableRecord;
+  independent?: boolean;
+  openapi?: TypeOpenapiMetadata;
+  pipes?: SchemaLike | SchemaLike[];
+}
+
+declare module 'vona-module-a-onion' {
+  export interface BeanOnion {
+    entity: ServiceOnion<IEntityRecord>;
+  }
+}
+
+declare module 'vona' {
+  export interface ConfigOnions {
+    entity: OmitNever<IEntityRecord>;
+  }
+
+  export interface IBeanSceneRecord {
+    entity: never;
+  }
+}

package/src/types/onion/index.ts

@@ -0,0 +1,4 @@
+export * from './databaseDialect.ts';
+export * from './entity.ts';
+export * from './model.ts';
+export * from './table.ts';