@ez4/database 0.26.0 → 0.28.0

package/dist/services/order.d.ts

@@ -1,6 +1,6 @@
-import type { DecomposeIndexName } from './indexes.js';
-import type { TableMetadata } from './table.js';
-import type { Database } from './database.js';
+import type { DecomposeIndexName } from './indexes';
+import type { TableMetadata } from './table';
+import type { Database } from './database';
 /**
  * Query order types.
  */
@@ -16,9 +16,9 @@ export declare const enum OrderMode {
     AnyColumns = "any"
 }
 /**
- * Order utils.
+ * Order mode utils.
  */
-export declare namespace OrderUtils {
+export declare namespace OrderModeUtils {
     /**
      * Order input for index columns.
      */

package/dist/services/pagination.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseEngine, EngineUtils } from './engine.js';
+import type { DatabaseEngine, EngineUtils } from './engine';
 /**
  * Pagination mode.
  */
@@ -7,9 +7,9 @@ export declare const enum PaginationMode {
     Offset = "offset"
 }
 /**
- * Pagination utils.
+ * Pagination mode utils.
  */
-export declare namespace PaginationUtils {
+export declare namespace PaginationModeUtils {
     /**
      * Get the pagination range based on the given database engine.
      */

package/dist/services/parameters.d.ts

@@ -1,5 +1,5 @@
-import type { EngineUtils } from './engine.js';
-import type { Database } from './database.js';
+import type { EngineUtils } from './engine';
+import type { Database } from './database';
 /**
  * Parameters mode.
  */
@@ -8,9 +8,9 @@ export declare const enum ParametersMode {
     OnlyIndex = "index"
 }
 /**
- * Parameters utils.
+ * Parameters mode utils.
  */
-export declare namespace ParametersUtils {
+export declare namespace ParametersModeUtils {
     /**
      * Get the parameters type based on the given database service.
      */

package/dist/services/query.d.ts

@@ -1,12 +1,13 @@
-import type { DecomposeIndexName, PrimaryIndexes, UniqueIndexes } from './indexes.js';
-import type { DatabaseEngine } from './engine.js';
-import type { RelationMetadata } from './relations.js';
-import type { InsensitiveUtils } from './insensitive.js';
-import type { PaginationUtils } from './pagination.js';
-import type { TableMetadata } from './table.js';
-import type { OrderUtils } from './order.js';
-import type { Database } from './database.js';
-import type { AnyObject, PartialProperties, PartialObject, FlatObject, OptionalObject, StrictObject, IsNullable, IsObjectEmpty, IsObject, IsArray, Prettify } from '@ez4/utils';
+import type { DecomposeIndexName, PrimaryIndexes, UniqueIndexes } from './indexes';
+import type { DatabaseEngine } from './engine';
+import type { RelationMetadata } from './relations';
+import type { InsensitiveModeUtils } from './insensitive';
+import type { PaginationModeUtils } from './pagination';
+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, IsUndefined, IsObjectEmpty, IsObject, IsArray, Prettify } from '@ez4/utils';
 /**
  * Query builder types.
  */
@@ -16,17 +17,20 @@ export declare namespace Query {
         data: Prettify<InsertDataInput<T>>;
     };
     export type UpdateOneInput<S extends AnyObject, T extends TableMetadata> = {
+        lock?: LockModeUtils.Input<T>;
         select?: StrictSelectInput<S, T>;
         include?: StrictIncludeInput<S, T>;
         data: Prettify<OptionalObject<UpdateDataInput<T>>>;
         where: WhereInput<T, true>;
     };
     export type FindOneInput<S extends AnyObject, T extends TableMetadata> = {
+        lock?: LockModeUtils.Input<T>;
         select: StrictSelectInput<S, T>;
         include?: StrictIncludeInput<S, T>;
         where: WhereInput<T, true>;
     };
     export type UpsertOneInput<S extends AnyObject, T extends TableMetadata> = {
+        lock?: LockModeUtils.Input<T>;
         select?: StrictSelectInput<S, T>;
         include?: StrictIncludeInput<S, T>;
         update: Prettify<OptionalObject<UpdateDataInput<T>>>;
@@ -41,20 +45,22 @@ export declare namespace Query {
     export type InsertManyInput<T extends TableMetadata> = {
         data: Prettify<T['schema']>[];
     };
-    export type UpdateManyInput<S extends AnyObject, T extends TableMetadata> = PaginationUtils.End<T['engine']> & {
+    export type UpdateManyInput<S extends AnyObject, T extends TableMetadata> = PaginationModeUtils.End<T['engine']> & {
+        lock?: LockModeUtils.Input<T>;
         select?: StrictSelectInput<S, T>;
         include?: StrictIncludeInput<S, T>;
         data: Prettify<OptionalObject<UpdateDataInput<T>>>;
         where?: WhereInput<T>;
     };
-    export type FindManyInput<S extends AnyObject, C extends boolean, T extends TableMetadata> = PaginationUtils.Range<T['engine']> & {
+    export type FindManyInput<S extends AnyObject, C extends boolean, T extends TableMetadata> = PaginationModeUtils.Range<T['engine']> & {
+        lock?: LockModeUtils.Input<T>;
         select: StrictSelectInput<S, T>;
         include?: StrictIncludeInput<S, T>;
         where?: WhereInput<T>;
         order?: OrderInput<T>;
         count?: C;
     };
-    export type DeleteManyInput<S extends AnyObject, T extends TableMetadata> = PaginationUtils.End<T['engine']> & {
+    export type DeleteManyInput<S extends AnyObject, T extends TableMetadata> = PaginationModeUtils.End<T['engine']> & {
         select?: StrictSelectInput<S, T>;
         include?: StrictIncludeInput<S, T>;
         where?: WhereInput<T>;
@@ -62,30 +68,30 @@ export declare namespace Query {
     export type CountInput<T extends TableMetadata> = {
         where?: WhereInput<T>;
     };
-    export type InsertOneResult<S extends AnyObject, T extends TableMetadata> = Query.SelectInput<T> extends S ? void : Record<S, T>;
-    export type UpdateOneResult<S extends AnyObject, T extends TableMetadata> = Query.SelectInput<T> extends S ? void : Record<S, T> | undefined;
-    export type FindOneResult<S extends AnyObject, T extends TableMetadata> = Query.SelectInput<T> extends S ? void : Record<S, T> | undefined;
-    export type UpsertOneResult<S extends AnyObject, T extends TableMetadata> = Query.SelectInput<T> extends S ? void : Record<S, T>;
-    export type DeleteOneResult<S extends AnyObject, T extends TableMetadata> = Query.SelectInput<T> extends S ? void : Record<S, T> | undefined;
-    export type UpdateManyResult<S extends AnyObject, T extends TableMetadata> = Query.SelectInput<T> extends S ? void : Record<S, T>[];
+    export type InsertOneResult<S extends AnyObject, T extends TableMetadata> = SelectInput<T> extends S ? void : Record<S, T>;
+    export type UpdateOneResult<S extends AnyObject, T extends TableMetadata> = SelectInput<T> extends S ? void : Record<S, T> | undefined;
+    export type FindOneResult<S extends AnyObject, T extends TableMetadata> = SelectInput<T> extends S ? void : Record<S, T> | undefined;
+    export type UpsertOneResult<S extends AnyObject, T extends TableMetadata> = SelectInput<T> extends S ? void : Record<S, T>;
+    export type DeleteOneResult<S extends AnyObject, T extends TableMetadata> = SelectInput<T> extends S ? void : Record<S, T> | undefined;
+    export type UpdateManyResult<S extends AnyObject, T extends TableMetadata> = SelectInput<T> extends S ? void : Record<S, T>[];
     export type InsertManyResult = void;
-    export type FindManyResult<S extends AnyObject, C extends boolean, T extends TableMetadata> = PaginationUtils.Result<T['engine']> & {
-        records: Query.SelectInput<T> extends S ? void : Record<S, T>[];
+    export type FindManyResult<S extends AnyObject, C extends boolean, T extends TableMetadata> = PaginationModeUtils.Result<T['engine']> & {
+        records: SelectInput<T> extends S ? void : Record<S, T>[];
     } & (false extends C ? {} : {
         total: number;
     });
-    export type DeleteManyResult<S extends AnyObject, T extends TableMetadata> = Query.SelectInput<T> extends S ? void : Record<S, T>[];
-    export type Record<S extends AnyObject, T extends TableMetadata> = PartialObject<SelectFields<T['schema'], T['relations']>, S>;
-    export type SelectInput<T extends TableMetadata> = PartialProperties<SelectFields<T['schema'], T['relations']>>;
-    export type StrictSelectInput<S extends AnyObject, T extends TableMetadata> = StrictObject<S, FlatObject<SelectFields<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 OrderInput<T extends TableMetadata> = OrderUtils.Input<T>;
+    export type DeleteManyResult<S extends AnyObject, T extends TableMetadata> = SelectInput<T> extends S ? void : Record<S, T>[];
+    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']['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<T['relations']['filters'][P], T['engine']> : never;
+        [P in keyof T['relations']['filters']]?: P extends keyof S ? StrictIncludeRelation<NonNullable<T['relations']['filters'][P]>, T['engine']> : never;
     };
-    export type StrictIncludeOrder<V extends AnyObject> = OrderUtils.AnyInput<V>;
-    export type StrictIncludeRelation<V extends AnyObject, E extends DatabaseEngine> = PaginationUtils.Range<E> & {
+    export type StrictIncludeOrder<V extends AnyObject> = OrderModeUtils.AnyInput<V>;
+    export type StrictIncludeRelation<V extends AnyObject, E extends DatabaseEngine> = PaginationModeUtils.Range<E> & {
         where?: WhereRelationField<V, E>;
         order?: StrictIncludeOrder<V>;
     };
@@ -94,7 +100,8 @@ export declare namespace Query {
         AND?: WhereInput<T>[];
         OR?: WhereInput<T>[];
     }>;
-    type SelectFields<T extends Database.Schema, R extends RelationMetadata> = IsObjectEmpty<R['selects']> extends true ? T : T & R['selects'];
+    type SelectInputFields<T extends Database.Schema, R extends RelationMetadata> = IsObjectEmpty<R['selects']> extends true ? T : T & R['selects'];
+    type SelectOutputFields<T extends Database.Schema, R extends RelationMetadata> = IsObjectEmpty<R['records']> extends true ? T : T & R['records'];
     type WhereOperations<V, E extends DatabaseEngine> = WhereNegate<V, E> | WhereEqual<V, E> | WhereGreaterThan<V> | WhereGreaterThanOrEqual<V> | WhereLessThan<V> | WhereLessThanOrEqual<V> | WhereIn<V> | WhereBetween<V> | WhereIsMissing | WhereIsNull | WhereStartsWith<E> | WhereContains<V, E>;
     type WhereField<V, E extends DatabaseEngine> = IsObject<V> extends false ? V | WhereOperations<V, E> : IsNullable<V> extends true ? null | WhereObjectField<NonNullable<V>, E> : WhereObjectField<NonNullable<V>, E>;
     type WhereObjectField<V extends AnyObject, E extends DatabaseEngine> = {
@@ -120,10 +127,10 @@ export declare namespace Query {
     type WhereCommonFilters<V extends AnyObject, T extends TableMetadata, I extends Database.Indexes> = IsObjectEmpty<I> extends true ? WhereObjectField<V, T['engine']> : WhereRequiredFilters<V, I> & WhereOptionalFilters<V, T, I>;
     type WhereInputFilters<T extends TableMetadata, I extends Database.Indexes> = WhereCommonFilters<T['schema'], T, I> & (IsObjectEmpty<T['relations']['filters']> extends false ? WhereRelationFilters<T['relations']['filters'], T['engine']> : {});
     export type WhereOperators = keyof (WhereNegate<any, never> & WhereEqual<any, never> & WhereGreaterThan<any> & WhereGreaterThanOrEqual<any> & WhereLessThan<any> & WhereLessThanOrEqual<any> & WhereIn<any> & WhereBetween<any> & WhereIsMissing & WhereIsNull & WhereStartsWith<never> & WhereContains<any, never>);
-    type WhereNegate<V, E extends DatabaseEngine> = (V extends string ? InsensitiveUtils.Input<E> : {}) & {
+    type WhereNegate<V, E extends DatabaseEngine> = (V extends string ? InsensitiveModeUtils.Input<E> : {}) & {
         not: V;
     };
-    type WhereEqual<V, E extends DatabaseEngine> = (V extends string ? InsensitiveUtils.Input<E> : {}) & {
+    type WhereEqual<V, E extends DatabaseEngine> = (V extends string ? InsensitiveModeUtils.Input<E> : {}) & {
         equal: V;
     };
     type WhereGreaterThan<V> = {
@@ -150,20 +157,20 @@ export declare namespace Query {
     type WhereIsNull = {
         isNull: boolean;
     };
-    type WhereStartsWith<E extends DatabaseEngine> = InsensitiveUtils.Input<E> & {
+    type WhereStartsWith<E extends DatabaseEngine> = InsensitiveModeUtils.Input<E> & {
         startsWith: string;
     };
-    type WhereContains<V, E extends DatabaseEngine> = (V extends string ? InsensitiveUtils.Input<E> : {}) & {
+    type WhereContains<V, E extends DatabaseEngine> = (V extends string ? InsensitiveModeUtils.Input<E> : {}) & {
         contains: IsObject<V> extends true ? Partial<V> : V;
     };
     export type AtomicOperators = keyof (AtomicIncrement & AtomicDecrement & AtomicMultiply & AtomicDivide);
     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,14 +1,16 @@
-import type { AnyObject, ArrayRest, PropertyType, ExclusiveType, IsArrayEmpty, IsUndefined } from '@ez4/utils';
-import type { IndexedTables, PrimaryIndexes, UniqueIndexes } from './indexes.js';
-import type { Database, DatabaseTables } from './database.js';
-import type { TableSchemas } from './schemas.js';
+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';
 /**
  * Internal relation type.
  */
 export type RelationMetadata = {
-    filters: Record<string, {}>;
-    selects: Record<string, {}>;
-    changes: Record<string, {}>;
+    filters: Record<string, AnyObject | undefined>;
+    updates: Record<string, AnyObject | undefined>;
+    inserts: Record<string, AnyObject | undefined>;
+    selects: Record<string, AnyObject | undefined>;
+    records: Record<string, AnyObject | undefined>;
     indexes: string;
 };
 /**
@@ -30,70 +32,138 @@ export type RelationTargetAlias<T> = T extends `${string}@${infer U}` ? U : neve
 /**
  * Given a database service `T`, it produces an object with all relation tables.
  */
-export type RelationTables<T extends Database.Service> = MergeRelations<DatabaseTables<T>, TableSchemas<T>, IndexedTables<T>>;
+export type RelationTables<T extends Database.Service> = MergeRelations<DatabaseTables<T>, DatabaseTables<T>, TableSchemas<T>, IndexedTables<T>>;
 /**
  * Given a list of tables with relations `T`, it produces an object containing all the
  * relation tables.
  */
-type MergeRelations<T extends Database.Table[], S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = IsArrayEmpty<T> extends false ? TableRelation<T[0], S, I> & MergeRelations<ArrayRest<T>, S, I> : {};
+type MergeRelations<T extends Database.Table[], C extends Database.Table[], S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = IsArrayEmpty<C> extends false ? TableRelation<T, C[0], S, I> & MergeRelations<T, ArrayRest<C>, S, I> : {};
 /**
  * Given a database table `T`, it produces an object containing all its relations.
  */
-type TableRelation<T, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = T extends {
+type TableRelation<T extends Database.Table[], C extends Database.Table, S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>> = C extends {
     name: infer N;
     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: RequiredRelationSchemas<PropertyType<N, S>, S, I, R, false> & OptionalRelationSchemas<PropertyType<N, S>, S, I, R, false>;
+        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 only required relation schemas.
+ * Produce an object containing relation schemas for updates.
  */
-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 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 optional relation schemas.
+ * Produce an object containing relation schemas for inserts.
  */
-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 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>;
 };
 /**
- * Check whether a relation is optional or not.
+ * Produce an object containing relation schemas for selects.
+ */
+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 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 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;
+};
+/**
+ * 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/dist/services/schemas.d.ts

@@ -1,5 +1,5 @@
 import type { ArrayRest, IsArrayEmpty } from '@ez4/utils';
-import type { Database, DatabaseTables } from './database.js';
+import type { Database, DatabaseTables } from './database';
 /**
  * Given a database service `T`, it produces an object containing all tables with schemas.
  */

package/dist/services/table.d.ts

@@ -1,10 +1,10 @@
 import type { AnyObject, PropertyExists } from '@ez4/utils';
-import type { RelationMetadata, RelationTables } from './relations.js';
-import type { IndexedTables } from './indexes.js';
-import type { TableSchemas } from './schemas.js';
-import type { Database } from './database.js';
-import type { DatabaseEngine } from './engine.js';
-import type { Query } from './query.js';
+import type { RelationMetadata, RelationTables } from './relations';
+import type { IndexedTables } from './indexes';
+import type { TableSchemas } from './schemas';
+import type { Database } from './database';
+import type { DatabaseEngine } from './engine';
+import type { Query } from './query';
 /**
  * Given an indexed table `T` and a property `P`, it returns all the indexes corresponding
  * to the given property.

package/dist/services/transaction.d.ts

@@ -1,11 +1,11 @@
-import type { TableIndex, TableMetadata, TableRelation } from './table.js';
-import type { RelationTables } from './relations.js';
-import type { IndexedTables } from './indexes.js';
-import type { EngineUtils } from './engine.js';
-import type { TableSchemas } from './schemas.js';
-import type { Database } from './database.js';
-import type { Client } from './client.js';
-import type { Query } from './query.js';
+import type { TableIndex, TableMetadata, TableRelation } from './table';
+import type { RelationTables } from './relations';
+import type { IndexedTables } from './indexes';
+import type { EngineUtils } from './engine';
+import type { TableSchemas } from './schemas';
+import type { Database } from './database';
+import type { Client } from './client';
+import type { Query } from './query';
 /**
  * Transaction mode.
  */
@@ -14,9 +14,9 @@ export declare const enum TransactionMode {
     Static = "static"
 }
 /**
- * Transaction utils.
+ * Transaction mode utils.
  */
-export declare namespace TransactionUtils {
+export declare namespace TransactionModeUtils {
     /**
      * Extract the operation result from an interactive transaction.
      */

package/dist/types/engine.d.ts

@@ -1,13 +1,15 @@
-import type { ParametersMode } from '../services/parameters.js';
-import type { TransactionMode } from '../services/transaction.js';
-import type { InsensitiveMode } from '../services/insensitive.js';
-import type { PaginationMode } from '../services/pagination.js';
-import type { OrderMode } from '../services/order.js';
+import type { ParametersMode } from '../services/parameters';
+import type { TransactionMode } from '../services/transaction';
+import type { InsensitiveMode } from '../services/insensitive';
+import type { PaginationMode } from '../services/pagination';
+import type { OrderMode } from '../services/order';
+import type { LockMode } from '../services/lock';
 export type DatabaseEngine = {
     parametersMode: ParametersMode;
     transactionMode: TransactionMode;
     insensitiveMode: InsensitiveMode;
     paginationMode: PaginationMode;
     orderMode: OrderMode;
+    lockMode: LockMode;
     name: string;
 };

package/dist/types/indexes.d.ts

@@ -1,4 +1,4 @@
-import type { Index } from '../services/indexes.js';
+import type { Index } from '../services/indexes';
 export type TableIndex = {
     name: string;
     columns: string[];

package/dist/types/relations.d.ts

@@ -1,4 +1,4 @@
-import type { Index } from '../services/indexes.js';
+import type { Index } from '../services/indexes';
 export type TableRelation = {
     sourceTable: string;
     sourceColumn: string;

package/dist/types/service.d.ts

@@ -1,7 +1,7 @@
 import type { ServiceMetadata } from '@ez4/project/library';
-import type { DatabaseScalability } from './scalability.js';
-import type { DatabaseEngine } from './engine.js';
-import type { DatabaseTable } from './table.js';
+import type { DatabaseScalability } from './scalability';
+import type { DatabaseEngine } from './engine';
+import type { DatabaseTable } from './table';
 export declare const ServiceType = "@ez4/database";
 export type DatabaseService = ServiceMetadata & {
     type: typeof ServiceType;

package/dist/types/stream.d.ts

@@ -1,6 +1,6 @@
 import type { LinkedVariables } from '@ez4/project/library';
 import type { ServiceListener } from '@ez4/common/library';
-import type { StreamHandler } from './handler.js';
+import type { StreamHandler } from './handler';
 export type TableStream = {
     listener?: ServiceListener;
     handler: StreamHandler;

package/dist/types/table.d.ts

@@ -1,7 +1,7 @@
-import type { TableRelation } from './relations.js';
-import type { TableIndex } from './indexes.js';
-import type { TableSchema } from './schema.js';
-import type { TableStream } from './stream.js';
+import type { TableRelation } from './relations';
+import type { TableIndex } from './indexes';
+import type { TableSchema } from './schema';
+import type { TableStream } from './stream';
 export type DatabaseTable = {
     name: string;
     schema: TableSchema;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ez4/database",
   "description": "EZ4: Components to build database services",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "author": "Silas B.",
   "license": "MIT",
   "type": "module",
@@ -11,7 +11,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/sbalmt/ez4.git",
-    "directory": "packages/database"
+    "directory": "contracts/database"
   },
   "engines": {
     "node": ">=22.7"
@@ -29,24 +29,23 @@
     }
   },
   "workspaces": [
-    "packages/*"
+    "foundation/*",
+    "contracts/*"
   ],
   "scripts": {
     "lint": "eslint --cache",
     "clean": "rm -f *.tsbuildinfo && rm -rf dist/*",
-    "build": "tsc -p tsconfig.json && node tools/bundler.mjs",
-    "test": "npm run test:types && node --test --import ../../tools/tsnode.mjs test/*.spec.ts",
-    "test:only": "npm run test:types && node --test-only --test --import ../../tools/tsnode.mjs test/*.spec.ts",
-    "test:types": "npm run build && tsc -p tsconfig.test.json",
+    "build": "tsc && node tools/bundler.mjs",
+    "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.26.0",
-    "@ez4/project": "^0.26.0",
-    "@ez4/reflection": "^0.26.0",
-    "@ez4/schema": "^0.26.0",
-    "@ez4/utils": "^0.26.0"
+    "@ez4/common": "^0.28.0",
+    "@ez4/project": "^0.28.0",
+    "@ez4/reflection": "^0.28.0",
+    "@ez4/schema": "^0.28.0",
+    "@ez4/utils": "^0.28.0"
   }
 }