@ez4/database 0.27.0 → 0.29.0

package/dist/services/query.d.ts

@@ -7,7 +7,7 @@ import type { OrderModeUtils } from './order';
 import type { LockModeUtils } from './lock';
 import type { TableMetadata } from './table';
 import type { Database } from './database';
-import type { AnyObject, PartialProperties, PartialObject, FlatObject, OptionalObject, StrictObject, IsNullable, IsObjectEmpty, IsObject, IsArray, Prettify } from '@ez4/utils';
+import type { AnyObject, PartialProperties, PartialObject, FlatObject, OptionalObject, StrictObject, IsNullable, IsUndefined, IsObjectEmpty, IsObject, IsArray, Prettify } from '@ez4/utils';
 /**
  * Query builder types.
  */
@@ -84,8 +84,8 @@ export declare namespace Query {
     export type Record<S extends AnyObject, T extends TableMetadata> = PartialObject<SelectOutputFields<T['schema'], T['relations']>, S>;
     export type SelectInput<T extends TableMetadata> = PartialProperties<SelectInputFields<T['schema'], T['relations']>>;
     export type StrictSelectInput<S extends AnyObject, T extends TableMetadata> = StrictObject<S, SelectInputFields<T['schema'], T['relations']>>;
-    export type InsertDataInput<T extends TableMetadata> = IsObjectEmpty<T['relations']['changes']> extends false ? Omit<T['schema'] & T['relations']['changes'], T['relations']['indexes']> : T['schema'];
-    export type UpdateDataInput<T extends TableMetadata> = AtomicDataInput<IsObjectEmpty<T['relations']['changes']> extends false ? Omit<T['schema'] & FlatObject<T['relations']['changes']>, T['relations']['indexes']> : T['schema']>;
+    export type InsertDataInput<T extends TableMetadata> = IsObjectEmpty<T['relations']['inserts']> extends false ? Omit<T['schema'], T['relations']['indexes']> & T['relations']['inserts'] : T['schema'];
+    export type UpdateDataInput<T extends TableMetadata> = IsObjectEmpty<T['relations']['updates']> extends false ? AtomicDataInput<Omit<T['schema'], T['relations']['indexes']> & FlatObject<T['relations']['updates']>> : AtomicDataInput<T['schema']>;
     export type OrderInput<T extends TableMetadata> = OrderModeUtils.Input<T>;
     export type StrictIncludeInput<S extends AnyObject, T extends TableMetadata> = IsObjectEmpty<T['relations']['filters']> extends true ? never : {
         [P in keyof T['relations']['filters']]?: P extends keyof S ? StrictIncludeRelation<NonNullable<T['relations']['filters'][P]>, T['engine']> : never;
@@ -167,10 +167,10 @@ export declare namespace Query {
     type AtomicDataInput<T extends AnyObject> = AtomicRequiredFields<T> & AtomicOptionalFields<T>;
     type AtomicDataField<T> = T extends number ? AtomicOperation | T : T extends AnyObject ? AtomicDataInput<T> : NonNullable<T> extends AnyObject ? null | AtomicDataInput<NonNullable<T>> : T;
     type AtomicRequiredFields<T extends AnyObject> = {
-        [P in keyof T as T[P] extends undefined ? never : P]: AtomicDataField<T[P]>;
+        [P in keyof T as IsUndefined<T[P]> extends true ? never : P]: AtomicDataField<T[P]>;
     };
     type AtomicOptionalFields<T extends AnyObject> = {
-        [P in keyof T as T[P] extends undefined ? P : never]?: AtomicDataField<T[P]>;
+        [P in keyof T as IsUndefined<T[P]> extends true ? P : never]?: AtomicDataField<T[P]>;
     };
     type AtomicOperation = AtomicIncrement | AtomicDecrement | AtomicMultiply | AtomicDivide;
     type AtomicIncrement = {

package/dist/services/relations.d.ts

@@ -1,4 +1,4 @@
-import type { AnyObject, ArrayRest, PropertyType, ExclusiveType, IsArrayEmpty, IsUndefined, FlatObject, MergeObject } from '@ez4/utils';
+import type { AnyObject, ArrayRest, PropertyType, ExclusiveType, IsArrayEmpty, IsUndefined, MergeObject, Prettify } from '@ez4/utils';
 import type { IndexedTables, PrimaryIndexes, UniqueIndexes } from './indexes';
 import type { Database, DatabaseTables } from './database';
 import type { TableSchemas } from './schemas';
@@ -7,8 +7,9 @@ import type { TableSchemas } from './schemas';
  */
 export type RelationMetadata = {
     filters: Record<string, AnyObject | undefined>;
+    updates: Record<string, AnyObject | undefined>;
+    inserts: Record<string, AnyObject | undefined>;
     selects: Record<string, AnyObject | undefined>;
-    changes: Record<string, AnyObject | undefined>;
     records: Record<string, AnyObject | undefined>;
     indexes: string;
 };
@@ -45,73 +46,124 @@ type TableRelation<T extends Database.Table[], C extends Database.Table, S exten
     relations: infer R;
 } ? N extends string ? R extends AnyObject ? {
     [P in N]: {
-        indexes: RelationIndexes<PropertyType<N, I>, R>;
+        indexes: RelationIndexes<N, I, R>;
         filters: FilterableRelationSchemas<S, R>;
-        changes: RequiredRelationSchemas<PropertyType<N, S>, S, I, R, true> & OptionalRelationSchemas<PropertyType<N, S>, S, I, R, true>;
-        selects: FlatObject<RequiredRelationSchemas<PropertyType<N, S>, S, I, R, false>> & FlatObject<OptionalRelationSchemas<PropertyType<N, S>, S, I, R, false>> & NestedRelationSelects<T, S, I, R>;
-        records: MergeObject<RequiredRelationSchemas<PropertyType<N, S>, S, I, R, false> & OptionalRelationSchemas<PropertyType<N, S>, S, I, R, false>, NestedRelationRecords<T, S, I, R>>;
+        updates: UpdateRelationSchemas<N, S, I, R>;
+        inserts: InsertRelationSchemas<N, PropertyType<N, S>, S, I, R>;
+        selects: SelectRelationSchemas<S, I, R> & NestedSelectRelationSchemas<T, S, I, R>;
+        records: MergeObject<RecordsRelationSchemas<PropertyType<N, S>, S, I, R>, NestedRecordsRelationSchemas<T, S, I, R>>;
     };
 } : {} : {} : {};
+/**
+ * Check whether the given column is a primary index.
+ */
+type IsPrimarySourceIndex<C, I extends Record<string, Database.Indexes>> = RelationSourceColumn<C> extends keyof PrimaryIndexes<PropertyType<RelationSourceTable<C>, I>> ? true : false;
+/**
+ * Check whether the given column is a unique index.
+ */
+type IsUniqueSourceIndex<C, I extends Record<string, Database.Indexes>> = RelationSourceColumn<C> extends keyof UniqueIndexes<PropertyType<RelationSourceTable<C>, I>> ? true : false;
+/**
+ * Check whether the given column is a primary target index.
+ */
+type IsPrimaryTargetIndex<V, I extends Database.Indexes> = RelationTargetColumn<V> extends keyof PrimaryIndexes<I> ? true : false;
+/**
+ * Check whether the given column is a unique target index.
+ */
+export type IsUniqueTargetIndex<V, I extends Database.Indexes> = RelationTargetColumn<V> extends keyof UniqueIndexes<I> ? true : false;
+/**
+ * Check whether the given column is a secondary target index.
+ */
+type IsSecondaryTargetIndex<V, I extends Database.Indexes> = RelationTargetColumn<V> extends keyof (PrimaryIndexes<I> & UniqueIndexes<I>) ? false : true;
+/**
+ * Check whether a relation is optional or not.
+ */
+type IsOptionalRelation<C, V, T extends Database.Schema, I extends Record<string, Database.Indexes>, E extends boolean> = IsPrimarySourceIndex<C, I> extends true ? IsUndefined<PropertyType<RelationTargetColumn<V>, T>> : IsUniqueSourceIndex<C, I> extends true ? true : E;
 /**
  * Produce an object containing all relation indexes.
  */
-type RelationIndexes<I extends Database.Indexes, R extends AnyObject> = keyof {
-    [C in keyof R as RelationTargetColumn<C> extends keyof PrimaryIndexes<I> ? never : RelationTargetColumn<C>]: never;
+type RelationIndexes<N, I extends Record<string, Database.Indexes>, R extends AnyObject> = keyof {
+    [P in keyof R as IsRelationIndex<N, R[P], P, I> extends true ? RelationTargetColumn<P> : never]: never;
 };
 /**
- * Produce an object containing all filterable relation schemas.
+ * Check whether the given source and target columns are used to index the relation.
+ */
+type IsRelationIndex<N, C, V, I extends Record<string, Database.Indexes>> = IsPrimarySourceIndex<C, I> extends false ? IsSecondaryTargetIndex<V, PropertyType<N, I>> extends false ? IsUniqueTargetIndex<V, PropertyType<N, I>> extends true ? IsUniqueSourceIndex<C, I> : false : true : true;
+/**
+ * Produce an object containing relation schemas for filters.
  */
 type FilterableRelationSchemas<S extends Record<string, Database.Schema>, R extends AnyObject> = {
-    [C in keyof R as RelationTargetAlias<C>]: Omit<PropertyType<RelationSourceTable<R[C]>, S>, RelationSourceColumn<R[C]>>;
+    [P in keyof R as RelationTargetAlias<P>]: Omit<PropertyType<RelationSourceTable<R[P]>, S>, RelationSourceColumn<R[P]>>;
+};
+/**
+ * Produce an object containing relation schemas for updates.
+ */
+type UpdateRelationSchemas<N, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
+    [P in keyof R as RelationTargetAlias<P>]?: ChangeRelationSchema<N, R[P], P, S, I>;
 };
 /**
- * Produce an object containing only required relation schemas.
+ * Produce an object containing relation schemas for inserts.
  */
-type RequiredRelationSchemas<T extends Database.Schema, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject, E extends boolean> = {
-    [C in keyof R as IsOptionalRelation<R[C], C, T, I, E> extends false ? RelationTargetAlias<C> : never]: RelationSchema<R[C], C, T, S, I, E>;
+type InsertRelationSchemas<N, T extends Database.Schema, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
+    [P in keyof R as IsOptionalRelation<R[P], P, T, I, true> extends true ? RelationTargetAlias<P> : never]?: ChangeRelationSchema<N, R[P], P, S, I>;
+} & {
+    [P in keyof R as IsOptionalRelation<R[P], P, T, I, true> extends false ? RelationTargetAlias<P> : never]: ChangeRelationSchema<N, R[P], P, S, I>;
 };
 /**
- * Produce an object containing only optional relation schemas.
+ * Produce an object containing relation schemas for selects.
  */
-type OptionalRelationSchemas<T extends Database.Schema, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject, E extends boolean> = {
-    [C in keyof R as IsOptionalRelation<R[C], C, T, I, E> extends true ? RelationTargetAlias<C> : never]?: RelationSchema<R[C], C, T, S, I, E>;
+type SelectRelationSchemas<S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
+    [P in keyof R as RelationTargetAlias<P>]?: SelectRelationSchema<R[P], S, I>;
+};
+/**
+ * Produce an object containing relation schemas for records.
+ */
+type RecordsRelationSchemas<T extends Database.Schema, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
+    [P in keyof R as IsOptionalRelation<R[P], P, T, I, false> extends true ? RelationTargetAlias<P> : never]?: RecordRelationSchema<R[P], S, I>;
+} & {
+    [P in keyof R as IsOptionalRelation<R[P], P, T, I, false> extends false ? RelationTargetAlias<P> : never]: RecordRelationSchema<R[P], S, I>;
 };
 /**
  * Produce an object containing all nested relation schemas for select operations.
  */
-type NestedRelationSelects<T extends Database.Table[], S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
-    [C in keyof R as RelationTargetAlias<C>]?: RelationSourceTable<R[C]> extends keyof MergeRelations<T, T, S, I> ? MergeRelations<T, T, S, I>[RelationSourceTable<R[C]>] extends {
+type NestedSelectRelationSchemas<T extends Database.Table[], S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
+    [P in keyof R as RelationTargetAlias<P>]?: RelationSourceTable<R[P]> extends keyof MergeRelations<T, T, S, I> ? MergeRelations<T, T, S, I>[RelationSourceTable<R[P]>] extends {
         selects: infer N;
     } ? N : never : never;
 };
 /**
  * Produce an object containing all nested relation schemas for records.
  */
-type NestedRelationRecords<T extends Database.Table[], S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
-    [C in keyof R as RelationTargetAlias<C>]?: RelationSourceTable<R[C]> extends keyof MergeRelations<T, T, S, I> ? MergeRelations<T, T, S, I>[RelationSourceTable<R[C]>] extends {
+type NestedRecordsRelationSchemas<T extends Database.Table[], S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
+    [P in keyof R as RelationTargetAlias<P>]?: RelationSourceTable<R[P]> extends keyof MergeRelations<T, T, S, I> ? MergeRelations<T, T, S, I>[RelationSourceTable<R[P]>] extends {
         records: infer N;
     } ? N : never : never;
 };
 /**
- * Check whether a relation is optional or not.
+ * Produce a type corresponding to the source column schema.
+ */
+type SourceColumnSchema<C, S extends Record<string, Database.Schema>> = PropertyType<RelationSourceTable<C>, S>;
+/**
+ * Produce a change relation schema according to its indexation.
  */
-type IsOptionalRelation<C, V, T extends Database.Schema, I extends Record<string, Database.Indexes>, E extends boolean> = RelationSourceColumn<C> extends keyof PrimaryIndexes<PropertyType<RelationSourceTable<C>, I>> ? IsUndefined<PropertyType<RelationTargetColumn<V>, T>> : RelationSourceColumn<C> extends keyof UniqueIndexes<PropertyType<RelationSourceTable<C>, I>> ? true : E;
+type ChangeRelationSchema<N, C, V, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = IsPrimarySourceIndex<C, I> extends true ? ExclusiveType<SourceColumnSchema<C, S>, PrimaryKeyConnectionSchema<C, S, I>> : IsUniqueSourceIndex<C, I> extends true ? IsPrimaryTargetIndex<V, PropertyType<N, I>> extends true ? ExclusiveType<Omit<SourceColumnSchema<C, S>, RelationSourceColumn<C>>, UniqueKeyConnectionSchema<C, S, I>> : ExclusiveType<SourceColumnSchema<C, S>, UniqueKeyConnectionSchema<C, S, I>> : ExclusiveType<Omit<SourceColumnSchema<C, S>, RelationSourceColumn<C>>, PrimaryKeyConnectionSchema<C, S, I>>[];
 /**
- * Check whether a column is primary.
+ * Produce a select relation schema according to its indexation.
  */
-type IsPrimaryIndex<C, I extends Record<string, Database.Indexes>> = RelationSourceColumn<C> extends keyof PrimaryIndexes<PropertyType<RelationSourceTable<C>, I>> ? true : false;
+type SelectRelationSchema<C, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = IsPrimarySourceIndex<C, I> extends true ? SourceColumnSchema<C, S> : IsUniqueSourceIndex<C, I> extends true ? SourceColumnSchema<C, S> : SourceColumnSchema<C, S>;
 /**
- * Check whether a column is unique.
+ * Produce a record relation schema according to its indexation.
  */
-type IsUniqueIndex<C, I extends Record<string, Database.Indexes>> = RelationSourceColumn<C> extends keyof UniqueIndexes<PropertyType<RelationSourceTable<C>, I>> ? true : false;
+type RecordRelationSchema<C, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = IsPrimarySourceIndex<C, I> extends true ? SourceColumnSchema<C, S> : IsUniqueSourceIndex<C, I> extends true ? SourceColumnSchema<C, S> : SourceColumnSchema<C, S>[];
 /**
- * Produce a type corresponding to the source index column type.
+ * Produce a relation schema for connections using primary keys.
  */
-type ExtractSourceIndexType<C, S extends Record<string, Database.Schema>> = PropertyType<RelationSourceTable<C>, S>;
+type PrimaryKeyConnectionSchema<C, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = Prettify<{
+    [P in keyof PrimaryIndexes<PropertyType<RelationSourceTable<C>, I>>]: PropertyType<P, PropertyType<RelationSourceTable<C>, S>> | undefined | null;
+}>;
 /**
- * Produce a relation schema according to its indexation.
+ * Produce a relation schema for connections using unique keys.
  */
-type RelationSchema<C, V, T extends Database.Schema, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, E extends boolean> = IsPrimaryIndex<C, I> extends true ? E extends false ? ExtractSourceIndexType<C, S> : ExclusiveType<ExtractSourceIndexType<C, S>, {
-    [P in RelationTargetColumn<V>]: PropertyType<RelationTargetColumn<V>, T>;
-}> : IsUniqueIndex<C, I> extends true ? E extends false ? ExtractSourceIndexType<C, S> : Omit<ExtractSourceIndexType<C, S>, RelationSourceColumn<C>> : Omit<ExtractSourceIndexType<C, S>, RelationSourceColumn<C>>[];
+type UniqueKeyConnectionSchema<C, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = Prettify<{
+    [P in keyof UniqueIndexes<PropertyType<RelationSourceTable<C>, I>> as P extends RelationSourceColumn<C> ? P : never]: PropertyType<P, PropertyType<RelationSourceTable<C>, S>> | undefined | null;
+}>;
 export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ez4/database",
   "description": "EZ4: Components to build database services",
-  "version": "0.27.0",
+  "version": "0.29.0",
   "author": "Silas B.",
   "license": "MIT",
   "type": "module",
@@ -36,16 +36,16 @@
     "lint": "eslint --cache",
     "clean": "rm -f *.tsbuildinfo && rm -rf dist/*",
     "build": "tsc && node tools/bundler.mjs",
-    "test": "npm run build && ez4 test",
+    "test": "npm run build && tsc -p tsconfig.test.json && ez4 test",
     "local:publish": "npm run build && npm run clean:registry && npm publish --registry http://localhost:4873",
     "clean:registry": "rm -rf ../../.registry/@ez4/database",
     "live:publish": "npm run build && npm publish --access public"
   },
   "dependencies": {
-    "@ez4/common": "^0.27.0",
-    "@ez4/project": "^0.27.0",
-    "@ez4/reflection": "^0.27.0",
-    "@ez4/schema": "^0.27.0",
-    "@ez4/utils": "^0.27.0"
+    "@ez4/common": "^0.29.0",
+    "@ez4/project": "^0.29.0",
+    "@ez4/reflection": "^0.29.0",
+    "@ez4/schema": "^0.29.0",
+    "@ez4/utils": "^0.29.0"
   }
 }