@simplysm/orm-common 13.0.100 → 14.0.4

package/docs/schema-builders.md

@@ -1,28 +1,27 @@
 # Schema Builders
 
-## `Table`
+Fluent API builders for defining tables, views, procedures, columns, indexes, and relations.
 
-Table builder factory function. Creates a `TableBuilder` for defining table schema via fluent API.
+## Table (function)
+
+Factory function that creates a `TableBuilder`.
 
 ```typescript
 function Table(name: string): TableBuilder<{}, {}>;
 ```
 
-## `TableBuilder`
+## TableBuilder
 
-Database table definition builder. Define columns, PK, indexes, and relations via fluent API.
+Database table definition builder with fluent API for columns, primary keys, indexes, and relations.
 
 ```typescript
-class TableBuilder<
-  TColumns extends ColumnBuilderRecord,
-  TRelations extends RelationBuilderRecord,
-> {
-  readonly $columns!: TColumns;
-  readonly $relations!: TRelations;
-  readonly $inferSelect!: InferColumns<TColumns> & InferDeepRelations<TRelations>;
-  readonly $inferColumns!: InferColumns<TColumns>;
-  readonly $inferInsert!: InferInsertColumns<TColumns>;
-  readonly $inferUpdate!: InferUpdateColumns<TColumns>;
+class TableBuilder<TColumns extends ColumnBuilderRecord, TRelations extends RelationBuilderRecord> {
+  readonly $columns: TColumns;
+  readonly $relations: TRelations;
+  readonly $inferSelect: InferColumns<TColumns> & InferDeepRelations<TRelations>;
+  readonly $inferColumns: InferColumns<TColumns>;
+  readonly $inferInsert: InferInsertColumns<TColumns>;
+  readonly $inferUpdate: InferUpdateColumns<TColumns>;
 
   constructor(readonly meta: {
     name: string;
@@ -34,49 +33,55 @@ class TableBuilder<
     relations?: TRelations;
     indexes?: IndexBuilder<(keyof TColumns & string)[]>[];
   });
-
-  description(desc: string): TableBuilder<TColumns, TRelations>;
-  database(db: string): TableBuilder<TColumns, TRelations>;
-  schema(schema: string): TableBuilder<TColumns, TRelations>;
-  columns<TNewColumnDefs extends ColumnBuilderRecord>(
-    fn: (c: ReturnType<typeof createColumnFactory>) => TNewColumnDefs,
-  ): TableBuilder<TNewColumnDefs, TRelations>;
-  primaryKey(...columns: (keyof TColumns & string)[]): TableBuilder<TColumns, TRelations>;
-  indexes(fn: (i: ...) => IndexBuilder<string[]>[]): TableBuilder<TColumns, TRelations>;
-  relations<T extends RelationBuilderRecord>(fn: (r: ...) => T): TableBuilder<TColumns, T>;
 }
 ```
 
-| Method | Description |
-|--------|-------------|
-| `description()` | Set table description (DDL comment) |
-| `database()` | Set database name |
-| `schema()` | Set schema name (MSSQL/PostgreSQL) |
-| `columns()` | Define columns using the column factory |
-| `primaryKey()` | Set primary key columns (composite PK supported) |
-| `indexes()` | Define indexes using the index factory |
-| `relations()` | Define relations using the relation factory |
+### Methods
 
-## `View`
+| Method | Signature | Description |
+|---|---|---|
+| `description` | `(desc: string) => TableBuilder` | Set table description (DDL comment) |
+| `database` | `(db: string) => TableBuilder` | Set database name |
+| `schema` | `(schema: string) => TableBuilder` | Set schema name (MSSQL/PostgreSQL) |
+| `columns` | `(fn: (c: ColumnFactory) => TNewCols) => TableBuilder<TNewCols, TRelations>` | Define columns using the column factory |
+| `primaryKey` | `(...columns: string[]) => TableBuilder` | Set primary key (composite supported) |
+| `indexes` | `(fn: (i: IndexFactory) => IndexBuilder[]) => TableBuilder` | Define indexes |
+| `relations` | `(fn: (r: RelationFactory) => T) => TableBuilder<TColumns, T>` | Define relationships |
 
-View builder factory function. Creates a `ViewBuilder` for defining view schema via fluent API.
+**Example:**
 
 ```typescript
-function View(name: string): ViewBuilder<any, any, {}>;
+const User = Table("User")
+  .database("mydb")
+  .columns((c) => ({
+    id: c.bigint().autoIncrement(),
+    name: c.varchar(100),
+    email: c.varchar(200).nullable(),
+    status: c.varchar(20).default("active"),
+  }))
+  .primaryKey("id")
+  .indexes((i) => [i.index("email").unique()])
+  .relations((r) => ({
+    posts: r.foreignKeyTarget(() => Post, "author"),
+  }));
 ```
 
-## `ViewBuilder`
+## View (function)
 
-Database view definition builder. Define view query and relations via fluent API.
+Factory function that creates a `ViewBuilder`.
 
 ```typescript
-class ViewBuilder<
-  TDbContext extends DbContextBase,
-  TData extends DataRecord,
-  TRelations extends RelationBuilderRecord,
-> {
-  readonly $relations!: TRelations;
-  readonly $inferSelect!: TData;
+function View(name: string): ViewBuilder<any, {}, {}>;
+```
+
+## ViewBuilder
+
+Database view definition builder.
+
+```typescript
+class ViewBuilder<TDbContext, TData extends DataRecord, TRelations extends RelationBuilderRecord> {
+  readonly $relations: TRelations;
+  readonly $inferSelect: TData;
 
   constructor(readonly meta: {
     name: string;
@@ -86,44 +91,47 @@ class ViewBuilder<
     viewFn?: (db: TDbContext) => Queryable<TData, any>;
     relations?: TRelations;
   });
-
-  description(desc: string): ViewBuilder<TDbContext, TData, TRelations>;
-  database(db: string): ViewBuilder<TDbContext, TData, TRelations>;
-  schema(schema: string): ViewBuilder<TDbContext, TData, TRelations>;
-  query<TViewData extends DataRecord, TDb extends DbContextBase>(
-    viewFn: (db: TDb) => Queryable<TViewData, any>,
-  ): ViewBuilder<TDb, TViewData, TRelations>;
-  relations<T extends RelationBuilderRecord>(fn: (r: ...) => T): ViewBuilder<TDbContext, TData & InferDeepRelations<T>, TRelations>;
 }
 ```
 
-| Method | Description |
-|--------|-------------|
-| `description()` | Set view description (DDL comment) |
-| `database()` | Set database name |
-| `schema()` | Set schema name |
-| `query()` | Define the view's SELECT query |
-| `relations()` | Define relations with other tables/views |
+### Methods
 
-## `Procedure`
+| Method | Signature | Description |
+|---|---|---|
+| `description` | `(desc: string) => ViewBuilder` | Set view description |
+| `database` | `(db: string) => ViewBuilder` | Set database name |
+| `schema` | `(schema: string) => ViewBuilder` | Set schema name |
+| `query` | `(viewFn: (db: TDb) => Queryable) => ViewBuilder` | Define view query |
+| `relations` | `(fn: (r: RelationFactory) => T) => ViewBuilder` | Define relationships |
 
-Procedure builder factory function. Creates a `ProcedureBuilder` for defining stored procedure schema via fluent API.
+**Example:**
+
+```typescript
+const ActiveUsers = View("ActiveUsers")
+  .database("mydb")
+  .query((db: MyDb) =>
+    db.user()
+      .where((u) => [expr.eq(u.status, "active")])
+      .select((u) => ({ id: u.id, name: u.name }))
+  );
+```
+
+## Procedure (function)
+
+Factory function that creates a `ProcedureBuilder`.
 
 ```typescript
 function Procedure(name: string): ProcedureBuilder<never, never>;
 ```
 
-## `ProcedureBuilder`
+## ProcedureBuilder
 
-Stored procedure definition builder. Define parameters, return type, and body via fluent API.
+Stored procedure definition builder.
 
 ```typescript
-class ProcedureBuilder<
-  TParams extends ColumnBuilderRecord,
-  TReturns extends ColumnBuilderRecord,
-> {
-  readonly $params!: TParams;
-  readonly $returns!: TReturns;
+class ProcedureBuilder<TParams extends ColumnBuilderRecord, TReturns extends ColumnBuilderRecord> {
+  readonly $params: TParams;
+  readonly $returns: TReturns;
 
   constructor(readonly meta: {
     name: string;
@@ -134,50 +142,52 @@ class ProcedureBuilder<
     returns?: TReturns;
     query?: string;
   });
-
-  description(desc: string): ProcedureBuilder<TParams, TReturns>;
-  database(db: string): ProcedureBuilder<TParams, TReturns>;
-  schema(schema: string): ProcedureBuilder<TParams, TReturns>;
-  params<T extends ColumnBuilderRecord>(fn: (c: ...) => T): ProcedureBuilder<T, TReturns>;
-  returns<T extends ColumnBuilderRecord>(fn: (c: ...) => T): ProcedureBuilder<TParams, T>;
-  body(sql: string): ProcedureBuilder<TParams, TReturns>;
 }
 ```
 
-| Method | Description |
-|--------|-------------|
-| `description()` | Set procedure description |
-| `database()` | Set database name |
-| `schema()` | Set schema name |
-| `params()` | Define input parameters |
-| `returns()` | Define return type columns |
-| `body()` | Set procedure body SQL |
+### Methods
 
-## `ColumnBuilder`
+| Method | Signature | Description |
+|---|---|---|
+| `description` | `(desc: string) => ProcedureBuilder` | Set procedure description |
+| `database` | `(db: string) => ProcedureBuilder` | Set database name |
+| `schema` | `(schema: string) => ProcedureBuilder` | Set schema name |
+| `params` | `(fn: (c: ColumnFactory) => T) => ProcedureBuilder<T, TReturns>` | Define input parameters |
+| `returns` | `(fn: (c: ColumnFactory) => T) => ProcedureBuilder<TParams, T>` | Define return columns |
+| `body` | `(sql: string) => ProcedureBuilder` | Set procedure body SQL |
 
-Column definition builder. Define column type, nullable, autoIncrement, default, and description via fluent API.
+**Example:**
+
+```typescript
+const GetUserById = Procedure("GetUserById")
+  .database("mydb")
+  .params((c) => ({ userId: c.bigint() }))
+  .returns((c) => ({ id: c.bigint(), name: c.varchar(100) }))
+  .body("SELECT id, name FROM User WHERE id = userId");
+```
+
+## ColumnBuilder
+
+Column definition builder used inside `TableBuilder.columns()`.
 
 ```typescript
 class ColumnBuilder<TValue extends ColumnPrimitive, TMeta extends ColumnMeta> {
   constructor(readonly meta: TMeta);
-
-  autoIncrement(): ColumnBuilder<TValue, Omit<TMeta, "autoIncrement"> & { autoIncrement: true }>;
-  nullable(): ColumnBuilder<TValue | undefined, Omit<TMeta, "nullable"> & { nullable: true }>;
-  default(value: TValue): ColumnBuilder<TValue, Omit<TMeta, "default"> & { default: typeof value }>;
-  description(desc: string): ColumnBuilder<TValue, TMeta & { description: string }>;
 }
 ```
 
-| Method | Description |
-|--------|-------------|
-| `autoIncrement()` | Set auto increment (optional in INSERT) |
-| `nullable()` | Allow NULL (adds `undefined` to type) |
-| `default()` | Set default value (optional in INSERT) |
-| `description()` | Set column description (DDL comment) |
+### Methods
+
+| Method | Signature | Description |
+|---|---|---|
+| `autoIncrement` | `() => ColumnBuilder` | Set auto-increment. Makes column optional in INSERT. |
+| `nullable` | `() => ColumnBuilder<TValue \| undefined, ...>` | Allow NULL. Adds `undefined` to value type. |
+| `default` | `(value: TValue) => ColumnBuilder` | Set default value. Makes column optional in INSERT. |
+| `description` | `(desc: string) => ColumnBuilder` | Set column description (DDL comment) |
 
-## `createColumnFactory`
+## createColumnFactory
 
-Column builder factory. Provides builder creation methods for all basic data types.
+Returns a column factory object with methods for all supported data types.
 
 ```typescript
 function createColumnFactory(): {
@@ -198,26 +208,9 @@ function createColumnFactory(): {
 };
 ```
 
-| Method | SQL Type | TypeScript Type |
-|--------|----------|-----------------|
-| `int()` | INT (4 bytes) | `number` |
-| `bigint()` | BIGINT (8 bytes) | `number` |
-| `float()` | FLOAT (4 bytes) | `number` |
-| `double()` | DOUBLE (8 bytes) | `number` |
-| `decimal()` | DECIMAL(p, s) | `number` |
-| `varchar()` | VARCHAR(n) | `string` |
-| `char()` | CHAR(n) | `string` |
-| `text()` | TEXT | `string` |
-| `binary()` | LONGBLOB/VARBINARY(MAX)/BYTEA | `Bytes` |
-| `boolean()` | TINYINT(1)/BIT/BOOLEAN | `boolean` |
-| `datetime()` | DATETIME | `DateTime` |
-| `date()` | DATE | `DateOnly` |
-| `time()` | TIME | `Time` |
-| `uuid()` | BINARY(16)/UNIQUEIDENTIFIER/UUID | `Uuid` |
-
-## `IndexBuilder`
-
-Index definition builder. Define index columns, uniqueness, and sort order via fluent API.
+## IndexBuilder
+
+Index definition builder used inside `TableBuilder.indexes()`.
 
 ```typescript
 class IndexBuilder<TKeys extends string[]> {
@@ -228,33 +221,34 @@ class IndexBuilder<TKeys extends string[]> {
     orderBy?: { [K in keyof TKeys]: "ASC" | "DESC" };
     description?: string;
   });
-
-  name(name: string): IndexBuilder<TKeys>;
-  unique(): IndexBuilder<TKeys>;
-  orderBy(...orderBy: { [K in keyof TKeys]: "ASC" | "DESC" }): IndexBuilder<TKeys>;
-  description(description: string): IndexBuilder<TKeys>;
 }
 ```
 
-## `createIndexFactory`
+### Methods
 
-Index builder factory. Used in `TableBuilder.indexes()`.
+| Method | Signature | Description |
+|---|---|---|
+| `name` | `(name: string) => IndexBuilder` | Set custom index name |
+| `unique` | `() => IndexBuilder` | Mark as unique index |
+| `orderBy` | `(...orderBy: ("ASC" \| "DESC")[]) => IndexBuilder` | Set column sort order |
+| `description` | `(description: string) => IndexBuilder` | Set index description |
+
+## createIndexFactory
+
+Returns an index factory with the `index(...columns)` method.
 
 ```typescript
 function createIndexFactory<TColumnKey extends string>(): {
-  index<TKeys extends TColumnKey[]>(...columns: [...TKeys]): IndexBuilder<TKeys>;
+  index<TKeys extends TColumnKey[]>(...columns: TKeys): IndexBuilder<TKeys>;
 };
 ```
 
-## `ForeignKeyBuilder`
+## ForeignKeyBuilder
 
-Foreign key relation builder (N:1). Creates actual FK constraints in the DB.
+Foreign key relation builder (N:1). Creates a real FK constraint in the database.
 
 ```typescript
-class ForeignKeyBuilder<
-  TOwner extends TableBuilder<any, any>,
-  TTargetFn extends () => TableBuilder<any, any>,
-> {
+class ForeignKeyBuilder<TOwner extends TableBuilder, TTargetFn extends () => TableBuilder> {
   constructor(readonly meta: {
     ownerFn: () => TOwner;
     columns: string[];
@@ -262,19 +256,16 @@ class ForeignKeyBuilder<
     description?: string;
   });
 
-  description(desc: string): ForeignKeyBuilder<TOwner, TTargetFn>;
+  description(desc: string): ForeignKeyBuilder;
 }
 ```
 
-## `ForeignKeyTargetBuilder`
+## ForeignKeyTargetBuilder
 
-Foreign key reverse-reference builder (1:N). Loaded as array on `include()` (single object when `.single()` is called).
+Foreign key reverse-reference builder (1:N). Loaded as array by default, call `.single()` for 1:1.
 
 ```typescript
-class ForeignKeyTargetBuilder<
-  TTargetTableFn extends () => TableBuilder<any, any>,
-  TIsSingle extends boolean,
-> {
+class ForeignKeyTargetBuilder<TTargetTableFn extends () => TableBuilder, TIsSingle extends boolean> {
   constructor(readonly meta: {
     targetTableFn: TTargetTableFn;
     relationName: string;
@@ -282,20 +273,17 @@ class ForeignKeyTargetBuilder<
     isSingle?: TIsSingle;
   });
 
-  description(desc: string): ForeignKeyTargetBuilder<TTargetTableFn, TIsSingle>;
+  description(desc: string): ForeignKeyTargetBuilder;
   single(): ForeignKeyTargetBuilder<TTargetTableFn, true>;
 }
 ```
 
-## `RelationKeyBuilder`
+## RelationKeyBuilder
 
-Logical relation builder (N:1). Same as `ForeignKeyBuilder` but does not create FK constraints in the DB. Can be used in views.
+Logical relation builder (N:1). Same as `ForeignKeyBuilder` but does NOT create a FK constraint in the database. Usable from both Tables and Views.
 
 ```typescript
-class RelationKeyBuilder<
-  TOwner extends TableBuilder<any, any> | ViewBuilder<any, any, any>,
-  TTargetFn extends () => TableBuilder<any, any> | ViewBuilder<any, any, any>,
-> {
+class RelationKeyBuilder<TOwner, TTargetFn extends () => TableBuilder | ViewBuilder> {
   constructor(readonly meta: {
     ownerFn: () => TOwner;
     columns: string[];
@@ -303,19 +291,16 @@ class RelationKeyBuilder<
     description?: string;
   });
 
-  description(desc: string): RelationKeyBuilder<TOwner, TTargetFn>;
+  description(desc: string): RelationKeyBuilder;
 }
 ```
 
-## `RelationKeyTargetBuilder`
+## RelationKeyTargetBuilder
 
-Logical relation reverse-reference builder (1:N). Same as `ForeignKeyTargetBuilder` but without DB FK constraints. Can be used in views.
+Logical reverse-reference builder (1:N). Same as `ForeignKeyTargetBuilder` but without FK constraint. Usable from both Tables and Views.
 
 ```typescript
-class RelationKeyTargetBuilder<
-  TTargetTableFn extends () => TableBuilder<any, any> | ViewBuilder<any, any, any>,
-  TIsSingle extends boolean,
-> {
+class RelationKeyTargetBuilder<TTargetTableFn, TIsSingle extends boolean> {
   constructor(readonly meta: {
     targetTableFn: TTargetTableFn;
     relationName: string;
@@ -323,141 +308,45 @@ class RelationKeyTargetBuilder<
     isSingle?: TIsSingle;
   });
 
-  description(desc: string): RelationKeyTargetBuilder<TTargetTableFn, TIsSingle>;
+  description(desc: string): RelationKeyTargetBuilder;
   single(): RelationKeyTargetBuilder<TTargetTableFn, true>;
 }
 ```
 
-## `createRelationFactory`
-
-Relation builder factory. Used in `TableBuilder.relations()` and `ViewBuilder.relations()`. Tables can use both FK + RelationKey; views can only use RelationKey.
-
-```typescript
-function createRelationFactory<
-  TOwner extends TableBuilder<any, any> | ViewBuilder<any, any, any>,
-  TColumnKey extends string,
->(ownerFn: () => TOwner): TOwner extends TableBuilder<any, any>
-  ? RelationFkFactory<TOwner, TColumnKey> & RelationRkFactory<TOwner, TColumnKey>
-  : RelationRkFactory<TOwner, TColumnKey>;
-```
-
-## `ColumnBuilderRecord`
-
-Column builder record type. Used as the return type of `TableBuilder.columns()`.
-
-```typescript
-type ColumnBuilderRecord = Record<string, ColumnBuilder<ColumnPrimitive, ColumnMeta>>;
-```
-
-## `RelationBuilderRecord`
-
-Relation builder record type. Return type of `TableBuilder.relations()` and `ViewBuilder.relations()`.
-
-```typescript
-type RelationBuilderRecord = Record<
-  string,
-  ForeignKeyBuilder<any, any> | ForeignKeyTargetBuilder<any, any> | RelationKeyBuilder<any, any> | RelationKeyTargetBuilder<any, any>
->;
-```
-
-## `InferColumns`
-
-Infer actual value types from a column builder record.
-
-```typescript
-type InferColumns<TBuilders extends ColumnBuilderRecord> = {
-  [K in keyof TBuilders]: TBuilders[K] extends ColumnBuilder<infer V, any> ? V : never;
-};
-```
-
-## `InferColumnExprs`
-
-Infer expression input types from a column builder record.
-
-```typescript
-type InferColumnExprs<TBuilders extends ColumnBuilderRecord> = {
-  [K in keyof TBuilders]: TBuilders[K] extends ColumnBuilder<infer V, any> ? ExprInput<V> : never;
-};
-```
-
-## `InferInsertColumns`
-
-INSERT type inference. Required columns are required, optional columns (autoIncrement, nullable, default) are `Partial`.
-
-```typescript
-type InferInsertColumns<TBuilders extends ColumnBuilderRecord> = Pick<
-  InferColumns<TBuilders>,
-  RequiredInsertKeys<TBuilders>
-> & Partial<Pick<InferColumns<TBuilders>, OptionalInsertKeys<TBuilders>>>;
-```
-
-## `InferUpdateColumns`
-
-UPDATE type inference. All columns are optional.
-
-```typescript
-type InferUpdateColumns<TBuilders extends ColumnBuilderRecord> = Partial<InferColumns<TBuilders>>;
-```
-
-## `RequiredInsertKeys`
-
-Extract required column keys for INSERT (columns without autoIncrement, nullable, or default).
-
-```typescript
-type RequiredInsertKeys<TBuilders extends ColumnBuilderRecord> = { ... }[keyof TBuilders];
-```
-
-## `OptionalInsertKeys`
-
-Extract optional column keys for INSERT.
-
-```typescript
-type OptionalInsertKeys<TBuilders extends ColumnBuilderRecord> = Exclude<keyof TBuilders, RequiredInsertKeys<TBuilders>>;
-```
-
-## `DataToColumnBuilderRecord`
+## createRelationFactory
 
-Transform from data record to column builder record.
+Returns a relation factory. Tables get both FK and RelationKey methods; Views get only RelationKey methods.
 
 ```typescript
-type DataToColumnBuilderRecord<TData extends DataRecord> = { ... };
+function createRelationFactory<TOwner, TColumnKey extends string>(
+  ownerFn: () => TOwner,
+): TOwner extends TableBuilder
+  ? RelationFkFactory & RelationRkFactory
+  : RelationRkFactory;
 ```
 
-## `InferDeepRelations`
-
-Deep relation type inference from relation definitions. Makes all relations optional.
-
-```typescript
-type InferDeepRelations<TRelations extends RelationBuilderRecord> = {
-  [K in keyof TRelations]?: ExtractRelationTarget<TRelations[K]> | ExtractRelationTargetResult<TRelations[K]>;
-};
-```
-
-## `ExtractRelationTarget`
-
-Extract target type from FK/RelationKey (single object, N:1 relation).
-
-```typescript
-type ExtractRelationTarget<TRelation> = ...;
-```
+**Factory methods (Table):**
 
-## `ExtractRelationTargetResult`
-
-Extract target type from FKTarget/RelationKeyTarget (array or single object, 1:N relation).
-
-```typescript
-type ExtractRelationTargetResult<TRelation> = ...;
-```
-
-## `_Migration`
-
-Built-in system migration table. Automatically included in every `DbContextDef`.
-
-```typescript
-const _Migration = Table("_migration")
-  .columns((c) => ({
-    code: c.varchar(255),
-  }))
-  .description("System Migration Table")
-  .primaryKey("code");
-```
+| Method | Description |
+|---|---|
+| `foreignKey(columns, targetFn)` | N:1 FK relation (creates DB constraint) |
+| `foreignKeyTarget(targetTableFn, relationName)` | 1:N FK reverse-reference |
+| `relationKey(columns, targetFn)` | N:1 logical relation (no DB constraint) |
+| `relationKeyTarget(targetTableFn, relationName)` | 1:N logical reverse-reference |
+
+## Type Utilities
+
+| Type | Description |
+|---|---|
+| `ColumnBuilderRecord` | `Record<string, ColumnBuilder<ColumnPrimitive, ColumnMeta>>` |
+| `RelationBuilderRecord` | `Record<string, ForeignKeyBuilder \| ForeignKeyTargetBuilder \| RelationKeyBuilder \| RelationKeyTargetBuilder>` |
+| `InferColumns<T>` | Infer runtime value types from column builders |
+| `InferColumnExprs<T>` | Infer `ExprInput` types from column builders |
+| `InferInsertColumns<T>` | INSERT type: required fields + optional for autoIncrement/nullable/default |
+| `InferUpdateColumns<T>` | UPDATE type: all fields optional |
+| `RequiredInsertKeys<T>` | Extract required INSERT column keys |
+| `OptionalInsertKeys<T>` | Extract optional INSERT column keys |
+| `DataToColumnBuilderRecord<T>` | Convert data record to column builder record |
+| `ExtractRelationTarget<T>` | Extract target type from FK/RelationKey (single object) |
+| `ExtractRelationTargetResult<T>` | Extract target type from FKTarget/RelationKeyTarget (array or single) |
+| `InferDeepRelations<T>` | Deep relation type inference (all optional) |