vona-module-a-orm 5.0.96 → 5.1.2

package/src/types/relationsDefDynamic.ts

@@ -0,0 +1,128 @@
+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 { IModelClassRecord } from './onion/model.ts';
+import type { TypeModelClassLike, TypeModelOfModelLike, TypeModelsClassLikeGeneral, TypeSymbolKeyEntity } from './relations.ts';
+import type { TypeEntityTableColumnNamesOfGeneral, TypeEntityTableColumnsOfGeneral } from './relationsColumns.ts';
+import type { IModelRelationOptionsMetaWrapper } from './relationsDef.ts';
+import type { TypeModelSelectGroupParamsColumnNames } from './relationsGroup.ts';
+import type { TypeEntityTableNamesOfGeneral } from './relationsTables.ts';
+
+// export type TypeModelRelationDynamic<MODELSelf extends BeanModelMeta | undefined, MODELTarget extends BeanModelMeta> =
+//   IModelRelationHasOneDynamic<MODELTarget> |
+//   IModelRelationBelongsToDynamic<MODELSelf, MODELTarget> |
+//   IModelRelationHasManyDynamic<MODELTarget>;
+
+// use optional ? for app config
+export interface IModelRelationHasOneDynamic<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined,
+> {
+  type?: 'hasOne';
+  model?: TypeModelClassLike<MODEL>;
+  key?: KEY;
+  options?: OPTIONS;
+}
+
+export interface IModelRelationBelongsToDynamic<
+  MODELSelf extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  OPTIONS extends IModelRelationOptionsOneDynamic<TypeModelOfModelLike<MODEL>> | undefined = undefined,
+> {
+  type?: 'belongsTo';
+  model?: TypeModelClassLike<MODEL>;
+  key?: keyof TypeModelOfModelLike<MODELSelf>[TypeSymbolKeyEntity];
+  options?: OPTIONS;
+}
+
+export interface IModelRelationHasManyDynamic<
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  KEY extends keyof TypeModelOfModelLike<MODEL>[TypeSymbolKeyEntity],
+  OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+> {
+  type?: 'hasMany';
+  model?: TypeModelClassLike<MODEL>;
+  key?: KEY;
+  options?: OPTIONS;
+}
+
+export interface IModelRelationBelongsToManyDynamic<
+  MODELMiddle extends BeanModelMeta | keyof IModelClassRecord,
+  MODEL extends BeanModelMeta | keyof IModelClassRecord,
+  OPTIONS extends IModelRelationOptionsManyDynamic<TypeModelOfModelLike<MODEL>, ModelJoins, Group> | undefined = undefined,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+> {
+  type?: 'belongsToMany';
+  modelMiddle?: TypeModelClassLike<MODELMiddle>;
+  model?: TypeModelClassLike<MODEL>;
+  keyFrom?: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity];
+  keyTo?: keyof TypeModelOfModelLike<MODELMiddle>[TypeSymbolKeyEntity];
+  options?: OPTIONS;
+}
+
+export interface IModelRelationOptionsOneDynamic<MODEL extends BeanModelMeta>
+  extends IModelRelationOptionsMetaWrapper, IModelRelationIncludeWrapper<MODEL> {
+  columns?: TypeModelColumnsPatch<MODEL[TypeSymbolKeyEntity], TypeModelColumn<MODEL[TypeSymbolKeyEntity]>>;
+}
+
+export interface IModelRelationOptionsManyDynamic<
+  MODEL extends BeanModelMeta,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+>
+  extends
+    IModelRelationOptionsMetaWrapper,
+    IModelRelationIncludeWrapper<MODEL>,
+    Omit<IModelRelationOptionsManyDynamic_Raw<MODEL, false, TypeModelColumn<MODEL[TypeSymbolKeyEntity]>, ModelJoins, Group>, 'autoload'> {}
+
+export type IModelRelationOptionsManyDynamic_Raw<
+  MODEL extends BeanModelMeta,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<MODEL[TypeSymbolKeyEntity]> = TypeModelColumn<MODEL[TypeSymbolKeyEntity]>,
+  ModelJoins extends TypeModelsClassLikeGeneral | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+> = IBuildModelRelationOptionsManyDynamic<
+  MODEL[TypeSymbolKeyEntity],
+  AUTOLOAD,
+  COLUMNS,
+  TypeEntityTableNamesOfGeneral<ModelJoins, MODEL>,
+  TypeEntityTableColumnNamesOfGeneral<ModelJoins, MODEL>,
+  TypeEntityTableColumnsOfGeneral<ModelJoins, MODEL>,
+  Group
+>;
+
+export interface IBuildModelRelationOptionsManyDynamic<
+  TRecord,
+  AUTOLOAD extends boolean = false,
+  COLUMNS extends TypeModelColumn<TRecord> = TypeModelColumn<TRecord>,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+> extends IBuildModelSelectGeneralParamsBasicDynamic<TRecord, COLUMNS, TableNames, ColumnNames, Columns, Group> {
+  autoload?: AUTOLOAD;
+}
+
+export interface IBuildModelSelectGeneralParamsBasicDynamic<
+  TRecord,
+  COLUMNS extends TypeModelColumn<TRecord> = TypeModelColumn<TRecord>,
+  TableNames = undefined,
+  ColumnNames = keyof TRecord,
+  Columns extends {} | undefined = undefined,
+  Group extends boolean | undefined = undefined,
+> {
+  distinct?: boolean | keyof TRecord | (keyof TRecord)[];
+  columns?: TypeModelColumnsPatch<TRecord, COLUMNS>;
+  aggrs?: TypeModelSelectAggrParamsAggrs<TRecord>;
+  groups?: TypeModelColumnsStrict<TRecord>;
+  where?: TypeModelWhere<TRecord, Columns>;
+  joins?: IModelSelectParamsJoin<TRecord, TableNames, ColumnNames>[];
+  orders?: Group extends true ? IModelSelectParamsOrder<TypeModelSelectGroupParamsColumnNames<TRecord>>[] : IModelSelectParamsOrder<ColumnNames>[];
+  limit?: number;
+  offset?: number;
+}

package/src/types/relationsDefMutate.ts

@@ -0,0 +1,11 @@
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IModelRelationIncludeWrapper } from './model.ts';
+import type { IModelRelationOptionsMetaWrapper } from './relationsDef.ts';
+
+export interface IModelRelationOptionsOneMutate<MODEL extends BeanModelMeta>
+  extends IModelRelationOptionsMetaWrapper, IModelRelationIncludeWrapper<MODEL> {}
+
+export interface IModelRelationOptionsManyMutate<MODEL extends BeanModelMeta>
+  extends IModelRelationOptionsMetaWrapper, IModelRelationIncludeWrapper<MODEL> {}
+
+export interface IModelRelationOptionsBelongsToManyMutate<_MODEL extends BeanModelMeta> extends IModelRelationOptionsMetaWrapper {}

package/src/types/relationsGroup.ts

@@ -0,0 +1,58 @@
+import type { TypeModelSelectAggrParamsAggrs } from './modelAggr.ts';
+import type { TypeModelColumnsStrict } from './modelWhere.ts';
+import type { TypeUtilGetParamsAggrs, TypeUtilGetParamsColumns, TypeUtilGetParamsGroups, TypeUtilGetRelationOptionsGroups } from './relations.ts';
+import type {
+  TypeModelAggrRelationResultAggr,
+  TypeModelAggrRelationResultAggrs,
+  TypeRecordAggrsValues,
+  TypeRecordAggrsValuesToObject,
+  TypeUtilAggrPrepareColumns,
+} from './relationsAggr.ts';
+
+export type TypeModelGroupRelationResult<TRecord, TOptions> = TypeModelGroupRelationResultGroups<
+  TRecord,
+  TypeUtilGetParamsAggrs<TOptions>,
+  TypeUtilGetParamsGroups<TOptions>,
+  TypeUtilGetParamsColumns<TOptions>
+>;
+
+export type TypeModelGroupRelationResultGroups<TRecord, Aggrs, Groups, Columns> = Groups extends string | string[]
+  ? TypeModelGroupRelationResultGroupsObject<TRecord, Groups, Columns> &
+      (Aggrs extends {}
+        ? TypeRecordAggrsValuesToObject<
+            TypeRecordAggrsValues<{
+              [K in keyof Aggrs]: K extends string ? TypeModelAggrRelationResultAggr<K, TypeUtilAggrPrepareColumns<Aggrs[K]>> : never;
+            }>
+          >
+        : {})
+  : {}; // not use undefined
+
+export type TypeModelGroupRelationResultGroupsObject<TRecord, Groups, Columns> = Columns extends string | string[]
+  ? { [K in TypeUtilAggrPrepareColumns<Columns>]: K extends keyof TRecord ? TRecord[K] : never }
+  : Groups extends string | string[]
+    ? { [K in TypeUtilAggrPrepareColumns<Groups>]: K extends keyof TRecord ? TRecord[K] : never }
+    : {};
+
+export type TypeModelSelectGroupParamsColumnNames<
+  TRecord,
+  ColumnNames extends TypeModelColumnsStrict<TRecord> | undefined = TypeModelColumnsStrict<TRecord>,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> | undefined = TypeModelSelectAggrParamsAggrs<TRecord>,
+> =
+  | (ColumnNames extends TypeModelColumnsStrict<TRecord> ? TypeUtilAggrPrepareColumns<ColumnNames> : never)
+  | (Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> ? keyof TypeModelAggrRelationResultAggrs<Aggrs> : never);
+
+export type TypeModelSelectGroupParamsColumns<
+  TRecord,
+  ColumnNames extends TypeModelColumnsStrict<TRecord> | undefined = TypeModelColumnsStrict<TRecord>,
+  Aggrs extends TypeModelSelectAggrParamsAggrs<TRecord> | undefined = TypeModelSelectAggrParamsAggrs<TRecord>,
+> = (TypeUtilAggrPrepareColumns<ColumnNames> extends string
+  ? { [K in TypeUtilAggrPrepareColumns<ColumnNames>]: K extends keyof TRecord ? TRecord[K] : never }
+  : {}) &
+  TypeModelAggrRelationResultAggrsToNumberType<TypeModelAggrRelationResultAggrs<Aggrs>>;
+
+export type TypeModelAggrRelationResultAggrsToNumberType<Columns> = { [K in keyof Columns]: string }; // not use BigNumber or number | string
+
+export type TypeUtilGetGroupsFromRelationAndIncludeWrapper<Relation, IncludeWrapper extends {} | undefined | unknown> =
+  TypeUtilGetParamsGroups<IncludeWrapper> extends string | string[]
+    ? TypeUtilGetParamsGroups<IncludeWrapper>
+    : TypeUtilGetRelationOptionsGroups<Relation>;

package/src/types/relationsMutate.ts

@@ -0,0 +1,118 @@
+import type { TableIdentity } from 'table-identity';
+import type { OmitNever } from 'vona';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IDecoratorModelOptions } from './onion/model.ts';
+import type {
+  TypeUtilGetModelOptions,
+  TypeUtilGetParamsInlcude,
+  TypeUtilGetParamsWith,
+  TypeUtilGetRelationEntity,
+  TypeUtilGetRelationModel,
+  TypeUtilGetRelationOptions,
+  TypeUtilGetRelationOptionsAutoload,
+  TypeUtilGetRelationType,
+} from './relations.ts';
+import type { IModelRelationOptionsMetaWrapper } from './relationsDef.ts';
+
+export type TypeModelMutateParamsInclude<MODEL extends BeanModelMeta | undefined> = TypeModelMutateParamsIncludeByModelOptions<
+  TypeUtilGetModelOptions<MODEL>
+>;
+
+export type TypeModelMutateParamsIncludeByModelOptions<ModelOptions extends IDecoratorModelOptions | undefined> =
+  ModelOptions extends IDecoratorModelOptions
+    ? {
+        [relationName in keyof ModelOptions['relations']]?: TypeModelMutateParamsRelationOptions<ModelOptions['relations'][relationName]>;
+      }
+    : never;
+
+export type TypeModelMutateParamsRelationOptions<Relation> =
+  | boolean
+  | (IModelRelationOptionsMetaWrapper & {
+      include?: TypeModelMutateParamsInclude<TypeUtilGetRelationModel<Relation>>;
+      with?: Record<string, unknown>;
+    });
+
+export type TypeModelMutateRelationResultMergeInclude<
+  TModelOptions extends IDecoratorModelOptions,
+  TInclude extends {} | undefined | unknown,
+  TForInsertResult extends boolean | undefined = undefined,
+> = {
+  [RelationName in keyof TModelOptions['relations']]: TInclude extends {} // not use ?: for OmitNever take effect
+    ? TInclude[RelationName] extends {} | boolean
+      ? TypeModelMutateRelationResultMergeIncludeWrapper<TModelOptions['relations'][RelationName], TInclude[RelationName], TForInsertResult>
+      : TypeModelMutateRelationResultMergeAutoload<TModelOptions['relations'][RelationName], TForInsertResult>
+    : TypeModelMutateRelationResultMergeAutoload<TModelOptions['relations'][RelationName], TForInsertResult>;
+};
+
+export type TypeModelMutateRelationResultMergeAutoload<Relation, TForInsertResult extends boolean | undefined = undefined> =
+  TypeUtilGetRelationOptionsAutoload<Relation> extends true ? TypeUtilMutateGetRelationEntityByType<Relation, undefined, TForInsertResult> : never;
+
+export type TypeModelMutateRelationResultMergeIncludeWrapper<
+  Relation,
+  IncludeWrapper,
+  TForInsertResult extends boolean | undefined = undefined,
+> = IncludeWrapper extends false
+  ? never
+  : IncludeWrapper extends true
+    ? TypeUtilMutateGetRelationEntityByType<Relation, undefined, TForInsertResult>
+    : IncludeWrapper extends {}
+      ? TypeUtilMutateGetRelationEntityByType<Relation, IncludeWrapper, TForInsertResult>
+      : never;
+
+export type TypeUtilMutateGetRelationEntityByType<
+  Relation,
+  IncludeWrapper extends {} | undefined | unknown,
+  TForInsertResult extends boolean | undefined = undefined,
+> = TypeUtilMutateGetEntityByType<
+  TypeUtilGetRelationEntity<Relation>,
+  TypeUtilGetRelationType<Relation>,
+  TypeUtilGetRelationModel<Relation>,
+  IncludeWrapper,
+  TForInsertResult
+>;
+
+export type TypeUtilMutateGetEntityByType<
+  TRecord,
+  TYPE,
+  TModel extends BeanModelMeta | undefined,
+  IncludeWrapper extends {} | undefined | unknown,
+  TForInsertResult extends boolean | undefined = undefined,
+> = TYPE extends 'belongsTo'
+  ? never
+  : TYPE extends 'belongsToMany'
+    ? Array<{ id: TableIdentity; deleted?: boolean }> | undefined
+    : TYPE extends 'hasMany'
+      ? Array<TypeModelMutateRelationData<TRecord, TModel, IncludeWrapper, TForInsertResult>> | undefined
+      : TypeModelMutateRelationData<TRecord, TModel, IncludeWrapper, TForInsertResult> | undefined;
+
+export type TypeModelMutateRelationResultMergeWith<
+  TWith extends {} | undefined | unknown,
+  TForInsertResult extends boolean | undefined = undefined,
+> = TWith extends {} ? { [RelationName in keyof TWith]: TypeModelMutateRelationResultMergeWithRelation<TWith[RelationName], TForInsertResult> } : {};
+
+export type TypeModelMutateRelationResultMergeWithRelation<
+  WithRelation,
+  TForInsertResult extends boolean | undefined = undefined,
+> = WithRelation extends false
+  ? never
+  : WithRelation extends true
+    ? never
+    : WithRelation extends {}
+      ? TypeUtilMutateGetRelationEntityByType<WithRelation, TypeUtilGetRelationOptions<WithRelation>, TForInsertResult>
+      : never;
+
+export type TypeModelMutateRelationData<
+  TRecord,
+  TModel extends BeanModelMeta | undefined,
+  TOptionsRelation,
+  TForInsertResult extends boolean | undefined = undefined,
+> = (TForInsertResult extends true ? TRecord : Partial<TRecord>) &
+  (TModel extends BeanModelMeta
+    ? Partial<
+        OmitNever<
+          TypeModelMutateRelationResultMergeInclude<TypeUtilGetModelOptions<TModel>, TypeUtilGetParamsInlcude<TOptionsRelation>, TForInsertResult>
+        >
+      > &
+        Partial<OmitNever<TypeModelMutateRelationResultMergeWith<TypeUtilGetParamsWith<TOptionsRelation>, TForInsertResult>>>
+    : {});

package/src/types/relationsTables.ts

@@ -0,0 +1,38 @@
+import type { TypeConfirmArray, TypeRecordValues } from 'vona';
+
+import type { BeanModelMeta } from '../bean/bean.model/bean.model_meta.ts';
+import type { IDecoratorModelOptions } from './onion/model.ts';
+import type {
+  TypeModelOfModelLike,
+  TypeModelsClassLikeGeneral,
+  TypeSymbolKeyEntityMeta,
+  TypeUtilGetModelOptions,
+  TypeUtilGetRelationEntityMeta,
+} from './relations.ts';
+
+export type TypeEntityTableNames<EntityMeta extends { $table: string } | undefined> = EntityMeta extends { $table: infer TableName }
+  ? TableName
+  : never;
+
+export type TypeEntityTableNamesOfModelOptions<TModelOptions extends IDecoratorModelOptions> = TModelOptions['relations'] extends {}
+  ? TypeRecordValues<{
+      [RelationName in keyof TModelOptions['relations']]: TypeEntityTableNames<
+        TypeUtilGetRelationEntityMeta<TModelOptions['relations'][RelationName]>
+      >;
+    }>
+  : never;
+
+export type TypeEntityTableNamesOfModelJoins<TModelJoins extends TypeModelsClassLikeGeneral> = TypeEntityTableNames<
+  TypeModelOfModelLike<TypeConfirmArray<TModelJoins>[number]>[TypeSymbolKeyEntityMeta]
+>;
+
+export type TypeEntityTableNamesOfModelClass<TModel extends BeanModelMeta> = TypeEntityTableNamesOfModelOptions<TypeUtilGetModelOptions<TModel>>;
+
+export type TypeEntityTableNamesOfGeneral<
+  TModelJoins extends TypeModelsClassLikeGeneral | undefined,
+  TModel extends BeanModelMeta | undefined,
+> = TModel extends BeanModelMeta
+  ? TModelJoins extends TypeModelsClassLikeGeneral
+    ? TypeEntityTableNamesOfModelJoins<TModelJoins>
+    : TypeEntityTableNamesOfModelClass<TModel>
+  : undefined;

package/src/types/transaction.ts

@@ -0,0 +1,23 @@
+export const TransactionIsolationLevelsMap = {
+  DEFAULT: undefined,
+  READ_UNCOMMITTED: 'read uncommitted',
+  READ_COMMITTED: 'read committed',
+  REPEATABLE_READ: 'repeatable read',
+  SERIALIZABLE: 'serializable',
+  SNAPSHOT: 'snapshot',
+};
+
+export type TypeTransactionIsolationLevels = 'DEFAULT' | 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE' | 'SNAPSHOT';
+
+export type TypeTransactionPropagation = 'REQUIRED' | 'SUPPORTS' | 'MANDATORY' | 'REQUIRES_NEW' | 'NOT_SUPPORTED' | 'NEVER';
+
+// export type TransactionPropagation=''
+export interface ITransactionOptions {
+  isolationLevel?: TypeTransactionIsolationLevels;
+  readOnly?: boolean;
+  propagation?: TypeTransactionPropagation;
+}
+
+export interface ITransactionConsistencyCommitOptions {
+  ignoreIfNotInTransaction?: boolean;
+}