@ez4/database 0.25.0 → 0.27.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,11 +1,12 @@
-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 { 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, 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, T extends TableMetadata, C extends boolean> = PaginationUtils.Range<T['engine']> & {
-        count?: C;
+    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,31 +68,30 @@ export declare namespace Query {
     export type CountInput<T extends TableMetadata> = {
         where?: WhereInput<T>;
     };
-    export type InsertOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T>;
-    export type UpdateOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T> | undefined;
-    export type FindOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T> | undefined;
-    export type UpsertOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T>;
-    export type DeleteOneResult<S extends AnyObject, T extends TableMetadata> = S extends never ? void : Record<S, T> | undefined;
-    export type UpdateManyResult<S extends AnyObject, T extends TableMetadata> = S extends never ? 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, T extends TableMetadata, C extends boolean> = PaginationUtils.Result<T['engine']> & (C extends true ? {
-        records: 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;
-    } : {
-        records: Record<S, T>[];
     });
-    export type DeleteManyResult<S extends AnyObject, T extends TableMetadata> = Record<S, T>[];
-    export type Record<S extends AnyObject, T extends TableMetadata> = S extends never ? undefined : 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 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']['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 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>;
     };
@@ -95,8 +100,9 @@ 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 WhereOperations<V, E extends DatabaseEngine> = WhereNegate<V> | WhereEqual<V> | WhereGreaterThan<V> | WhereGreaterThanOrEqual<V> | WhereLessThan<V> | WhereLessThanOrEqual<V> | WhereIn<V> | WhereBetween<V> | WhereIsMissing | WhereIsNull | WhereStartsWith<E> | WhereContains<V, E>;
+    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> = {
         [P in keyof V]?: WhereField<V[P], E>;
@@ -120,11 +126,11 @@ 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> & WhereEqual<any> & WhereGreaterThan<any> & WhereGreaterThanOrEqual<any> & WhereLessThan<any> & WhereLessThanOrEqual<any> & WhereIn<any> & WhereBetween<any> & WhereIsMissing & WhereIsNull & WhereStartsWith<never> & WhereContains<any, never>);
-    type WhereNegate<V> = {
+    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 ? InsensitiveModeUtils.Input<E> : {}) & {
         not: V;
     };
-    type WhereEqual<V> = {
+    type WhereEqual<V, E extends DatabaseEngine> = (V extends string ? InsensitiveModeUtils.Input<E> : {}) & {
         equal: V;
     };
     type WhereGreaterThan<V> = {
@@ -151,10 +157,10 @@ 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);

package/dist/services/relations.d.ts

@@ -1,14 +1,15 @@
-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, FlatObject, MergeObject } 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>;
+    selects: Record<string, AnyObject | undefined>;
+    changes: Record<string, AnyObject | undefined>;
+    records: Record<string, AnyObject | undefined>;
     indexes: string;
 };
 /**
@@ -30,16 +31,16 @@ 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 ? {
@@ -47,7 +48,8 @@ type TableRelation<T, S extends Record<string, Database.Schema>, I extends Recor
         indexes: RelationIndexes<PropertyType<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>;
+        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>>;
     };
 } : {} : {} : {};
 /**
@@ -74,6 +76,22 @@ type RequiredRelationSchemas<T extends Database.Schema, S extends Record<string,
 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>;
 };
+/**
+ * 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 {
+        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 {
+        records: infer N;
+    } ? N : never : never;
+};
 /**
  * Check whether a relation is optional or not.
  */

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.
@@ -44,7 +44,7 @@ export interface Table<T extends TableMetadata> {
      *
      * @param query Input query.
      */
-    insertOne<S extends Query.SelectInput<T> = never>(query: Query.InsertOneInput<S, T>): Promise<Query.InsertOneResult<S, T>>;
+    insertOne<S extends Query.SelectInput<T>>(query: Query.InsertOneInput<S, T>): Promise<Query.InsertOneResult<S, T>>;
     /**
      * Find one database record.
      *
@@ -56,19 +56,19 @@ export interface Table<T extends TableMetadata> {
      *
      * @param query Input query.
      */
-    updateOne<S extends Query.SelectInput<T> = never>(query: Query.UpdateOneInput<S, T>): Promise<Query.UpdateOneResult<S, T>>;
+    updateOne<S extends Query.SelectInput<T>>(query: Query.UpdateOneInput<S, T>): Promise<Query.UpdateOneResult<S, T>>;
     /**
      * Try to insert a database record, and if it already exists, perform an update instead.
      *
      * @param query Input query.
      */
-    upsertOne<S extends Query.SelectInput<T> = never>(query: Query.UpsertOneInput<S, T>): Promise<Query.UpsertOneResult<S, T>>;
+    upsertOne<S extends Query.SelectInput<T>>(query: Query.UpsertOneInput<S, T>): Promise<Query.UpsertOneResult<S, T>>;
     /**
      * Delete one database record.
      *
      * @param query Input query.
      */
-    deleteOne<S extends Query.SelectInput<T> = never>(query: Query.DeleteOneInput<S, T>): Promise<Query.DeleteOneResult<S, T>>;
+    deleteOne<S extends Query.SelectInput<T>>(query: Query.DeleteOneInput<S, T>): Promise<Query.DeleteOneResult<S, T>>;
     /**
      * Insert multiple records into the database.
      *
@@ -80,19 +80,19 @@ export interface Table<T extends TableMetadata> {
      *
      * @param query Input query.
      */
-    findMany<S extends Query.SelectInput<T>, C extends boolean = false>(query: Query.FindManyInput<S, T, C>): Promise<Query.FindManyResult<S, T, C>>;
+    findMany<S extends Query.SelectInput<T>, C extends boolean>(query: Query.FindManyInput<S, C, T>): Promise<Query.FindManyResult<S, C, T>>;
     /**
      * Update multiple database records.
      *
      * @param query Input query.
      */
-    updateMany<S extends Query.SelectInput<T> = never>(query: Query.UpdateManyInput<S, T>): Promise<Query.UpdateManyResult<S, T>>;
+    updateMany<S extends Query.SelectInput<T>>(query: Query.UpdateManyInput<S, T>): Promise<Query.UpdateManyResult<S, T>>;
     /**
      * Delete multiple database records.
      *
      * @param query Input query.
      */
-    deleteMany<S extends Query.SelectInput<T> = never>(query: Query.DeleteManyInput<S, T>): Promise<Query.DeleteManyResult<S, T>>;
+    deleteMany<S extends Query.SelectInput<T>>(query: Query.DeleteManyInput<S, T>): Promise<Query.DeleteManyResult<S, T>>;
     /**
      * Count database records.
      *

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.25.0",
+  "version": "0.27.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 && 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 publish --access public"
+    "live:publish": "npm run build && npm publish --access public"
   },
   "dependencies": {
-    "@ez4/common": "^0.25.0",
-    "@ez4/project": "^0.25.0",
-    "@ez4/reflection": "^0.25.0",
-    "@ez4/schema": "^0.25.0",
-    "@ez4/utils": "^0.25.0"
+    "@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"
   }
 }