vona-module-a-orm 5.0.96 → 5.1.2

package/src/service/transaction_.ts

@@ -0,0 +1,147 @@
+import type knex from 'knex';
+import type { Knex } from 'knex';
+import type { FunctionAny, FunctionAsync } from 'vona';
+
+import { BeanBase } from 'vona';
+import { Service } from 'vona-module-a-bean';
+
+import type { ITransactionConsistencyCommitOptions, ITransactionOptions } from '../types/transaction.ts';
+import type { ServiceDb } from './db_.ts';
+import type { ServiceTransactionFiber } from './transactionFiber_.ts';
+
+import { TransactionIsolationLevelsMap } from '../types/transaction.ts';
+import { ServiceTransactionAsyncLocalStorage } from './transactionAsyncLocalStorage_.ts';
+
+@Service()
+export class ServiceTransaction extends BeanBase {
+  private _db: ServiceDb;
+
+  protected __init__(db: ServiceDb) {
+    this._db = db;
+  }
+
+  get transactionState() {
+    return this.bean._getBean(ServiceTransactionAsyncLocalStorage).transactionState;
+  }
+
+  get transactionFiber(): ServiceTransactionFiber | undefined {
+    return this.transactionState.get(this._db);
+  }
+
+  get inTransaction() {
+    return !!this.transactionFiber;
+  }
+
+  get connection(): knex.Knex.Transaction | undefined {
+    return this.transactionFiber?.connection;
+  }
+
+  async commit(cb: FunctionAny, options?: ITransactionConsistencyCommitOptions) {
+    const fiber = this.transactionFiber;
+    if (!fiber) {
+      if (!options?.ignoreIfNotInTransaction) {
+        await cb();
+      }
+    } else {
+      fiber.commit(cb);
+    }
+  }
+
+  compensate(cb: FunctionAny) {
+    const fiber = this.transactionFiber;
+    if (fiber) {
+      fiber.compensate(cb);
+    }
+  }
+
+  async begin<RESULT>(fn: FunctionAsync<RESULT>, options?: ITransactionOptions): Promise<RESULT> {
+    // transactionOptions
+    const transactionOptions = Object.assign({}, options, { propagation: undefined });
+    // propagation
+    const propagation = options?.propagation ?? 'REQUIRED';
+    if (propagation === 'REQUIRED') {
+      // required
+      return this._isolationLevelRequired(fn, transactionOptions);
+    } else if (propagation === 'SUPPORTS') {
+      // supports
+      if (this.inTransaction) {
+        return this._isolationLevelRequired(fn, transactionOptions);
+      } else {
+        return fn();
+      }
+    } else if (propagation === 'MANDATORY') {
+      // mandatory
+      if (this.inTransaction) {
+        return this._isolationLevelRequired(fn, transactionOptions);
+      } else {
+        throw new Error('transaction error: EnumTransactionPropagation.MANDATORY');
+      }
+    } else if (propagation === 'REQUIRES_NEW') {
+      // requires_new
+      if (!this.inTransaction) {
+        return this._isolationLevelRequired(fn, transactionOptions);
+      } else {
+        return this.bean.database.switchDbIsolate(() => {
+          return this.bean.database.current.transaction.begin(() => {
+            return fn();
+          }, transactionOptions);
+        }, this._db.info);
+      }
+    } else if (propagation === 'NOT_SUPPORTED') {
+      if (!this.inTransaction) {
+        return fn();
+      } else {
+        return this.bean.database.switchDbIsolate(fn, this._db.info);
+      }
+    } else if (propagation === 'NEVER') {
+      if (!this.inTransaction) {
+        return fn();
+      } else {
+        throw new Error('transaction error: EnumTransactionPropagation.NEVER');
+      }
+    }
+    throw new Error('transaction error: unknown propagation');
+  }
+
+  private async _isolationLevelRequired<RESULT>(fn: FunctionAsync<RESULT>, options?: ITransactionOptions): Promise<RESULT> {
+    let res: RESULT;
+    // begin
+    let fiber: ServiceTransactionFiber | undefined;
+    if (!this.inTransaction) {
+      const connection = this._db.client.connection;
+      const transactionConnection = await connection.transaction(_translateTransactionOptions(options));
+      fiber = this.transactionState.add(this._db, transactionConnection);
+    }
+    // fn
+    try {
+      res = await fn();
+    } catch (err) {
+      if (fiber) {
+        await fiber.doRollback();
+        this.transactionState.remove(this._db);
+      }
+      throw err;
+    }
+    try {
+      if (fiber) {
+        await fiber.doCommit();
+        this.transactionState.remove(this._db);
+      }
+    } catch (err) {
+      if (fiber) {
+        await fiber.doRollback();
+        this.transactionState.remove(this._db);
+      }
+      throw err;
+    }
+    return res;
+  }
+}
+
+function _translateTransactionOptions(options?: ITransactionOptions): Knex.TransactionConfig | undefined {
+  if (!options) return undefined;
+  return {
+    isolationLevel: TransactionIsolationLevelsMap[options.isolationLevel ?? 'DEFAULT'] as any,
+    readOnly: options.readOnly,
+  };
+}

package/src/types/columns.ts

@@ -0,0 +1,8 @@
+export interface ITableColumn {
+  type: string;
+  default: any;
+}
+
+export type ITableColumns = Record<string, ITableColumn>;
+
+export type ITableColumnsDefault = Record<string, any>;

package/src/types/config.ts

@@ -0,0 +1,23 @@
+import type { Knex } from 'knex';
+import type { VonaContext } from 'vona';
+
+import type { IDatabaseClientDialectRecord, IDatabaseClientRecord } from './database.ts';
+import type { IDatabaseDialectRecord } from './onion/databaseDialect.ts';
+
+export type TypeDefaultClientNameFn = (ctx?: VonaContext) => keyof IDatabaseClientRecord;
+
+export type TypeDefaultClientName = TypeDefaultClientNameFn | keyof IDatabaseClientRecord;
+
+export interface ConfigDatabaseClient extends Omit<Knex.Config, 'client'> {
+  client: keyof IDatabaseClientDialectRecord;
+}
+export interface ConfigDatabase {
+  testDatabase: boolean;
+  defaultClient: TypeDefaultClientName;
+  clients: Record<keyof IDatabaseClientRecord, ConfigDatabaseClient>;
+  base: ConfigDatabaseClient;
+}
+
+export type IDataBaseConfigDialects = {
+  [KEY in keyof IDatabaseClientDialectRecord]: keyof IDatabaseDialectRecord;
+};

package/src/types/database.ts

@@ -0,0 +1,64 @@
+import type { FunctionAny } from 'vona';
+
+import type { BeanModel } from '../bean/bean.model.ts';
+import type { ServiceDb } from '../service/db_.ts';
+import type { ConfigDatabase } from './config.ts';
+
+export interface IDbInfo {
+  level: number;
+  clientName: keyof IDatabaseClientRecord;
+}
+
+export interface IDatabaseClientRecord {
+  default: never;
+  sqlite3: never;
+  pg: never;
+  mysql: never;
+}
+
+export interface IDatabaseClientDialectRecord {
+  'better-sqlite3': never;
+  'pg': never;
+  'mysql': never;
+  'mysql2': never;
+}
+
+export interface IDatabaseSwitchOptions {
+  clientName?: keyof IDatabaseClientRecord;
+}
+
+declare module 'vona' {
+  export interface IBeanRecordGlobal {
+    model: BeanModel;
+  }
+
+  export interface VonaConfig {
+    database: ConfigDatabase;
+  }
+
+  export interface VonaContext {
+    get db(): ServiceDb;
+    commit(cb: FunctionAny): void;
+    commitsDone(): Promise<void>;
+  }
+
+  export interface VonaConfigEnv {
+    // default
+    DATABASE_DEFAULT_CLIENT: string | undefined;
+    // sqlite3
+    DATABASE_CLIENT_SQLITE3_FILENAME: string | undefined;
+    DATABASE_CLIENT_SQLITE3_NATIVEBINDING: string | 'true' | 'false' | undefined;
+    // pg
+    DATABASE_CLIENT_PG_HOST: string | undefined;
+    DATABASE_CLIENT_PG_PORT: string | undefined;
+    DATABASE_CLIENT_PG_USER: string | undefined;
+    DATABASE_CLIENT_PG_PASSWORD: string | undefined;
+    DATABASE_CLIENT_PG_DATABASE: string | undefined;
+    // mysql
+    DATABASE_CLIENT_MYSQL_HOST: string | undefined;
+    DATABASE_CLIENT_MYSQL_PORT: string | undefined;
+    DATABASE_CLIENT_MYSQL_USER: string | undefined;
+    DATABASE_CLIENT_MYSQL_PASSWORD: string | undefined;
+    DATABASE_CLIENT_MYSQL_DATABASE: string | undefined;
+  }
+}

package/src/types/depth.ts

@@ -0,0 +1,55 @@
+export type TypeDepthPrevMax = 50;
+export type TypeDepthPrev = [
+  never,
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  16,
+  17,
+  18,
+  19,
+  20,
+  21,
+  22,
+  23,
+  24,
+  25,
+  26,
+  27,
+  28,
+  29,
+  30,
+  31,
+  32,
+  33,
+  34,
+  35,
+  36,
+  37,
+  38,
+  39,
+  40,
+  41,
+  42,
+  43,
+  44,
+  45,
+  46,
+  47,
+  48,
+  49,
+  50,
+];

package/src/types/dialect.ts

@@ -0,0 +1,17 @@
+import type { ITableColumns } from './columns.ts';
+
+export interface IFetchDatabasesResultItem {
+  name: string;
+}
+
+export interface IFetchIndexesResultItem {
+  indexName: string;
+}
+
+export type TypeDatabaseDialectTableColumnsFn = () => Promise<ITableColumns>;
+
+export interface IDatabaseDialectCapabilities {
+  like: boolean;
+  ilike: boolean;
+  level: boolean;
+}

package/src/types/dto/dtoAggregate.ts

@@ -0,0 +1,3 @@
+import type { TypeModelAggrRelationResultAggrs } from '../relationsAggr.ts';
+
+export type TypeDtoAggrResult<Aggrs> = TypeModelAggrRelationResultAggrs<Aggrs>;

package/src/types/dto/dtoGet.ts

@@ -0,0 +1,23 @@
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper } from '../model.ts';
+import type { TypeModelColumns } from '../modelWhere.ts';
+import type { IModelClassRecord } from '../onion/model.ts';
+import type { TypeModelOfModelLike, TypeModelRelationResult, TypeSymbolKeyEntity } from '../relations.ts';
+
+export type IDtoGetParams<ModelLike extends BeanModelMeta | keyof IModelClassRecord> = IBuildDtoGetParams<
+  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
+  TypeModelOfModelLike<ModelLike>
+>;
+
+export interface IBuildDtoGetParams<TRecord, Model extends BeanModelMeta>
+  extends IModelRelationIncludeWrapper<Model>, IBuildDtoGetParamsBasic<TRecord> {}
+
+export interface IBuildDtoGetParamsBasic<TRecord> {
+  columns?: TypeModelColumns<TRecord>;
+}
+
+export type TypeDtoGetResult<ModelLike extends BeanModelMeta | keyof IModelClassRecord, TOptionsRelation> = TypeModelRelationResult<
+  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
+  TypeModelOfModelLike<ModelLike>,
+  TOptionsRelation
+>;

package/src/types/dto/dtoGroup.ts

@@ -0,0 +1,3 @@
+import type { TypeModelGroupRelationResultGroups } from '../relationsGroup.ts';
+
+export type TypeDtoGroupResult<TRecord, Aggrs, Groups, Columns> = TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, Columns>;

package/src/types/dto/dtoListAndCount.ts

@@ -0,0 +1,7 @@
+export interface TypeDtoListAndCountResult<T> {
+  list: T[];
+  total: string;
+  pageCount: number;
+  pageSize: number;
+  pageNo: number;
+}

package/src/types/dto/dtoMutate.ts

@@ -0,0 +1,231 @@
+import type { TableIdentity } from 'table-identity';
+import type { OmitNever, TypeOmitStringUnion } from 'vona';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper } from '../model.ts';
+import type { TypeModelColumnsStrict } from '../modelWhere.ts';
+import type { IDecoratorModelOptions, IModelClassRecord } from '../onion/model.ts';
+import type {
+  TypeModelOfModelLike,
+  TypeSymbolKeyEntity,
+  TypeUtilEntityOmit,
+  TypeUtilEntityPartial,
+  TypeUtilEntitySelector,
+  TypeUtilGetColumnsFromRelationAndIncludeWrapper,
+  TypeUtilGetModelOptions,
+  TypeUtilGetParamsColumns,
+  TypeUtilGetParamsInlcude,
+  TypeUtilGetParamsWith,
+  TypeUtilGetRelationEntity,
+  TypeUtilGetRelationKey,
+  TypeUtilGetRelationModel,
+  TypeUtilGetRelationOptions,
+  TypeUtilGetRelationOptionsAutoload,
+  TypeUtilGetRelationType,
+  TypeUtilPrepareColumns,
+} from '../relations.ts';
+
+export type TypeDtoMutateType = 'create' | 'update' | 'mutate';
+
+export type IDtoMutateParams<ModelLike extends BeanModelMeta | keyof IModelClassRecord> = IBuildDtoMutateParams<
+  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
+  TypeModelOfModelLike<ModelLike>
+>;
+
+export interface IBuildDtoMutateParams<TRecord, Model extends BeanModelMeta>
+  extends IModelRelationIncludeWrapper<Model>, IBuildDtoMutateParamsBasic<TRecord> {}
+
+export interface IBuildDtoMutateParamsBasic<TRecord> {
+  columns?: TypeModelColumnsStrict<TRecord>;
+}
+
+export type TypeDtoMutateResult<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  TOptionsRelation,
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  TColumnsOmitDefault extends string | string[] | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+> = TypeDtoMutateRelationResult<
+  TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity],
+  TypeModelOfModelLike<ModelLike>,
+  TOptionsRelation,
+  TMutateTypeTopLevel,
+  TColumnsOmitDefault,
+  TTopLevel
+>;
+
+export type TypeDtoMutateRelationResult<
+  TRecord,
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  TColumnsOmitDefault extends string | string[] | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+  TColumns = undefined,
+  REFKEY = undefined,
+> = TypeDtoMutateRelationResultEntity<
+  TRecord,
+  TColumns extends string | string[] ? TColumns : TypeUtilGetParamsColumns<TOptionsRelation>,
+  TMutateTypeTopLevel,
+  TColumnsOmitDefault,
+  TTopLevel,
+  REFKEY
+> &
+  (TModel extends BeanModelMeta
+    ? OmitNever<
+        TypeDtoMutateRelationResultMergeInclude<TMutateTypeTopLevel, TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>>
+      > &
+        OmitNever<TypeDtoMutateModelRelationResultMergeWith<TMutateTypeTopLevel, TypeUtilGetParamsWith<TOptionsRelation>>>
+    : {});
+
+type TypeDtoMutateRelationResultMergeInclude<
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  TModelOptions extends IDecoratorModelOptions,
+  TInclude extends {} | undefined | unknown,
+> = {
+  [RelationName in keyof TModelOptions['relations']]: TInclude extends {}
+    ? TInclude[RelationName] extends {} | boolean
+      ? TypeDtoMutateRelationResultMergeIncludeWrapper<TMutateTypeTopLevel, TModelOptions['relations'][RelationName], TInclude[RelationName]>
+      : TypeDtoMutateRelationResultMergeAutoload<TMutateTypeTopLevel, TModelOptions['relations'][RelationName]>
+    : TypeDtoMutateRelationResultMergeAutoload<TMutateTypeTopLevel, TModelOptions['relations'][RelationName]>;
+};
+
+type TypeDtoMutateModelRelationResultMergeWith<
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  TWith extends {} | undefined | unknown,
+> = TWith extends {} ? { [RelationName in keyof TWith]: TypeDtoMutateRelationResultMergeWithRelation<TMutateTypeTopLevel, TWith[RelationName]> } : {};
+
+type TypeDtoMutateRelationResultMergeIncludeWrapper<
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  Relation,
+  IncludeWrapper,
+> = IncludeWrapper extends false
+  ? never
+  : IncludeWrapper extends true
+    ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, undefined>
+    : IncludeWrapper extends {}
+      ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, IncludeWrapper>
+      : never;
+
+type TypeDtoMutateRelationResultMergeAutoload<TMutateTypeTopLevel extends TypeDtoMutateType, Relation> =
+  TypeUtilGetRelationOptionsAutoload<Relation> extends true
+    ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, Relation, undefined>
+    : never;
+
+type TypeDtoMutateRelationResultMergeWithRelation<TMutateTypeTopLevel extends TypeDtoMutateType, WithRelation> = WithRelation extends false
+  ? never
+  : WithRelation extends true
+    ? never
+    : WithRelation extends {}
+      ? TypeUtilGetDtoMutateRelationEntityByType<TMutateTypeTopLevel, WithRelation, TypeUtilGetRelationOptions<WithRelation>>
+      : never;
+
+type TypeUtilGetDtoMutateRelationEntityByType<
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  Relation,
+  IncludeWrapper extends {} | undefined | unknown,
+> = TypeUtilGetDtoMutateEntityByType<
+  TMutateTypeTopLevel,
+  TypeUtilGetRelationEntity<Relation>,
+  TypeUtilGetRelationType<Relation>,
+  TypeUtilGetRelationModel<Relation>,
+  IncludeWrapper,
+  TypeUtilGetColumnsFromRelationAndIncludeWrapper<Relation, IncludeWrapper>,
+  TypeUtilGetRelationKey<Relation>
+>;
+type TypeUtilGetDtoMutateEntityByType<
+  TMutateTypeTopLevel extends TypeDtoMutateType,
+  TRecord,
+  TYPE,
+  TModel extends BeanModelMeta | undefined,
+  IncludeWrapper extends {} | undefined | unknown,
+  Columns,
+  REFKEY = undefined,
+> = TYPE extends 'belongsTo'
+  ? never
+  : TYPE extends 'belongsToMany'
+    ? Array<{ id: TableIdentity; deleted?: boolean }> | undefined
+    : TYPE extends 'hasMany'
+      ? Array<TypeDtoMutateRelationResult<TRecord, TModel, IncludeWrapper, TMutateTypeTopLevel, undefined, false, Columns, REFKEY>> | undefined
+      : TypeDtoMutateRelationResult<TRecord, TModel, IncludeWrapper, TMutateTypeTopLevel, undefined, false, Columns, REFKEY> | undefined;
+
+type TypeDtoMutateRelationResultEntity<
+  TRecord,
+  Columns = undefined,
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TColumnsOmitDefault extends string | string[] | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+  REFKEY = undefined,
+> = TypeDtoMutateRelationResultPatch<
+  TypeDtoMutateRelationResultEntityInner<TRecord, Columns, TMutateTypeTopLevel, TColumnsOmitDefault, TTopLevel>,
+  TMutateTypeTopLevel,
+  TTopLevel,
+  REFKEY
+>;
+
+type TypeDtoMutateRelationResultPatch<
+  TRecordResult,
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+  REFKEY = undefined,
+> = TTopLevel extends false
+  ? TypeUtilEntityOmit<TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel, TTopLevel>, REFKEY>
+  : TypeDtoMutateRelationResultPatch2<TRecordResult, TMutateTypeTopLevel, TTopLevel>;
+
+type TypeDtoMutateRelationResultPatch2<
+  TRecordResult,
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+> = TTopLevel extends false
+  ? TMutateTypeTopLevel extends 'update' | 'mutate'
+    ? TypeUtilEntityPartial<TRecordResult, 'id' | 'deleted'>
+    : TRecordResult
+  : TRecordResult;
+
+type TypeDtoMutateRelationResultEntityInner<
+  TRecord,
+  Columns = undefined,
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TColumnsOmitDefault extends string | string[] | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+> = [Columns] extends [string | string[]]
+  ? TypeDtoMutateRelationResultEntityFromColumns<TRecord, Columns, TMutateTypeTopLevel, TTopLevel>
+  : TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<TRecord, TMutateTypeTopLevel, TColumnsOmitDefault>;
+
+type TypeDtoMutateRelationResultEntityFromColumns<
+  TRecord,
+  Columns = undefined,
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+> = TypeUtilEntitySelector<
+  TRecord,
+  TypeUtilPrepareColumns<TypeDtoMutateRelationResultPrepareColumns<TypeUtilPrepareColumns<Columns>, TMutateTypeTopLevel, TTopLevel>>
+>;
+
+type TypeDtoMutateRelationResultEntityFromColumnsOmitDefault<
+  TRecord,
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TColumnsOmitDefault extends string | string[] | undefined = undefined,
+> = TypeUtilEntityOmit<
+  TRecord,
+  TypeUtilPrepareColumns<TypeDtoMutateRelationResultPrepareColumnsOmitDefault<TMutateTypeTopLevel, TColumnsOmitDefault>>
+>;
+
+type TypeDtoMutateRelationResultPrepareColumns<
+  TColumns = undefined,
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TTopLevel extends boolean | undefined = undefined,
+> = TTopLevel extends true
+  ? TColumns
+  : TMutateTypeTopLevel extends 'create'
+    ? TypeOmitStringUnion<TColumns, 'deleted' | 'id'>
+    : TColumns | 'deleted' | 'id';
+
+type TypeDtoMutateRelationResultPrepareColumnsOmitDefault<
+  TMutateTypeTopLevel extends TypeDtoMutateType | undefined = undefined,
+  TColumnsOmitDefault extends string | string[] | undefined = undefined,
+> = TColumnsOmitDefault extends string | string[]
+  ? TColumnsOmitDefault
+  : TMutateTypeTopLevel extends 'create'
+    ? ['id', 'iid', 'deleted', 'createdAt', 'updatedAt']
+    : ['iid', 'createdAt', 'updatedAt'];

package/src/types/dto/dtoQueryBase.ts

@@ -0,0 +1,18 @@
+import { useApp } from 'vona';
+import { Api, v } from 'vona-module-a-openapiutils';
+import z from 'zod';
+
+const app = useApp();
+const ormConfig = app.util.getModuleConfigRaw('a-orm');
+const ordersDefault = ormConfig?.rest?.query?.orders?.default ?? 'createdAt,desc';
+
+export class DtoQueryBase {
+  @Api.field(v.optional(), v.array(String, { separator: ',' }))
+  columns?: string[];
+
+  @Api.field(v.optional(), z.looseObject({}))
+  where?: object;
+
+  @Api.field(v.default(ordersDefault), v.optional(), z.union([z.string(), z.array(z.array(z.string()))]))
+  orders?: string | string[][];
+}

package/src/types/dto/dtoQueryPageBase.ts

@@ -0,0 +1,18 @@
+import { useApp } from 'vona';
+import { Api } from 'vona-module-a-openapiutils';
+import z from 'zod';
+
+import { DtoQueryBase } from './dtoQueryBase.ts';
+
+const app = useApp();
+const ormConfig = app.util.getModuleConfigRaw('a-orm');
+const pageSizeDefault = ormConfig?.rest?.query?.pageSize?.default ?? 20;
+const pageSizeMax = ormConfig?.rest?.query?.pageSize?.max ?? 100;
+
+export class DtoQueryPageBase extends DtoQueryBase {
+  @Api.field(z.number().min(1).default(1))
+  pageNo: number;
+
+  @Api.field(z.number().min(1).max(pageSizeMax).default(pageSizeDefault))
+  pageSize: number;
+}

package/src/types/dto/dtoSelectAndCount.ts

@@ -0,0 +1,11 @@
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IModelClassRecord } from '../onion/model.ts';
+import type { TypeDtoGetResult } from './dtoGet.ts';
+
+export interface TypeDtoSelectAndCountResult<ModelLike extends BeanModelMeta | keyof IModelClassRecord, TOptionsRelation> {
+  list: TypeDtoGetResult<ModelLike, TOptionsRelation>[];
+  total: string;
+  pageCount: number;
+  pageSize: number;
+  pageNo: number;
+}

package/src/types/dto/index.ts

@@ -0,0 +1,8 @@
+export * from './dtoAggregate.ts';
+export * from './dtoGet.ts';
+export * from './dtoGroup.ts';
+export * from './dtoListAndCount.ts';
+export * from './dtoMutate.ts';
+export * from './dtoQueryBase.ts';
+export * from './dtoQueryPageBase.ts';
+export * from './dtoSelectAndCount.ts';

package/src/types/entity.ts

@@ -0,0 +1,15 @@
+import type { PickString } from 'vona';
+
+export type TypeEntityMeta<T, N = string> = Required<{
+  [key in keyof T]: key;
+}> & {
+  $table: N;
+  $comment: Required<{ [key in keyof T]: string }> & { $table: string };
+  $default: Required<{ [key in keyof T]: any }>;
+};
+
+export const SymbolKeyFieldsMore = Symbol('$fieldsMore');
+export type TypeSymbolKeyFieldsMore = typeof SymbolKeyFieldsMore;
+
+export type TypeEntityStudentMetaSimple<T> = Omit<T, '$table' | '$comment' | '$default'>;
+export type TypeEntityStudentMetaSimpleColumns<T> = PickString<keyof TypeEntityStudentMetaSimple<T>>;

package/src/types/entityBase.ts

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

package/src/types/entityBaseEmpty.ts

@@ -0,0 +1 @@
+export class EntityBaseEmpty {}