npm - effect-qb - Versions diffs - 0.17.0 → 0.19.0 - Mend

effect-qb 0.17.0 → 0.19.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (103) hide show

package/README.md +4 -0
package/dist/index.js +8065 -0
package/dist/mysql.js +3053 -2505
package/dist/postgres/metadata.js +1366 -1250
package/dist/postgres.js +2020 -2719
package/dist/sqlite.js +3226 -2732
package/dist/standard.js +8019 -0
package/package.json +10 -3
package/src/casing.ts +71 -0
package/src/index.ts +2 -0
package/src/internal/casing.ts +89 -0
package/src/internal/column-state.ts +11 -6
package/src/internal/column.ts +44 -7
package/src/internal/datatypes/define.ts +2 -1
package/src/internal/datatypes/enrich.ts +23 -0
package/src/internal/datatypes/lookup.ts +14 -7
package/src/internal/derived-table.ts +4 -36
package/src/{mysql/internal/sql-expression-renderer.ts → internal/dialect-renderers/mysql.ts} +548 -359
package/src/{postgres/internal/sql-expression-renderer.ts → internal/dialect-renderers/postgres.ts} +654 -399
package/src/{sqlite/internal/sql-expression-renderer.ts → internal/dialect-renderers/sqlite.ts} +501 -345
package/src/internal/dialect.ts +35 -0
package/src/internal/dsl-mutation-runtime.ts +12 -162
package/src/internal/dsl-plan-runtime.ts +10 -138
package/src/internal/dsl-query-runtime.ts +5 -79
package/src/internal/dsl-transaction-ddl-runtime.ts +41 -65
package/src/internal/executor.ts +10 -6
package/src/internal/grouping-key.ts +87 -20
package/src/internal/implication-runtime.ts +1 -1
package/src/internal/predicate/runtime.ts +3 -0
package/src/internal/query.d.ts +38 -11
package/src/internal/query.ts +64 -25
package/src/internal/renderer.ts +26 -14
package/src/internal/runtime/normalize.ts +12 -5
package/src/internal/scalar.ts +6 -1
package/src/internal/schema-derivation.d.ts +12 -61
package/src/internal/schema-derivation.ts +90 -38
package/src/internal/schema-expression.ts +2 -2
package/src/internal/sql-expression-renderer.ts +19 -0
package/src/internal/standard-dsl.ts +6885 -0
package/src/internal/table-options.ts +126 -66
package/src/internal/table.d.ts +33 -32
package/src/internal/table.ts +406 -155
package/src/mysql/column-extension.ts +3 -0
package/src/mysql/column.ts +10 -11
package/src/mysql/datatypes/index.ts +3 -2
package/src/mysql/executor.ts +7 -5
package/src/mysql/internal/dialect.ts +9 -4
package/src/mysql/internal/dsl.ts +219 -155
package/src/mysql/internal/renderer.ts +6 -2
package/src/mysql/json.ts +37 -0
package/src/mysql/query-extension.ts +16 -0
package/src/mysql/renderer.ts +31 -4
package/src/mysql.ts +4 -12
package/src/postgres/column-extension.ts +28 -0
package/src/postgres/column.ts +5 -11
package/src/postgres/datatypes/index.d.ts +2 -1
package/src/postgres/datatypes/index.ts +3 -2
package/src/postgres/executor.ts +7 -5
package/src/postgres/function/core.ts +1 -3
package/src/postgres/function/index.ts +1 -17
package/src/postgres/internal/dialect.ts +9 -4
package/src/postgres/internal/dsl.ts +208 -160
package/src/postgres/internal/renderer.ts +6 -2
package/src/postgres/internal/schema-ddl.ts +22 -10
package/src/postgres/internal/schema-model.ts +238 -7
package/src/postgres/json.ts +43 -7
package/src/postgres/jsonb.ts +38 -0
package/src/postgres/query-extension.ts +2 -0
package/src/postgres/renderer.ts +31 -4
package/src/postgres/schema-management.ts +17 -12
package/src/postgres/schema.ts +98 -15
package/src/postgres/table.ts +193 -524
package/src/postgres/type.ts +8 -7
package/src/postgres.ts +9 -11
package/src/sqlite/column-extension.ts +3 -0
package/src/sqlite/column.ts +10 -11
package/src/sqlite/datatypes/index.ts +3 -2
package/src/sqlite/executor.ts +7 -5
package/src/sqlite/internal/dialect.ts +9 -4
package/src/sqlite/internal/dsl.ts +208 -155
package/src/sqlite/internal/renderer.ts +6 -2
package/src/sqlite/json.ts +37 -0
package/src/sqlite/query-extension.ts +2 -0
package/src/sqlite/renderer.ts +31 -4
package/src/sqlite.ts +4 -12
package/src/standard/column.ts +163 -0
package/src/standard/datatypes/index.ts +83 -0
package/src/standard/datatypes/spec.ts +98 -0
package/src/standard/dialect.ts +40 -0
package/src/standard/function/aggregate.ts +2 -0
package/src/standard/function/core.ts +2 -0
package/src/standard/function/index.ts +18 -0
package/src/standard/function/string.ts +2 -0
package/src/standard/function/temporal.ts +78 -0
package/src/standard/function/window.ts +2 -0
package/src/standard/internal/renderer.ts +45 -0
package/src/standard/query.ts +152 -0
package/src/standard/renderer.ts +21 -0
package/src/standard/table.ts +147 -0
package/src/standard.ts +18 -0
package/src/internal/aggregation-validation.ts +0 -57
package/src/mysql/table.ts +0 -183
package/src/sqlite/table.ts +0 -183

package/src/internal/table-options.ts CHANGED Viewed

@@ -4,7 +4,10 @@ import {
   type AnyColumnDefinition,
   type IsNullable
 } from "./column-state.js"
+import type * as Casing from "./casing.js"
+import * as Expression from "./scalar.js"
 import type { Any as AnyExpression } from "./scalar.js"
+import * as SchemaExpression from "./schema-expression.js"
 import type { Any as AnySchemaExpression } from "./schema-expression.js"
 import type { TableFieldMap } from "./schema-derivation.js"
@@ -39,6 +42,27 @@ const validateReferentialAction = (action: unknown): void => {
   }
 }
+const requireColumnArray = (
+  value: unknown,
+  message: string
+): readonly string[] => {
+  if (!Array.isArray(value) || value.some((column) => typeof column !== "string" || column.length === 0)) {
+    throw new Error(message)
+  }
+  return value
+}
+const requireOptionalColumnArray = (
+  value: unknown,
+  message: string
+): readonly string[] =>
+  value === undefined ? [] : requireColumnArray(value, message)
+const isDdlExpressionLike = (value: unknown): value is DdlExpressionLike =>
+  typeof value === "object" &&
+  value !== null &&
+  (Expression.TypeId in value || SchemaExpression.TypeId in value)
 export type IndexKeySpec =
   | {
       readonly kind: "column"
@@ -91,6 +115,7 @@ export type TableOptionSpec =
       readonly references: () => {
         readonly tableName: string
         readonly schemaName?: string
+        readonly casing?: Casing.Options
         readonly columns: ColumnList
         readonly knownColumns?: readonly string[]
       }
@@ -134,6 +159,83 @@ type TupleFromColumns<Columns> = Columns extends readonly [infer Head extends st
 export type NonEmptyColumnInput<Columns extends string | readonly string[]> =
   TupleFromColumns<Columns> extends never ? never : Columns
+export type NonEmptyStringInput<Value extends string> =
+  string extends Value ? Value : Value extends "" ? never : Value
+export type LiteralStringInput<Value extends string> =
+  string extends Value ? never : NonEmptyStringInput<Value>
+type LowerAlpha =
+  | "a"
+  | "b"
+  | "c"
+  | "d"
+  | "e"
+  | "f"
+  | "g"
+  | "h"
+  | "i"
+  | "j"
+  | "k"
+  | "l"
+  | "m"
+  | "n"
+  | "o"
+  | "p"
+  | "q"
+  | "r"
+  | "s"
+  | "t"
+  | "u"
+  | "v"
+  | "w"
+  | "x"
+  | "y"
+  | "z"
+type UpperAlpha = Uppercase<LowerAlpha>
+type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
+type IdentifierStart = LowerAlpha | UpperAlpha | "_"
+type IdentifierRest = IdentifierStart | Digit
+type SafeIdentifierRest<Value extends string> =
+  Value extends ""
+    ? Value
+    : Value extends `${infer Head}${infer Tail}`
+      ? Head extends IdentifierRest ? SafeIdentifierRest<Tail> : never
+      : never
+type SafeSqlIdentifier<Value extends string> =
+  Value extends `${infer Head}${infer Tail}`
+    ? Head extends IdentifierStart
+      ? SafeIdentifierRest<Tail> extends never ? never : Value
+      : never
+    : never
+export type SafeSqlIdentifierPathInput<Value extends string> =
+  string extends Value
+    ? never
+    : Value extends `${infer Head}.${infer Tail}`
+      ? SafeSqlIdentifier<Head> extends never
+        ? never
+        : SafeSqlIdentifierPathInput<Tail> extends never ? never : Value
+      : SafeSqlIdentifier<Value> extends never ? never : Value
+export type SafeSqlIdentifierInput<Value extends string> =
+  string extends Value
+    ? never
+    : SafeSqlIdentifier<Value> extends never ? never : Value
+type LiteralStringTupleInput<Values extends readonly string[]> = {
+  readonly [K in keyof Values]: Values[K] extends string ? LiteralStringInput<Values[K]> : never
+} & Values
+export type CollationIdentifierInput<Value extends string | readonly [string, ...string[]]> =
+  Value extends string
+    ? LiteralStringInput<Value>
+    : Value extends readonly [string, ...string[]]
+      ? LiteralStringTupleInput<Value>
+      : never
 export type MatchingColumnArityInput<
   Left extends string | readonly string[],
   Right extends string | readonly string[]
@@ -206,11 +308,10 @@ type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
 /** Normalizes a string or tuple input into a non-empty column list. */
 export const normalizeColumnList = (columns: string | readonly string[]): ColumnList => {
-  const normalized = Array.isArray(columns) ? [...columns] : [columns]
-  if (normalized.length === 0) {
-    throw new Error("Table options require at least one column")
+  if (typeof columns === "string") {
+    return [columns]
   }
-  return normalized as unknown as ColumnList
+  return [columns[0] as string, ...columns.slice(1)]
 }
 /** Converts inline column flags into normalized table option records. */
@@ -236,8 +337,6 @@ export const collectInlineOptions = <Fields extends TableFieldMap>(
       })
     }
     if (column.metadata.references) {
-      validateReferentialAction(column.metadata.references.onUpdate)
-      validateReferentialAction(column.metadata.references.onDelete)
       const local = [columnName] as ColumnList
       options.push({
         kind: "foreignKey",
@@ -248,6 +347,7 @@ export const collectInlineOptions = <Fields extends TableFieldMap>(
           return {
             tableName: bound.baseTableName,
             schemaName: bound.schemaName,
+            casing: bound.casing,
             columns: [bound.columnName]
           }
         },
@@ -287,24 +387,16 @@ export const resolvePrimaryKeyColumns = <Fields extends TableFieldMap>(
   const inline = Object.entries(fields)
     .filter(([, column]) => column.metadata.primaryKey)
     .map(([key]) => key) as (keyof Fields & string)[]
-  const explicit = declaredOptions
-    .filter((option) => option.kind === "primaryKey")
-    .map((option) => option.columns)
-  if (explicit.length > 1) {
-    throw new Error("Only one primary key declaration is allowed")
-  }
+  const explicit = declaredOptions.flatMap((option) => {
+    if (typeof option !== "object" || option === null || !("kind" in option) || option.kind !== "primaryKey") {
+      return []
+    }
+    return Array.isArray(option.columns) ? [option.columns] : []
+  })
   if (explicit.length === 0) {
     return inline
   }
   const tablePrimaryKey = [...explicit[0]!] as (keyof Fields & string)[]
-  if (inline.length > 0) {
-    const same =
-      inline.length === tablePrimaryKey.length &&
-      inline.every((column) => tablePrimaryKey.includes(column))
-    if (!same) {
-      throw new Error("Inline primary keys conflict with table-level primary key declaration")
-    }
-  }
   return tablePrimaryKey
 }
@@ -312,67 +404,35 @@ export const resolvePrimaryKeyColumns = <Fields extends TableFieldMap>(
 export const validateOptions = <Fields extends TableFieldMap>(
   tableName: string,
   fields: Fields,
-  options: readonly TableOptionSpec[]
+  options: unknown
 ): void => {
-  const knownColumns = new Set(Object.keys(fields))
-  for (const option of options) {
+  const tableOptions = (Array.isArray(options)
+    ? options
+    : [options]) as readonly TableOptionSpec[]
+  for (const option of tableOptions) {
+    if (typeof option !== "object" || option === null || !("kind" in option)) {
+      continue
+    }
     switch (option.kind) {
       case "index":
       case "primaryKey":
       case "unique":
       case "foreignKey": {
-        const columns = option.kind === "index"
-          ? option.columns ?? []
-          : option.columns
-        if (columns.length === 0 && option.kind !== "index") {
-          throw new Error(`Option '${option.kind}' on table '${tableName}' requires at least one column`)
-        }
-        for (const column of columns) {
-          if (!knownColumns.has(column)) {
-            throw new Error(`Unknown column '${column}' on table '${tableName}'`)
-          }
-        }
-        if (option.kind === "foreignKey") {
-          validateReferentialAction(option.onUpdate)
-          validateReferentialAction(option.onDelete)
-          const reference = option.references()
-          if (reference.columns.length !== columns.length) {
-            throw new Error(`Foreign key on table '${tableName}' must reference the same number of columns`)
-          }
-          if (reference.knownColumns) {
-            const referenced = new Set(reference.knownColumns)
-            for (const column of reference.columns) {
-              if (!referenced.has(column)) {
-                throw new Error(`Unknown referenced column '${column}' on table '${reference.tableName}'`)
-              }
-            }
-          }
-        }
         if (option.kind === "index") {
-          for (const column of option.include ?? []) {
-            if (!knownColumns.has(column)) {
-              throw new Error(`Unknown included column '${column}' on table '${tableName}'`)
-            }
-          }
-          for (const key of option.keys ?? []) {
-            if (key.kind === "column" && !knownColumns.has(key.column)) {
-              throw new Error(`Unknown index key column '${key.column}' on table '${tableName}'`)
+          const keys = Array.isArray(option.keys) ? option.keys : []
+          for (const key of keys) {
+            if (typeof key !== "object" || key === null || !("kind" in key)) {
+              continue
             }
           }
-          if (columns.length === 0 && (option.keys === undefined || option.keys.length === 0)) {
-            throw new Error(`Index on table '${tableName}' requires at least one column or key`)
-          }
         }
         break
       }
       case "check": {
         break
       }
-    }
-  }
-  for (const column of resolvePrimaryKeyColumns(fields, options)) {
-    if (fields[column]!.metadata.nullable) {
-      throw new Error(`Primary key column '${String(column)}' cannot be nullable`)
+      default:
+        break
     }
   }
 }

package/src/internal/table.d.ts CHANGED Viewed

@@ -3,7 +3,7 @@ import * as Schema from "effect/Schema";
 import * as Plan from "./row-set.js";
 import type { TrueFormula } from "./predicate/formula.js";
 import type { BoundColumnFrom } from "./column-state.js";
-import { type DdlExpressionLike, type NormalizeColumns, type TableOptionSpec, type ValidateKnownColumns, type ValidatePrimaryKeyColumns } from "./table-options.js";
+import { type DdlExpressionLike, type NonEmptyStringInput, type NormalizeColumns, type TableOptionSpec, type ValidateKnownColumns, type ValidatePrimaryKeyColumns } from "./table-options.js";
 import { type InsertRow, type SelectRow, type TableFieldMap, type UpdateRow } from "./schema-derivation.js";
 /** Symbol used to attach table-definition metadata. */
 export declare const TypeId: unique symbol;
@@ -59,13 +59,9 @@ interface TableState<Name extends string, Fields extends TableFieldMap, PrimaryK
     readonly primaryKey: readonly PrimaryKeyColumns[];
     readonly kind: Kind;
 }
-/** Namespace-scoped table builder. */
-export interface TableSchemaNamespace<SchemaName extends string> {
-    readonly schemaName: SchemaName;
-    readonly table: <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>>(name: Name, fields: Fields, ...options: DeclaredTableOptions) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>;
-}
 export type DeclaredTableOptions = readonly TableOptionBuilderLike[];
 export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js";
+export type NonEmptySchemaNameInput<Value extends string | undefined> = Value extends string ? NonEmptyStringInput<Value> : Value;
 export type TableDefinition<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> = Pipeable & {
     readonly name: Name;
     readonly columns: BoundColumns<Name, Fields>;
@@ -92,7 +88,10 @@ export type TableClassStatic<Name extends string, Fields extends TableFieldMap,
     readonly tableName: Name;
 } & BoundColumns<Name, Fields> & Plan.RowSet<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
 /** Minimal structural table-like contract used across helper APIs. */
-export type AnyTable = TableDefinition<any, any, any, any, any> | TableClassStatic<any, any, any, any>;
+export type AnyTable<Dialect extends string = string> = {
+    readonly [TypeId]: TableState<string, TableFieldMap, string, TableKind, string | undefined>;
+    readonly [OptionsSymbol]: readonly TableOptionSpec[];
+} & Plan.RowSet<any, any, Record<string, Plan.AnySource>, Dialect>;
 /** Public table-option builder type used by `Table.index`, `Table.primaryKey`, and friends. */
 export type TableOption<Spec extends TableOptionSpec = TableOptionSpec> = {
     <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: OptionInputTable<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>): ApplyOption<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>;
@@ -101,11 +100,7 @@ export type TableOption<Spec extends TableOptionSpec = TableOptionSpec> = {
 export declare const option: <Spec extends TableOptionSpec>(spec: Spec) => TableOption<Spec>;
 export declare const optionFromTable: <Spec extends TableOptionSpec>(spec: Spec, resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec) => TableOption<Spec>;
 /** Creates a table definition from a name and field map. */
-export declare function make<Name extends string, Fields extends TableFieldMap, SchemaName extends string | undefined = DefaultSchemaName>(name: Name, fields: Fields, schemaName?: SchemaName): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>;
-/**
- * Creates a namespace-scoped builder for a concrete SQL schema/database.
- */
-export declare const schema: <SchemaName extends string>(schemaName: SchemaName) => TableSchemaNamespace<SchemaName>;
+export declare function make<Name extends string, Fields extends TableFieldMap, const SchemaName extends string | undefined = DefaultSchemaName>(name: NonEmptyStringInput<Name>, fields: Fields, schemaName?: NonEmptySchemaNameInput<SchemaName>): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>;
 /**
  * Creates an aliased source from an existing table definition.
  *
@@ -114,13 +109,21 @@ export declare const schema: <SchemaName extends string>(schemaName: SchemaName)
  * downstream SQL rendering work.
  */
 export declare const alias: <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, SchemaName extends string, AliasName extends string>(table: TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName> | TableDefinition<Name, Fields, PrimaryKeyColumns, any, SchemaName>, aliasName: AliasName) => TableDefinition<AliasName, Fields, PrimaryKeyColumns, "alias", SchemaName>;
+/** Returns the lazily derived select schema for a table. */
+export declare function selectSchema<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>): Schema.Schema<SelectRow<Name, Fields>>;
+/** Returns the lazily derived insert schema for a table. */
+export declare function insertSchema<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>): Schema.Schema<InsertRow<Name, Fields>>;
+/** Returns the lazily derived update schema for a table. */
+export declare function updateSchema<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>): Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>;
 /**
  * Class-based table constructor mirroring `Schema.Class`.
  *
  * The returned base class can be extended and configured with
  * `static readonly [Table.options]`.
  */
-export declare function Class<Self = never, SchemaName extends string | undefined = DefaultSchemaName>(name: string, schemaName?: SchemaName): <Fields extends TableFieldMap>(fields: Fields) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`" : TableClassStatic<string, Fields, Extract<{ [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never; }[keyof Fields], string>, SchemaName>;
+export declare function Class<Self = never>(name: "", schemaName?: string | undefined): never;
+export declare function Class<Self = never>(name: string, schemaName: ""): never;
+export declare function Class<Self = never, const SchemaName extends string | undefined = DefaultSchemaName, const Name extends string = string>(name: NonEmptyStringInput<Name>, schemaName?: NonEmptySchemaNameInput<SchemaName>): <Fields extends TableFieldMap>(fields: Fields) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`" : TableClassStatic<Name, Fields, Extract<{ [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never; }[keyof Fields], string>, SchemaName>;
 /** Declares a table-level primary key. */
 export declare const primaryKey: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
     readonly kind: "primaryKey";
@@ -148,26 +151,24 @@ export declare const foreignKey: <const LocalColumns extends string | readonly s
     };
 }>;
 /** Declares a check constraint expression. */
-export declare const check: <Name extends string>(name: Name, predicate: DdlExpressionLike) => TableOption<{
+export declare const check: <const Name extends string>(name: NonEmptyStringInput<Name>, predicate: DdlExpressionLike) => TableOption<{
     readonly kind: "check";
     readonly name: Name;
     readonly predicate: DdlExpressionLike;
 }>;
-/** Extracts the row type of a table's select schema. */
-export type SelectOf<Table extends {
-    readonly schemas: {
-        readonly select: Schema.Schema<any>;
-    };
-}> = Schema.Schema.Type<Table["schemas"]["select"]>;
-/** Extracts the payload type of a table's insert schema. */
-export type InsertOf<Table extends {
-    readonly schemas: {
-        readonly insert: Schema.Schema<any>;
-    };
-}> = Schema.Schema.Type<Table["schemas"]["insert"]>;
-/** Extracts the payload type of a table's update schema. */
-export type UpdateOf<Table extends {
-    readonly schemas: {
-        readonly update: Schema.Schema<any>;
-    };
-}> = Schema.Schema.Type<Table["schemas"]["update"]>;
+/** Extracts the row type produced by `selectSchema(table)`. */
+export type SelectOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+    readonly name: infer Name extends string;
+    readonly fields: infer Fields extends TableFieldMap;
+} ? SelectRow<Name, Fields> : never;
+/** Extracts the payload type produced by `insertSchema(table)`. */
+export type InsertOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+    readonly name: infer Name extends string;
+    readonly fields: infer Fields extends TableFieldMap;
+} ? InsertRow<Name, Fields> : never;
+/** Extracts the payload type produced by `updateSchema(table)`. */
+export type UpdateOf<Table extends AnyTable> = Table[typeof TypeId] extends {
+    readonly name: infer Name extends string;
+    readonly fields: infer Fields extends TableFieldMap;
+    readonly primaryKey: readonly (infer PrimaryKeyColumns)[];
+} ? UpdateRow<Name, Fields, Extract<PrimaryKeyColumns, keyof Fields & string>> : never;