vona-module-a-orm 5.0.96 → 5.1.2

package/src/lib/const.ts

@@ -0,0 +1,58 @@
+import type { VonaApplication } from 'vona';
+
+import type { IModelRecord } from '../types/onion/model.ts';
+import type { TypeModelClassLikeGeneral } from '../types/relations.ts';
+
+export const SymbolCacheModelsClear = Symbol('SymbolCacheModelsClearAll');
+export const SymbolCacheModelCacheInstances = Symbol('SymbolCacheModelCacheInstances');
+
+export function clearAllCacheModelsClear(app: VonaApplication) {
+  delete app.meta[SymbolCacheModelsClear];
+}
+
+export async function clearCacheModelCacheInstance(app: VonaApplication, beanFullName: string) {
+  const cacheModelCacheInstances = getCacheModelCacheInstances(app);
+  const instances = cacheModelCacheInstances[beanFullName];
+  if (!instances) return;
+  delete cacheModelCacheInstances[beanFullName];
+  for (const cacheName in instances) {
+    await app.bean._removeBean(instances[cacheName]);
+  }
+}
+
+export function getCacheModelCacheInstances(app: VonaApplication) {
+  if (!app.meta[SymbolCacheModelCacheInstances]) app.meta[SymbolCacheModelCacheInstances] = {};
+  return app.meta[SymbolCacheModelCacheInstances];
+}
+
+export function getCacheModelsClear(app: VonaApplication): Record<keyof IModelRecord, TypeModelClassLikeGeneral[]> {
+  if (!app.meta[SymbolCacheModelsClear]) {
+    app.meta[SymbolCacheModelsClear] = _collectModelsClear(app);
+  }
+  return app.meta[SymbolCacheModelsClear];
+}
+
+function _collectModelsClear(app: VonaApplication) {
+  const modelsClearAll: Record<keyof IModelRecord, TypeModelClassLikeGeneral[]> = {} as any;
+  const onionSlices = app.bean.onion.model.getOnionsEnabledCached();
+  for (const onionSlice of onionSlices) {
+    const modelName = onionSlice.name;
+    if (!modelsClearAll[modelName]) modelsClearAll[modelName] = [];
+    //
+    const modelsClear = onionSlice.beanOptions.options?.cache?.modelsClear;
+    if (modelsClear) {
+      const modelsClear2 = Array.isArray(modelsClear) ? modelsClear : [modelsClear];
+      modelsClearAll[modelName].push(...modelsClear2);
+    }
+    //
+    const modelsClearedBy = onionSlice.beanOptions.options?.cache?.modelsClearedBy;
+    if (modelsClearedBy) {
+      const modelsClearedBy2 = Array.isArray(modelsClearedBy) ? modelsClearedBy : [modelsClearedBy];
+      for (const modelName2 of modelsClearedBy2) {
+        if (!modelsClearAll[modelName2]) modelsClearAll[modelName2] = [];
+        modelsClearAll[modelName2].push(modelName);
+      }
+    }
+  }
+  return modelsClearAll;
+}

package/src/lib/databaseDialect.ts

@@ -0,0 +1,7 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorDatabaseDialectOptions } from '../types/index.ts';
+
+export function DatabaseDialect<T extends IDecoratorDatabaseDialectOptions>(options?: T): ClassDecorator {
+  return createBeanDecorator('databaseDialect', options);
+}

package/src/lib/dto/dto.ts

@@ -0,0 +1,21 @@
+import { DtoAggregate } from './dtoAggregate.ts';
+import { DtoCreate } from './dtoCreate.ts';
+import { DtoGet } from './dtoGet.ts';
+import { DtoGroup } from './dtoGroup.ts';
+import { DtoListAndCount } from './dtoListAndCount.ts';
+import { DtoQuery } from './dtoQuery.ts';
+import { DtoQueryPage } from './dtoQueryPage.ts';
+import { DtoSelectAndCount } from './dtoSelectAndCount.ts';
+import { DtoUpdate } from './dtoUpdate.ts';
+
+export const $Dto = {
+  create: DtoCreate,
+  update: DtoUpdate,
+  get: DtoGet,
+  aggregate: DtoAggregate,
+  group: DtoGroup,
+  query: DtoQuery,
+  queryPage: DtoQueryPage,
+  selectAndCount: DtoSelectAndCount,
+  listAndCount: DtoListAndCount,
+};

package/src/lib/dto/dtoAggregate.ts

@@ -0,0 +1,51 @@
+import type { Constructable } from 'vona';
+
+import { ensureArray } from '@cabloy/utils';
+import { Api, v } from 'vona-module-a-openapiutils';
+import z from 'zod';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { TypeDtoAggrResult } from '../../types/dto/dtoAggregate.ts';
+import type { TypeModelSelectAggrParamsAggrs } from '../../types/modelAggr.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
+
+export function DtoAggregate<
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  aggrs: Aggrs,
+): Constructable<TypeDtoAggrResult<Aggrs>> {
+  return _DtoAggregate_raw(modelLike, aggrs);
+}
+
+function _DtoAggregate_raw<
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  aggrs: Aggrs,
+): Constructable<TypeDtoAggrResult<Aggrs>> {
+  abstract class TargetClass {}
+  return _DtoAggregate_inner(TargetClass as any, modelLike, aggrs);
+}
+
+export function _DtoAggregate_inner<
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+>(
+  classTarget: Constructable,
+  _modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  aggrs: Aggrs,
+): Constructable<TypeDtoAggrResult<Aggrs>> {
+  for (const key in aggrs) {
+    const columns = ensureArray(aggrs[key]);
+    if (!columns) continue;
+    for (const column of columns) {
+      const column2 = `${key}_${column === '*' ? 'all' : column}`;
+      Api.field(v.optional(), z.string())(classTarget.prototype, column2);
+    }
+  }
+  return classTarget as any;
+}

package/src/lib/dto/dtoCreate.ts

@@ -0,0 +1,14 @@
+import type { Constructable } from 'vona';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoMutateParams, TypeDtoMutateResult } from '../../types/dto/dtoMutate.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+
+import { _DtoMutate_raw } from './dtoMutate.ts';
+
+export function DtoCreate<ModelLike extends BeanModelMeta | keyof IModelClassRecord, T extends IDtoMutateParams<ModelLike> | undefined = undefined>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  params?: T,
+): Constructable<TypeDtoMutateResult<ModelLike, T, 'create', 'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt', true>> {
+  return _DtoMutate_raw(modelLike, params, 'create', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] as any, true, undefined);
+}

package/src/lib/dto/dtoGet.ts

@@ -0,0 +1,159 @@
+import type { Constructable } from 'vona';
+
+import { ensureArray, hashkey } from '@cabloy/utils';
+import { $Class, appResource } from 'vona';
+import { addSchemaDynamic, Api, getSchemaDynamic, SymbolSchemaDynamicRefId, v } from 'vona-module-a-openapiutils';
+import z from 'zod';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoGetParams, TypeDtoGetResult } from '../../types/dto/dtoGet.ts';
+import type { TypeDtoMutateType } from '../../types/dto/dtoMutate.ts';
+import type { IModelRelationIncludeWrapper } from '../../types/model.ts';
+import type { IDecoratorModelOptions, IModelClassRecord } from '../../types/onion/model.ts';
+import type { IRelationItem } from '../../types/relationsDef.ts';
+
+import { getClassEntityFromClassModel, prepareClassModel, prepareColumns } from '../../common/utils.ts';
+import { handleRelationsCollection } from '../utils.ts';
+import { DtoAggregate } from './dtoAggregate.ts';
+import { DtoGroup } from './dtoGroup.ts';
+import { _DtoMutate_raw } from './dtoMutate.ts';
+
+export function DtoGet<ModelLike extends BeanModelMeta | keyof IModelClassRecord, T extends IDtoGetParams<ModelLike> | undefined = undefined>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  params?: T,
+): Constructable<TypeDtoGetResult<ModelLike, T>> {
+  return _DtoGet_raw(modelLike, params);
+}
+
+function _DtoGet_raw<ModelLike extends BeanModelMeta | keyof IModelClassRecord, T extends IDtoGetParams<ModelLike> | undefined = undefined>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  params?: T,
+): Constructable<TypeDtoGetResult<ModelLike, T>> {
+  // model
+  const modelClass = prepareClassModel(modelLike);
+  // entity
+  let entityClass = getClassEntityFromClassModel(modelClass);
+  // columns
+  const columns = prepareColumns(params?.columns);
+  // always create a new class, no matter if columns empty
+  entityClass = $Class.pick(entityClass, columns as any);
+  // relations
+  _DtoGet_relations(modelClass, entityClass, params as any);
+  return entityClass as any;
+}
+
+export function _DtoGet_relations<TRecord extends {}, TModel extends BeanModelMeta>(
+  modelClass: Constructable<TModel>,
+  entityClass: Constructable<TRecord>,
+  includeWrapper?: IModelRelationIncludeWrapper,
+  mutateTypeTopLevel?: TypeDtoMutateType,
+) {
+  // relations
+  const relations = _DtoGet_relations_collection(modelClass, includeWrapper);
+  if (!relations) return;
+  for (const relation of relations) {
+    _DtoGet_relation_handle(entityClass, relation, mutateTypeTopLevel);
+  }
+}
+
+function _DtoGet_relation_handle<TRecord extends {}>(
+  entityClass: Constructable<TRecord>,
+  relation: [string, any, any, any, boolean],
+  mutateTypeTopLevel?: TypeDtoMutateType,
+) {
+  const [relationName, relationReal, includeReal, withReal, autoload] = relation;
+  const { type, model, options } = relationReal;
+  const modelTarget = prepareClassModel(model);
+  const optionsReal = Object.assign({}, options, { include: includeReal, with: withReal });
+  if (mutateTypeTopLevel) {
+    if (type === 'belongsTo') {
+      // donot mutate
+      return;
+    }
+    let schema;
+    if (type === 'belongsToMany') {
+      schema = v.array(z.object({ id: v.tableIdentity()(), deleted: z.boolean().optional() }));
+    } else if (type === 'hasOne') {
+      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
+      schema = v.lazy(v.visible(false), schemaLazy);
+      // optional = true;
+    } else {
+      // hasMany
+      const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
+      schema = v.array(v.lazy(schemaLazy));
+    }
+    Api.field(v.optional(), schema)(entityClass.prototype, relationName);
+  } else {
+    const schemaLazy = _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel, relation);
+    let schema;
+    let optional = false;
+    if (type === 'hasOne' || type === 'belongsTo') {
+      schema = v.lazy(v.visible(false), schemaLazy);
+      optional = true;
+    } else {
+      if (optionsReal.groups) {
+        schema = v.array(v.lazy(schemaLazy));
+      } else if (optionsReal.aggrs) {
+        schema = v.lazy(schemaLazy);
+        optional = true;
+      } else {
+        schema = v.array(v.lazy(schemaLazy));
+      }
+    }
+    if (optional) {
+      Api.field(v.optional(), schema)(entityClass.prototype, relationName);
+    } else {
+      Api.field(schema)(entityClass.prototype, relationName);
+    }
+  }
+}
+
+function _DtoGet_relation_handle_schemaLazy(modelTarget, optionsReal, autoload, mutateTypeTopLevel?: TypeDtoMutateType, relation?: IRelationItem) {
+  return () => {
+    if (!autoload) {
+      return _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
+    }
+    // dynamic
+    const entityClass = getClassEntityFromClassModel(modelTarget);
+    const beanFullName = appResource.getBeanFullName(entityClass);
+    const _hashkey = _DtoGet_relation_handle_schemaLazy_hashkey(optionsReal, mutateTypeTopLevel);
+    const dynamicName = `${beanFullName}_${_hashkey}`;
+    let entityTarget = getSchemaDynamic(dynamicName);
+    if (!entityTarget) {
+      entityTarget = _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel, relation);
+      entityTarget[SymbolSchemaDynamicRefId] = dynamicName;
+      addSchemaDynamic(dynamicName, entityTarget);
+    }
+    return entityTarget;
+  };
+}
+
+function _DtoGet_relation_handle_schemaLazy_raw(modelTarget, optionsReal, mutateTypeTopLevel?: TypeDtoMutateType, relation?: IRelationItem) {
+  if (mutateTypeTopLevel) {
+    return _DtoMutate_raw(modelTarget, optionsReal, mutateTypeTopLevel, undefined, false, relation); // columnsOmitDefault: undefined
+  } else {
+    if (optionsReal.groups) {
+      return DtoGroup(modelTarget, optionsReal.groups, optionsReal.aggrs, optionsReal.columns);
+    } else if (optionsReal.aggrs) {
+      return DtoAggregate(modelTarget, optionsReal.aggrs);
+    } else {
+      return _DtoGet_raw(modelTarget, optionsReal);
+    }
+  }
+}
+
+function _DtoGet_relation_handle_schemaLazy_hashkey(optionsReal, mutateTypeTopLevel?: TypeDtoMutateType) {
+  const columns = prepareColumns(optionsReal.columns);
+  const aggrs = ensureArray(optionsReal.aggrs);
+  const groups = ensureArray(optionsReal.groups);
+  return columns || aggrs || groups || mutateTypeTopLevel ? hashkey({ columns, aggrs, groups, mutate: mutateTypeTopLevel }) : 'none';
+}
+
+function _DtoGet_relations_collection<TModel extends BeanModelMeta>(
+  modelClass: Constructable<TModel>,
+  includeWrapper?: IModelRelationIncludeWrapper,
+) {
+  const beanOptions = appResource.getBean(modelClass);
+  const options = beanOptions?.options as IDecoratorModelOptions | undefined;
+  return handleRelationsCollection(options?.relations, includeWrapper);
+}

package/src/lib/dto/dtoGroup.ts

@@ -0,0 +1,57 @@
+import type { Constructable } from 'vona';
+
+import { ensureArray } from '@cabloy/utils';
+import { PickClassInner } from 'vona';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { TypeDtoGroupResult } from '../../types/dto/dtoGroup.ts';
+import type { TypeModelSelectAggrParamsAggrs } from '../../types/modelAggr.ts';
+import type { TypeModelColumnsStrict } from '../../types/modelWhere.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
+
+import { getClassEntityFromClassModel, prepareClassModel } from '../../common/utils.ts';
+import { _DtoAggregate_inner } from './dtoAggregate.ts';
+
+export function DtoGroup<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined,
+  Columns extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined,
+>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  groups: Groups,
+  aggrs?: Aggrs,
+  columns?: Columns,
+): Constructable<TypeDtoGroupResult<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], Aggrs, Groups, Columns>> {
+  return _DtoGroup_raw(modelLike, groups, aggrs, columns);
+}
+
+function _DtoGroup_raw<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  Groups extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]>,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined,
+  Columns extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined,
+>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  groups: Groups,
+  aggrs?: Aggrs,
+  columns?: Columns,
+): Constructable<TypeDtoGroupResult<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity], Aggrs, Groups, Columns>> {
+  abstract class TargetClass {}
+  // model
+  const modelClass = prepareClassModel(modelLike);
+  // entity
+  const entityClass = getClassEntityFromClassModel(modelClass);
+  // columns/groups
+  const displays = ensureArray(columns ?? groups);
+  if (displays) {
+    PickClassInner(TargetClass as any, entityClass, displays as any);
+  }
+  // aggrs
+  if (aggrs) {
+    _DtoAggregate_inner(TargetClass as any, modelLike, aggrs);
+  }
+  // ok
+  return TargetClass as any;
+}

package/src/lib/dto/dtoListAndCount.ts

@@ -0,0 +1,16 @@
+import type { Constructable } from 'vona';
+
+import { Api, v } from 'vona-module-a-openapiutils';
+import z from 'zod';
+
+import type { TypeDtoListAndCountResult } from '../../types/dto/dtoListAndCount.ts';
+
+export function DtoListAndCount<T>(classRef: Constructable<T>): Constructable<TypeDtoListAndCountResult<T>> {
+  abstract class TargetClass {}
+  Api.field(v.array(classRef))(TargetClass.prototype, 'list');
+  Api.field(z.string())(TargetClass.prototype, 'total');
+  Api.field(z.number())(TargetClass.prototype, 'pageCount');
+  Api.field(z.number())(TargetClass.prototype, 'pageSize');
+  Api.field(z.number())(TargetClass.prototype, 'pageNo');
+  return TargetClass as any;
+}

package/src/lib/dto/dtoMutate.ts

@@ -0,0 +1,82 @@
+import type { Constructable } from 'vona';
+
+import { mutate } from 'mutate-on-copy';
+import { $Class } from 'vona';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoMutateParams, TypeDtoMutateResult, TypeDtoMutateType } from '../../types/dto/dtoMutate.ts';
+import type { TypeModelColumnsStrict } from '../../types/modelWhere.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+import type { TypeModelOfModelLike, TypeSymbolKeyEntity } from '../../types/relations.ts';
+import type { IRelationItem } from '../../types/relationsDef.ts';
+
+import { getClassEntityFromClassModel, prepareClassModel, prepareColumns } from '../../common/utils.ts';
+import { _DtoGet_relations } from './dtoGet.ts';
+
+export function DtoMutate<ModelLike extends BeanModelMeta | keyof IModelClassRecord, T extends IDtoMutateParams<ModelLike> | undefined = undefined>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  params?: T,
+): Constructable<TypeDtoMutateResult<ModelLike, T, 'mutate', undefined, true>> {
+  return _DtoMutate_raw(modelLike, params, 'mutate', undefined, true, undefined);
+}
+
+export function _DtoMutate_raw<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  T extends IDtoMutateParams<ModelLike> | undefined = undefined,
+  ColumnsOmitDefault extends TypeModelColumnsStrict<TypeModelOfModelLike<ModelLike>[TypeSymbolKeyEntity]> | undefined = undefined,
+>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  params?: T,
+  mutateTypeTopLevel?: TypeDtoMutateType,
+  columnsOmitDefault?: ColumnsOmitDefault,
+  topLevel?: boolean,
+  relation?: IRelationItem,
+) {
+  // model
+  const modelClass = prepareClassModel(modelLike);
+  // entity
+  let entityClass = getClassEntityFromClassModel(modelClass);
+  // columns
+  let columns = prepareColumns(params?.columns);
+  if (columns) {
+    if (!topLevel) {
+      if (mutateTypeTopLevel === 'create') {
+        for (const key of ['deleted', 'id']) {
+          const index = columns.indexOf(key as any);
+          if (index > -1) {
+            columns = mutate(columns, copyState => {
+              copyState.splice(index, 1);
+            });
+          }
+        }
+      } else {
+        for (const key of ['deleted', 'id']) {
+          if (!columns.includes(key as any)) {
+            columns = mutate(columns, copyState => {
+              copyState.unshift(key as any);
+            });
+          }
+        }
+      }
+    }
+    entityClass = $Class.pick(entityClass, columns);
+  } else {
+    const columns =
+      columnsOmitDefault ??
+      (mutateTypeTopLevel === 'create' ? ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] : ['iid', 'createdAt', 'updatedAt']);
+    entityClass = $Class.omit(entityClass, prepareColumns(columns as any) as any);
+  }
+  if (!topLevel && mutateTypeTopLevel !== 'create') {
+    entityClass = $Class.partial(entityClass, ['id', 'deleted'] as any);
+  }
+  if (!topLevel && relation) {
+    const [_relationName, relationReal] = relation;
+    const { type, key } = relationReal;
+    if (type === 'hasOne' || type === 'hasMany') {
+      entityClass = $Class.omit(entityClass, key);
+    }
+  }
+  // relations
+  _DtoGet_relations(modelClass, entityClass, params as any, mutateTypeTopLevel);
+  return entityClass as any;
+}

package/src/lib/dto/dtoQuery.ts

@@ -0,0 +1,9 @@
+import type { Constructable } from 'vona';
+
+import { $Class } from 'vona';
+
+import { DtoQueryBase } from '../../types/dto/dtoQueryBase.ts';
+
+export function DtoQuery<T, K extends keyof T>(classRef: Constructable<T>, keys: K[]) {
+  return $Class.mixin(DtoQueryBase, $Class.partial($Class.pick(classRef, keys)));
+}

package/src/lib/dto/dtoQueryPage.ts

@@ -0,0 +1,9 @@
+import type { Constructable } from 'vona';
+
+import { $Class } from 'vona';
+
+import { DtoQueryPageBase } from '../../types/dto/dtoQueryPageBase.ts';
+
+export function DtoQueryPage<T, KEYS extends Array<keyof T>>(classRef: Constructable<T>, keys: KEYS) {
+  return $Class.mixin(DtoQueryPageBase, $Class.partial($Class.pick(classRef, keys)));
+}

package/src/lib/dto/dtoSelectAndCount.ts

@@ -0,0 +1,20 @@
+import type { Constructable } from 'vona';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoGetParams } from '../../types/dto/dtoGet.ts';
+import type { TypeDtoSelectAndCountResult } from '../../types/dto/dtoSelectAndCount.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+
+import { DtoGet } from './dtoGet.ts';
+import { DtoListAndCount } from './dtoListAndCount.ts';
+
+export function DtoSelectAndCount<
+  ModelLike extends BeanModelMeta | keyof IModelClassRecord,
+  T extends IDtoGetParams<ModelLike> | undefined = undefined,
+>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  params?: T,
+): Constructable<TypeDtoSelectAndCountResult<ModelLike, T>> {
+  const DtoGetResult = DtoGet(modelLike, params);
+  return DtoListAndCount(DtoGetResult);
+}

package/src/lib/dto/dtoUpdate.ts

@@ -0,0 +1,16 @@
+import type { Constructable } from 'vona';
+
+import type { BeanModelMeta } from '../../bean/bean.model/bean.model_meta.ts';
+import type { IDtoMutateParams, TypeDtoMutateResult } from '../../types/dto/dtoMutate.ts';
+import type { IModelClassRecord } from '../../types/onion/model.ts';
+
+import { _DtoMutate_raw } from './dtoMutate.ts';
+
+export function DtoUpdate<ModelLike extends BeanModelMeta | keyof IModelClassRecord, T extends IDtoMutateParams<ModelLike> | undefined = undefined>(
+  modelLike: ModelLike extends BeanModelMeta ? (() => Constructable<ModelLike>) | Constructable<ModelLike> : ModelLike,
+  params?: T,
+): Constructable<TypeDtoMutateResult<ModelLike, T, 'update', 'id' | 'iid' | 'deleted' | 'createdAt' | 'updatedAt', true>> {
+  return _DtoMutate_raw(modelLike, params, 'update', ['id', 'iid', 'deleted', 'createdAt', 'updatedAt'] as any, true, undefined);
+}
+
+// not use Partial/$Class.partial, for form render at frontend

package/src/lib/dto/index.ts

@@ -0,0 +1 @@
+export * from './dto.ts';

package/src/lib/entity.ts

@@ -0,0 +1,25 @@
+import { createBeanDecorator } from 'vona';
+import { mergeFieldsOpenapiMetadata } from 'vona-module-a-openapiutils';
+
+import type { IDecoratorEntityOptions } from '../types/onion/entity.ts';
+
+// const __tableNames = new Set();
+
+export function Entity<T extends IDecoratorEntityOptions<any>>(options?: T): ClassDecorator;
+export function Entity<T extends IDecoratorEntityOptions<any>>(table?: string, options?: Omit<T, 'table'>): ClassDecorator;
+export function Entity<T extends IDecoratorEntityOptions<any>>(table?: T | string, options?: T): ClassDecorator {
+  if (typeof table === 'string') {
+    options = Object.assign({}, options, { table });
+  } else {
+    options = table || ({} as any);
+  }
+  // // tableName
+  // const tableName = options.table;
+  // if (__tableNames.has(tableName)) {
+  //   throw new Error(`entity table exists: ${tableName}`);
+  // }
+  // __tableNames.add(tableName);
+  return createBeanDecorator('entity', options, false, target => {
+    mergeFieldsOpenapiMetadata(target);
+  });
+}

package/src/lib/index.ts

@@ -0,0 +1,9 @@
+export * from './const.ts';
+export * from './databaseDialect.ts';
+export * from './dto/index.ts';
+export * from './entity.ts';
+export * from './model.ts';
+export * from './relations.ts';
+export * from './relationsDynamic.ts';
+export * from './relationsMutate.ts';
+export * from './relationsStatic.ts';

package/src/lib/model.ts

@@ -0,0 +1,7 @@
+import { createBeanDecorator } from 'vona';
+
+import type { IDecoratorModelOptions } from '../types/onion/model.ts';
+
+export function Model<T extends IDecoratorModelOptions>(options?: T): ClassDecorator {
+  return createBeanDecorator('model', options);
+}