@ez4/database 0.10.0 → 0.12.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Silas B.
+Copyright (c) 2025 Silas B.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/main.d.ts

@@ -1,8 +1,8 @@
 export * from './services/streams.js';
 export { Client } from './services/client.js';
-export { Database } from './services/database.js';
+export { RelationMetadata } from './services/relations.js';
 export { Transaction } from './services/transaction.js';
-export { Relations } from './services/relations.js';
+export { Database } from './services/database.js';
 export { Index } from './services/indexes.js';
 export { Table } from './services/table.js';
 export { Query } from './services/query.js';

package/dist/services/query.d.ts

@@ -1,93 +1,115 @@
-import type { Relations } from './relations.js';
+import type { RelationMetadata } from './relations.js';
 import type { Database } from './database.js';
 import type { Order } from './order.js';
 import type { DecomposeIndexName, DecomposePrimaryIndexNames, DecomposeUniqueIndexNames } from './indexes.js';
-import type { AnyObject, PartialProperties, PartialObject, DeepPartial, FlatObject, IsObject, StrictType } from '@ez4/utils';
+import type { AnyObject, PartialProperties, PartialObject, FlatObject, OptionalObject, StrictObject, IsNullable, IsObjectEmpty, IsObject } from '@ez4/utils';
 /**
  * Query builder types.
  */
 export declare namespace Query {
-    export type InsertOneInput<T extends Database.Schema, R extends Relations> = {
-        data: Omit<T, R['indexes']> & R['changes'];
-    };
-    export type UpdateOneInput<T extends Database.Schema, S extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> = {
-        select?: StrictType<SelectInput<T, R>, S>;
-        data: DeepPartial<Omit<T, R['indexes']> & FlatObject<R['changes']>>;
-        where: WhereInput<T, I>;
-    };
-    export type FindOneInput<T extends Database.Schema, S extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> = {
-        select: StrictType<SelectInput<T, R>, S>;
-        where: WhereInput<T, I>;
-    };
-    export type UpsertOneInput<T extends Database.Schema, S extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> = {
-        select?: StrictType<SelectInput<T, R>, S>;
-        insert: Omit<T, R['indexes']> & R['changes'];
-        update: DeepPartial<Omit<T, R['indexes']> & FlatObject<R['changes']>>;
-        where: WhereInput<T, I>;
-    };
-    export type DeleteOneInput<T extends Database.Schema, S extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> = {
-        select?: StrictType<SelectInput<T, R>, S>;
-        where: WhereInput<T, I>;
-    };
-    export type InsertManyInput<T extends Database.Schema> = {
+    export type InsertOneInput<T extends Database.Schema, R extends RelationMetadata> = {
+        data: InsertDataInput<T, R>;
+    };
+    export type UpdateOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes<T>, R extends RelationMetadata> = {
+        select?: StrictSelectInput<T, S, R>;
+        include?: StrictIncludeInput<S, R>;
+        data: OptionalObject<UpdateDataInput<T, R>>;
+        where: WhereInput<T, I, R>;
+    };
+    export type FindOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes<T>, R extends RelationMetadata> = {
+        select: StrictSelectInput<T, S, R>;
+        include?: StrictIncludeInput<S, R>;
+        where: WhereInput<T, I, R>;
+    };
+    export type UpsertOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes<T>, R extends RelationMetadata> = {
+        select?: StrictSelectInput<T, S, R>;
+        include?: StrictIncludeInput<S, R>;
+        update: OptionalObject<UpdateDataInput<T, R>>;
+        insert: InsertDataInput<T, R>;
+        where: WhereInput<T, I, R>;
+    };
+    export type DeleteOneInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes<T>, R extends RelationMetadata> = {
+        select?: StrictSelectInput<T, S, R>;
+        include?: StrictIncludeInput<S, R>;
+        where: WhereInput<T, I, R>;
+    };
+    export type InsertManyInput<T extends Database.Schema = {}> = {
         data: T[];
     };
-    export type UpdateManyInput<T extends Database.Schema, S extends Database.Schema, R extends Relations> = {
-        select?: StrictType<SelectInput<T, R>, S>;
-        data: DeepPartial<Omit<T, R['indexes']> & FlatObject<R['changes']>>;
-        where?: WhereInput<T>;
+    export type UpdateManyInput<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = {
+        select?: StrictSelectInput<T, S, R>;
+        include?: StrictIncludeInput<S, R>;
+        data: OptionalObject<UpdateDataInput<T, R>>;
+        where?: WhereInput<T, {}, R>;
         limit?: number;
     };
-    export type FindManyInput<T extends Database.Schema, S extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> = {
-        select: StrictType<SelectInput<T, R>, S>;
-        where?: WhereInput<T>;
+    export type FindManyInput<T extends Database.Schema, S extends AnyObject, I extends Database.Indexes<T>, R extends RelationMetadata> = {
+        select: StrictSelectInput<T, S, R>;
+        include?: StrictIncludeInput<S, R>;
+        where?: WhereInput<T, {}, R>;
         order?: OrderInput<I>;
         cursor?: number | string;
         limit?: number;
     };
-    export type DeleteManyInput<T extends Database.Schema, S extends Database.Schema, R extends Relations> = {
-        select?: StrictType<SelectInput<T, R>, S>;
-        where?: WhereInput<T>;
+    export type DeleteManyInput<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = {
+        select?: StrictSelectInput<T, S, R>;
+        include?: StrictIncludeInput<S, R>;
+        where?: WhereInput<T, {}, R>;
         limit?: number;
     };
     export type InsertOneResult = void;
-    export type UpdateOneResult<T extends Database.Schema, S extends AnyObject, R extends Relations> = Record<T, S, R> | undefined;
-    export type FindOneResult<T extends Database.Schema, S extends AnyObject, R extends Relations> = Record<T, S, R> | undefined;
-    export type UpsertOneResult<T extends Database.Schema, S extends AnyObject, R extends Relations> = Record<T, S, R> | undefined;
-    export type DeleteOneResult<T extends Database.Schema, S extends AnyObject, R extends Relations> = Record<T, S, R> | undefined;
+    export type UpdateOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = Record<T, S, R> | undefined;
+    export type FindOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = Record<T, S, R> | undefined;
+    export type UpsertOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = Record<T, S, R> | undefined;
+    export type DeleteOneResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = Record<T, S, R> | undefined;
     export type InsertManyResult = void;
-    export type UpdateManyResult<T extends Database.Schema, S extends AnyObject, R extends Relations> = Record<T, S, R>[];
-    export type FindManyResult<T extends Database.Schema, S extends AnyObject, R extends Relations> = {
+    export type UpdateManyResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = Record<T, S, R>[];
+    export type FindManyResult<T extends Database.Schema, S extends Database.Schema, R extends RelationMetadata> = {
         records: Record<T, S, R>[];
         cursor?: number | string;
     };
-    export type DeleteManyResult<T extends Database.Schema, S extends AnyObject, R extends Relations> = Record<T, S, R>[];
-    export type Record<T extends Database.Schema, S extends AnyObject, R extends Relations> = PartialObject<T & R['selects'], S, false>;
-    export type SelectInput<T extends Database.Schema, R extends Relations> = PartialProperties<T & R['selects']>;
+    export type DeleteManyResult<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = Record<T, S, R>[];
+    export type Record<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = PartialObject<SelectFields<T, R>, S, false>;
+    export type SelectInput<T extends Database.Schema, R extends RelationMetadata> = PartialProperties<SelectFields<T, R>>;
+    export type StrictSelectInput<T extends Database.Schema, S extends AnyObject, R extends RelationMetadata> = StrictObject<S, FlatObject<SelectFields<T, R>>>;
+    export type InsertDataInput<T extends Database.Schema, R extends RelationMetadata> = Omit<IsObjectEmpty<R['changes']> extends true ? T : T & R['changes'], IndexFields<R>>;
+    export type UpdateDataInput<T extends Database.Schema, R extends RelationMetadata> = Omit<IsObjectEmpty<R['changes']> extends true ? T : T & FlatObject<R['changes']>, IndexFields<R>>;
+    export type StrictIncludeInput<S extends AnyObject, R extends RelationMetadata> = IsObjectEmpty<R['filters']> extends true ? never : IncludeFilters<R['filters'], S>;
     export type OrderInput<I extends Database.Indexes> = {
         [P in DecomposeIndexName<keyof I>]?: Order;
     };
-    export type WhereInput<T extends Database.Schema, I extends Database.Indexes<T> = {}> = WhereFields<T, I> & WhereNot<T, I> & WhereAnd<T, I> & WhereOr<T, I>;
+    export type WhereInput<T extends Database.Schema, I extends Database.Indexes<T>, R extends RelationMetadata> = WhereInputFilters<T, I, R> & WhereNot<WhereInputFilters<T, I, R>> & WhereAnd<WhereInputFilters<T, I, R>> & WhereOr<WhereInputFilters<T, I, R>>;
     export type WhereOperators = keyof (WhereNegate<any> & WhereEqual<any> & WhereGreaterThan<any> & WhereGreaterThanOrEqual<any> & WhereLessThan<any> & WhereLessThanOrEqual<any> & WhereIn<any> & WhereBetween<any> & WhereIsMissing & WhereIsNull & WhereStartsWith & WhereContains);
+    type IndexFields<R extends RelationMetadata> = string extends R['indexes'] ? never : R['indexes'];
+    type SelectFields<T extends Database.Schema, R extends RelationMetadata> = IsObjectEmpty<R['selects']> extends true ? T : T & R['selects'];
+    type IncludeFilters<T extends AnyObject, S extends AnyObject> = {
+        [P in keyof T]?: P extends keyof S ? IsObject<T[P]> extends true ? null | WhereRelationField<NonNullable<T[P]>> : never : never;
+    };
     type WhereOperations<T> = WhereNegate<T> | WhereEqual<T> | WhereGreaterThan<T> | WhereGreaterThanOrEqual<T> | WhereLessThan<T> | WhereLessThanOrEqual<T> | WhereIn<T> | WhereBetween<T> | WhereIsMissing | WhereIsNull | WhereStartsWith | WhereContains;
-    type WherePrimaryFields<T extends Database.Schema, I extends Database.Indexes<T>> = {
-        [P in DecomposePrimaryIndexNames<I>]: P extends keyof T ? IsObject<T[P]> extends true ? WhereFields<NonNullable<T[P]>, I> : T[P] | WhereOperations<T[P]> : never;
+    type WhereField<T> = IsObject<T> extends false ? T | WhereOperations<T> : IsNullable<T> extends true ? null | WhereObjectField<NonNullable<T>> : WhereObjectField<NonNullable<T>>;
+    type WhereObjectField<T extends AnyObject> = {
+        [P in keyof T]?: WhereField<T[P]>;
+    };
+    type WhereRelationField<T extends AnyObject> = WhereObjectField<T> & WhereNot<WhereObjectField<T>> & WhereAnd<WhereObjectField<T>> & WhereOr<WhereObjectField<T>>;
+    type WhereRelationFilters<T extends AnyObject> = {
+        [P in keyof T]?: IsObject<T[P]> extends true ? IsObjectEmpty<T[P]> extends false ? null | WhereRelationField<NonNullable<T[P]>> : null | {} : never;
     };
-    type WhereUniqueFields<T extends Database.Schema, I extends Database.Indexes<T>> = {
-        [P in DecomposeUniqueIndexNames<I>]: P extends keyof T ? IsObject<T[P]> extends true ? WhereFields<NonNullable<T[P]>, I> : T[P] | WhereOperations<T[P]> : never;
+    type WhereRequiredFilters<T extends AnyObject, N extends string> = {
+        [P in N as P extends keyof T ? P : never]: P extends keyof T ? WhereField<T[P]> : never;
     };
-    type WhereOptionalFields<T extends Database.Schema, I extends Database.Indexes<T>, N> = {
-        [P in Exclude<keyof T, N>]?: IsObject<T[P]> extends true ? WhereFields<NonNullable<T[P]>, I> : T[P] | WhereOperations<T[P]>;
+    type WhereOptionalFilters<T extends AnyObject, N extends string> = {
+        [P in Exclude<keyof T, N>]?: WhereField<T[P]>;
     };
-    type WhereFields<T extends Database.Schema, I extends Database.Indexes<T>> = (WherePrimaryFields<T, I> & WhereOptionalFields<T, I, DecomposePrimaryIndexNames<I>>) | (WhereUniqueFields<T, I> & WhereOptionalFields<T, I, DecomposeUniqueIndexNames<I>>);
-    type WhereNot<T extends Database.Schema, I extends Database.Indexes<T>> = {
-        NOT?: WhereInput<T, I> | WhereAnd<T, I> | WhereOr<T, I>;
+    type WhereCommonFilters<T extends AnyObject, I extends Database.Indexes<T>> = (WhereRequiredFilters<T, DecomposePrimaryIndexNames<I>> & WhereOptionalFilters<T, DecomposePrimaryIndexNames<I>>) | (WhereRequiredFilters<T, DecomposeUniqueIndexNames<I>> & WhereOptionalFilters<T, DecomposeUniqueIndexNames<I>>);
+    type WhereInputFilters<T extends Database.Schema, I extends Database.Indexes<T>, R extends RelationMetadata> = WhereCommonFilters<T, I> & WhereRelationFilters<R['filters']>;
+    type WhereNot<T extends AnyObject> = {
+        NOT?: T | WhereAnd<T> | WhereOr<T>;
     };
-    type WhereAnd<T extends Database.Schema, I extends Database.Indexes<T>> = {
-        AND?: (WhereInput<T, I> | WhereOr<T, I> | WhereNot<T, I>)[];
+    type WhereAnd<T extends AnyObject> = {
+        AND?: (T | WhereNot<T> | WhereAnd<T> | WhereOr<T>)[];
     };
-    type WhereOr<T extends Database.Schema, I extends Database.Indexes<T>> = {
-        OR?: (WhereInput<T, I> | WhereAnd<T, I> | WhereNot<T, I>)[];
+    type WhereOr<T extends AnyObject> = {
+        OR?: (T | WhereNot<T> | WhereAnd<T> | WhereOr<T>)[];
     };
     type WhereNegate<T> = {
         not: T | WhereOperations<T>;

package/dist/services/relations.d.ts

@@ -1,14 +1,15 @@
-import type { AnyObject, ArrayRest, IsArrayEmpty, PropertyType, ExclusiveType } 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 } from '@ez4/utils';
 /**
  * Internal relation type.
  */
-export type Relations = {
+export type RelationMetadata = {
     indexes: string;
-    selects: Record<string, any>;
-    changes: Record<string, any>;
+    filters: Record<string, unknown>;
+    selects: Record<string, unknown>;
+    changes: Record<string, unknown>;
 };
 /**
  * Given a relation source name `T`, it produces the source table name.
@@ -43,33 +44,40 @@ type TableRelation<T, S extends Record<string, Database.Schema>, I extends Recor
     relations: infer R;
 } ? N extends string ? R extends AnyObject ? {
     [P in N]: {
-        indexes: keyof RelationIndexes<PropertyType<N, S>, I, R>;
+        indexes: RequiredRelationIndexes<PropertyType<N, S>, I, R>;
+        filters: FilterableRelationSchemas<S, I, 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>;
     };
 } : {} : {} : {};
+/**
+ * Produce an object containing all required relation indexes.
+ */
+type RequiredRelationIndexes<T extends Database.Schema, I extends Record<string, Database.Indexes>, R extends AnyObject> = keyof {
+    [C in keyof R as IsOptionalRelation<C, R[C], T, I, true> extends true ? never : RelationTargetColumn<R[C]>]: never;
+};
+/**
+ * Produce an object containing all filterable relation schemas.
+ */
+type FilterableRelationSchemas<S extends Record<string, Database.Schema>, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
+    [C in keyof R as RelationTargetAlias<R[C]>]: IsPrimaryIndex<C, I> extends false ? Omit<PropertyType<RelationSourceTable<C>, S>, RelationSourceColumn<C>> : PropertyType<RelationSourceTable<C>, S>;
+};
 /**
  * Produce an object containing only required relation schemas.
  */
 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<C, R[C], T, I> extends true ? never : RelationTargetAlias<R[C]>]: RelationSchema<C, R[C], T, S, I, E>;
+    [C in keyof R as IsOptionalRelation<C, R[C], T, I, E> extends false ? RelationTargetAlias<R[C]> : never]: RelationSchema<C, R[C], T, S, I, E>;
 };
 /**
  * Produce an object containing only optional relation schemas.
  */
 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<C, R[C], T, I> extends true ? RelationTargetAlias<R[C]> : never]?: RelationSchema<C, R[C], T, S, I, E>;
-};
-/**
- * Produce an object containing all relation indexes.
- */
-type RelationIndexes<T extends Database.Schema, I extends Record<string, Database.Indexes>, R extends AnyObject> = {
-    [C in keyof R as IsOptionalRelation<C, R[C], T, I> extends true ? never : RelationTargetColumn<R[C]>]: never;
+    [C in keyof R as IsOptionalRelation<C, R[C], T, I, E> extends true ? RelationTargetAlias<R[C]> : never]?: RelationSchema<C, R[C], T, S, I, E>;
 };
 /**
  * Check whether a relation is optional or not.
  */
-type IsOptionalRelation<C, V, T extends Database.Schema, I extends Record<string, Database.Indexes>> = RelationSourceColumn<C> extends keyof PrimaryIndexes<PropertyType<RelationSourceTable<C>, I>> ? undefined extends PropertyType<RelationTargetColumn<V>, T> ? true : false : true;
+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>> extends true ? true : false : RelationSourceColumn<C> extends keyof UniqueIndexes<PropertyType<RelationSourceTable<C>, I>> ? true : E;
 /**
  * Check whether a column is primary.
  */

package/dist/services/table.d.ts

@@ -1,5 +1,5 @@
 import type { AnyObject, ArrayRest, IsArrayEmpty, IsAny, PropertyExists } from '@ez4/utils';
-import type { Relations, RelationTables } from './relations.js';
+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';
@@ -14,18 +14,10 @@ export type TableTypes<T extends Database.Schema[]> = IsAny<T> extends true ? an
  */
 export type TableIndex<P, T extends AnyObject> = PropertyExists<P, T> extends true ? (T[P] extends Database.Indexes ? T[P] : {}) : {};
 /**
- * Given a table `T` and a property `P`, it returns all the relations corresponding
- * to the given property.
+ * Given a table `T` and a property `P`, it returns all the relations corresponding to the
+ * given property.
  */
-export type TableRelation<P, T extends AnyObject> = PropertyExists<P, T> extends true ? T[P] extends Relations ? T[P] : {
-    indexes: never;
-    selects: {};
-    changes: {};
-} : {
-    indexes: never;
-    selects: {};
-    changes: {};
-};
+export type TableRelation<P, T extends AnyObject> = PropertyExists<P, T> extends true ? T[P] extends RelationMetadata ? T[P] : RelationMetadata : RelationMetadata;
 /**
  * Given a database service `T`, it returns all table clients.
  */
@@ -35,7 +27,7 @@ export type TableClients<T extends Database.Service<any>> = {
 /**
  * Table client.
  */
-export interface Table<T extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> {
+export interface Table<T extends Database.Schema, I extends Database.Indexes<T>, R extends RelationMetadata> {
     /**
      * Insert one record into the database.
      *

package/dist/services/transaction.d.ts

@@ -1,4 +1,5 @@
-import type { Relations, RelationTables } from './relations.js';
+import type { AnyObject } from '@ez4/utils';
+import type { RelationMetadata, RelationTables } from './relations.js';
 import type { TableIndex, TableRelation } from './table.js';
 import type { IndexedTables } from './indexes.js';
 import type { TableSchemas } from './schemas.js';
@@ -12,18 +13,17 @@ export declare namespace Transaction {
      * Write operations.
      */
     export type WriteOperations<T extends Database.Service<any>> = {
-        [P in keyof TableSchemas<T>]?: TableSchemas<T>[P] extends Database.Schema ? {
-            [alias: string]: InsertOperation<TableSchemas<T>[P], TableRelation<P, RelationTables<T>>> | UpdateOperation<TableSchemas<T>[P], TableIndex<P, IndexedTables<T>>, TableRelation<P, RelationTables<T>>> | DeleteOperation<TableSchemas<T>[P], TableIndex<P, IndexedTables<T>>, TableRelation<P, RelationTables<T>>>;
-        } : never;
+        [P in keyof TableSchemas<T>]?: (TableSchemas<T>[P] extends Database.Schema ? AnyOperation<TableSchemas<T>[P], TableIndex<P, IndexedTables<T>>, TableRelation<P, RelationTables<T>>> : AnyObject)[];
     };
-    type InsertOperation<T extends Database.Schema, R extends Relations> = {
+    type AnyOperation<T extends Database.Schema, I extends Database.Indexes<T>, R extends RelationMetadata> = InsertOperation<T, R> | UpdateOperation<T, I, R> | DeleteOperation<T, I, R>;
+    type InsertOperation<T extends Database.Schema, R extends RelationMetadata> = {
         insert: Query.InsertOneInput<T, R>;
     };
-    type UpdateOperation<T extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> = {
-        update: Omit<Query.UpdateOneInput<T, Query.SelectInput<T, R>, I, R>, 'select'>;
+    type UpdateOperation<T extends Database.Schema, I extends Database.Indexes<T>, R extends RelationMetadata> = {
+        update: Omit<Query.UpdateOneInput<T, Query.SelectInput<T, R>, I, R>, 'select' | 'include'>;
     };
-    type DeleteOperation<T extends Database.Schema, I extends Database.Indexes<T>, R extends Relations> = {
-        delete: Omit<Query.DeleteOneInput<T, Query.SelectInput<T, R>, I, R>, 'select'>;
+    type DeleteOperation<T extends Database.Schema, I extends Database.Indexes<T>, R extends RelationMetadata> = {
+        delete: Omit<Query.DeleteOneInput<T, Query.SelectInput<T, R>, I, R>, 'select' | 'include'>;
     };
     export {};
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ez4/database",
   "description": "EZ4: Components to build database services",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "author": "Silas B.",
   "license": "MIT",
   "type": "module",
@@ -41,13 +41,11 @@
     "clean:registry": "rm -rf ../../.registry/@ez4/database",
     "live:publish": "npm run test && npm publish --access public"
   },
-  "peerDependencies": {
-    "@ez4/project": "^0.10.0"
-  },
   "dependencies": {
-    "@ez4/common": "^0.10.0",
-    "@ez4/reflection": "^0.10.0",
-    "@ez4/schema": "^0.10.0",
-    "@ez4/utils": "^0.10.0"
+    "@ez4/common": "^0.12.0",
+    "@ez4/project": "^0.12.0",
+    "@ez4/reflection": "^0.12.0",
+    "@ez4/schema": "^0.12.0",
+    "@ez4/utils": "^0.12.0"
   }
 }

package/dist/richtypes/schema.d.ts

@@ -1,10 +0,0 @@
-export declare namespace Schema {
-    /**
-     * Set property to be a primary index.
-     */
-    type Primary<T> = T;
-    /**
-     * Set property to be a regular index.
-     */
-    type Index<T> = T;
-}

package/dist/richtypes/utils.d.ts

@@ -1,104 +0,0 @@
-import type { EveryType, TypeObject } from '@ez4/reflection';
-export type RichTypes = {
-    index?: string;
-    type: EveryType;
-};
-export declare const getRichTypes: (type: TypeObject) => RichTypes | null;
-export declare const createRichType: (richType: RichTypes) => {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Object;
-    file?: string;
-    members?: import("@ez4/reflection").EveryMemberType[];
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Any;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Void;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Never;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Unknown;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Undefined;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Null;
-    literal?: boolean;
-    default?: boolean;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Boolean;
-    literal?: boolean;
-    default?: boolean;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Number;
-    literal?: number;
-    default?: number;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.String;
-    literal?: string;
-    default?: string;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Reference;
-    namespace?: string;
-    internal?: boolean;
-    path: string;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Union;
-    elements: EveryType[];
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Array;
-    element: EveryType;
-    spread?: boolean;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Tuple;
-    elements: EveryType[];
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Callback;
-    name?: string;
-    file?: string;
-    description?: string;
-    parameters?: import("@ez4/reflection").TypeParameter[];
-    return?: EveryType;
-} | null;

package/dist/services/helpers.d.ts

@@ -1,12 +0,0 @@
-import type { ArrayRest, IsArrayEmpty, IsAny } from '@ez4/utils';
-import type { Database } from './database.js';
-/**
- * Given an array of schemas `T`, it returns an union of `Database.Table` for each schema.
- */
-export type TableTypes<T extends Database.Schema[]> = IsAny<T> extends true ? any : IsArrayEmpty<T> extends true ? Database.Table<Database.Schema> : Database.Table<T[0]> | TableTypes<ArrayRest<T>>;
-/**
- * Given a database service `T`, it returns all its table types.
- */
-export type DatabaseTables<T> = T extends {
-    tables: infer U;
-} ? U : [];

package/dist/services/stream.d.ts

@@ -1,34 +0,0 @@
-/**
- * Stream change for `insert`, `update` or `delete` operations.
- */
-export type StreamChange<T> = StreamInsertChange<T> | StreamUpdateChange<T> | StreamDeleteChange<T>;
-/**
- * Stream change for an `insert` operation.
- */
-export type StreamInsertChange<T> = {
-    type: StreamType.Insert;
-    record: T;
-};
-/**
- * Stream change for an `update` operation.
- */
-export type StreamUpdateChange<T> = {
-    type: StreamType.Update;
-    oldRecord: T;
-    newRecord: T;
-};
-/**
- * Stream change for an `delete` operation.
- */
-export type StreamDeleteChange<T> = {
-    type: StreamType.Delete;
-    record: T;
-};
-/**
- * Stream change types.
- */
-export declare const enum StreamType {
-    Insert = "insert",
-    Update = "update",
-    Delete = "delete"
-}

package/dist/triggers/richtypes.d.ts

@@ -1,100 +0,0 @@
-import type { TypeObject } from '@ez4/reflection';
-export declare const applyRichTypePath: (file: string) => string | null;
-export declare const applyRichTypeObject: (type: TypeObject) => {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Object;
-    file?: string;
-    members?: import("@ez4/reflection").EveryMemberType[];
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Any;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Void;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Never;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Unknown;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Undefined;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Null;
-    literal?: boolean;
-    default?: boolean;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Boolean;
-    literal?: boolean;
-    default?: boolean;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Number;
-    literal?: number;
-    default?: number;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.String;
-    literal?: string;
-    default?: string;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Reference;
-    namespace?: string;
-    internal?: boolean;
-    path: string;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Union;
-    elements: import("@ez4/reflection").EveryType[];
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Array;
-    element: import("@ez4/reflection").EveryType;
-    spread?: boolean;
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Tuple;
-    elements: import("@ez4/reflection").EveryType[];
-} | {
-    extra: {
-        index: "primary" | "regular";
-    };
-    type: import("@ez4/reflection").TypeName.Callback;
-    name?: string;
-    file?: string;
-    description?: string;
-    parameters?: import("@ez4/reflection").TypeParameter[];
-    return?: import("@ez4/reflection").EveryType;
-} | null;