effect-qb 0.16.0 → 0.19.0

package/src/internal/table.ts

@@ -12,20 +12,30 @@ import {
   resolvePrimaryKeyColumns,
   type DdlExpressionLike,
   type IndexKeySpec,
+  type LiteralStringInput,
+  type MatchingColumnArityInput,
+  type NonEmptyColumnInput,
+  type NonEmptyStringInput,
   type NormalizeColumns,
   type ReferentialAction,
   type TableOptionSpec,
+  type ValidateForeignKeyOptionColumns,
+  type ValidateIndexOptionColumns,
   type ValidateKnownColumns,
   type ValidatePrimaryKeyColumns,
   validateOptions
 } from "./table-options.js"
 import {
-  deriveSchemas,
+  deriveInsertSchema,
+  deriveSelectSchema,
+  deriveUpdateSchema,
   type InsertRow,
   type SelectRow,
   type TableFieldMap,
+  type TableSchemaVariant,
   type UpdateRow
 } from "./schema-derivation.js"
+import * as Casing from "./casing.js"
 
 /** Symbol used to attach table-definition metadata. */
 export const TypeId: unique symbol = Symbol.for("effect-qb/Table")
@@ -35,60 +45,141 @@ export const OptionsSymbol: unique symbol = Symbol.for("effect-qb/Table/normaliz
 export const options: unique symbol = Symbol.for("effect-qb/Table/declaredOptions")
 
 const CacheSymbol: unique symbol = Symbol.for("effect-qb/Table/cache")
+const SchemaCacheSymbol: unique symbol = Symbol.for("effect-qb/Table/schemaCache")
 const DeclaredOptionsSymbol: unique symbol = Symbol.for("effect-qb/Table/factoryDeclaredOptions")
 
 type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
   [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never
 }[keyof Fields], string>
 
-type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof import("./column-state.js").ColumnTypeId]["dbType"]["dialect"]
+type FieldDialects<Fields extends TableFieldMap> = Fields[keyof Fields][typeof import("./column-state.js").ColumnTypeId]["dbType"]["dialect"]
+type ConcreteFieldDialects<Fields extends TableFieldMap> = Exclude<FieldDialects<Fields>, "standard">
+type TableDialect<Fields extends TableFieldMap> = [ConcreteFieldDialects<Fields>] extends [never]
+  ? "standard"
+  : ConcreteFieldDialects<Fields>
 type TableKind = "schema" | "alias"
 type DefaultSchemaName = "public"
-type ClassOptionSpec = Exclude<TableOptionSpec, { readonly kind: "primaryKey" }>
+type NonEmptyFieldMap<Fields extends TableFieldMap> =
+  string extends keyof Fields ? Fields : "" extends keyof Fields ? never : Fields
+type FieldColumnName<Fields extends TableFieldMap> = Extract<keyof Fields, string>
+type FieldColumnList<Fields extends TableFieldMap> = readonly [FieldColumnName<Fields>, ...FieldColumnName<Fields>[]]
+type FieldIndexKeySpec<Fields extends TableFieldMap> =
+  | (Extract<IndexKeySpec, { readonly kind: "column" }> & { readonly column: FieldColumnName<Fields> })
+  | Extract<IndexKeySpec, { readonly kind: "expression" }>
+type ClassOptionSpec<Fields extends TableFieldMap = TableFieldMap> =
+  | (Omit<Extract<TableOptionSpec, { readonly kind: "index" }>, "columns" | "include" | "keys"> & {
+      readonly columns?: FieldColumnList<Fields>
+      readonly include?: readonly FieldColumnName<Fields>[]
+      readonly keys?: readonly [FieldIndexKeySpec<Fields>, ...FieldIndexKeySpec<Fields>[]]
+    })
+  | (Omit<Extract<TableOptionSpec, { readonly kind: "unique" }>, "columns"> & {
+      readonly columns: FieldColumnList<Fields>
+    })
+  | (Omit<Extract<TableOptionSpec, { readonly kind: "foreignKey" }>, "columns"> & {
+      readonly columns: FieldColumnList<Fields>
+    })
+  | Extract<TableOptionSpec, { readonly kind: "check" }>
 interface TableOptionBuilderLike<
   Spec extends TableOptionSpec = TableOptionSpec
 > {
-  (
-    table: TableDefinition<any, any, any, "schema", any>
-  ): TableDefinition<any, any, any, "schema", any>
   readonly option: Spec
 }
 
-type ClassTableOption = TableOptionBuilderLike<ClassOptionSpec>
-type ClassDeclaredTableOptions = readonly ClassTableOption[]
+type ClassTableOption<Fields extends TableFieldMap> = TableOptionBuilderLike<ClassOptionSpec<Fields>>
+type ClassDeclaredTableOptions<Fields extends TableFieldMap> = readonly ClassTableOption<Fields>[]
+type TableNameOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<infer Name, any, any, "schema", any> ? Name : never
+type TableFieldsOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<any, infer Fields, any, "schema", any> ? Fields : never
+type TablePrimaryKeyOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<any, any, infer PrimaryKeyColumns, "schema", any> ? PrimaryKeyColumns : never
+type TableSchemaNameOf<Table extends TableDefinition<any, any, any, "schema", any>> =
+  Table extends TableDefinition<any, any, any, "schema", infer SchemaName> ? SchemaName : never
 
 type BuildPrimaryKey<
   Table extends TableDefinition<any, any, any, "schema", any>,
   Spec extends TableOptionSpec
 > = Spec extends { readonly kind: "primaryKey"; readonly columns: infer Columns extends readonly string[] }
-  ? Columns[number] & keyof Table[typeof TypeId]["fields"] & string
-  : Table[typeof TypeId]["primaryKey"][number]
+  ? Columns[number] & keyof TableFieldsOf<Table> & string
+  : TablePrimaryKeyOf<Table>
 
-type OptionInputTable<
+type OptionInputConstraint<
   Table extends TableDefinition<any, any, any, "schema", any>,
   Spec extends TableOptionSpec
 > = Spec extends { readonly kind: "primaryKey"; readonly columns: infer Columns extends readonly string[] }
-  ? ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table
-  : Spec extends { readonly columns: infer Columns extends readonly string[] }
-    ? ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table
-    : Table
+  ? ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : unknown
+  : Spec extends { readonly kind: "index" }
+    ? ValidateIndexOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : unknown
+    : Spec extends { readonly kind: "foreignKey" }
+      ? ValidateForeignKeyOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : unknown
+      : Spec extends { readonly columns: infer Columns extends readonly string[] }
+        ? ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : unknown
+        : unknown
+
+type OptionInputTable<
+  Table extends TableDefinition<any, any, any, "schema", any>,
+  Spec extends TableOptionSpec
+> = Table & OptionInputConstraint<Table, Spec>
+
+type OptionValidationArgs<
+  Table extends TableDefinition<any, any, any, "schema", any>,
+  Spec extends TableOptionSpec
+> = OptionInputConstraint<Table, Spec> extends never ? [never] : []
 
 type ApplyOption<
   Table extends TableDefinition<any, any, any, "schema", any>,
   Spec extends TableOptionSpec
 > = Spec extends { readonly kind: "primaryKey" }
   ? TableDefinition<
-    Table[typeof TypeId]["name"],
-    Table[typeof TypeId]["fields"],
+    TableNameOf<Table>,
+    TableFieldsOf<Table>,
     BuildPrimaryKey<Table, Spec>,
-    "schema"
-  >
-  : TableDefinition<
-    Table[typeof TypeId]["name"],
-    Table[typeof TypeId]["fields"],
-    Table[typeof TypeId]["primaryKey"][number],
-    "schema"
+    "schema",
+    TableSchemaNameOf<Table>
   >
+  : Table
+
+type ApplyTableOption<
+  Table extends TableDefinition<any, any, any, "schema", any>,
+  Spec extends TableOptionSpec
+> = Spec extends { readonly kind: "primaryKey" }
+  ? ApplyOption<Table, Spec>
+  : Table
+
+type TableOptionPipe<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string,
+  Kind extends TableKind,
+  SchemaName extends string | undefined
+> = Kind extends "schema"
+  ? {
+      pipe<Spec extends TableOptionSpec>(
+        option: TableOption<Spec>,
+        ...validation: OptionValidationArgs<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Spec>
+      ): ApplyTableOption<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Spec>
+    }
+  : {}
+
+export type ValidateDeclaredOptions<
+  Table extends TableDefinition<any, any, any, "schema", any>,
+  Options extends DeclaredTableOptions
+> = {
+  readonly [K in keyof Options]: Options[K] extends TableOptionBuilderLike<infer Spec>
+    ? OptionInputTable<Table, Spec> extends never ? never : Options[K]
+    : never
+}
+
+export type ApplyDeclaredOptions<
+  Table extends TableDefinition<any, any, any, "schema", any>,
+  Options extends DeclaredTableOptions
+> = Options extends readonly [infer Head, ...infer Tail]
+  ? Head extends TableOptionBuilderLike<infer Spec>
+    ? Tail extends DeclaredTableOptions
+      ? ApplyDeclaredOptions<ApplyOption<Table, Spec>, Tail>
+      : ApplyOption<Table, Spec>
+    : Table
+  : Table
 
 export type MissingSelfGeneric = "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`"
 
@@ -111,6 +202,20 @@ export interface TableSchemas<
   readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
 }
 
+type AnyTableSchemas = {
+  readonly select: Schema.Schema<any>
+  readonly insert: Schema.Schema<any>
+  readonly update: Schema.Schema<any>
+}
+
+type TableSchemaCache<
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+> = Partial<TableSchemas<Name, Fields, PrimaryKeyColumns>> & {
+  schemas?: TableSchemas<Name, Fields, PrimaryKeyColumns>
+}
+
 interface TableState<
   Name extends string,
   Fields extends TableFieldMap,
@@ -124,24 +229,14 @@ interface TableState<
   readonly fields: Fields
   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>
+  readonly casing?: Casing.Options
 }
 
 export type DeclaredTableOptions = readonly TableOptionBuilderLike[]
-export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js"
+export type { DdlExpressionLike, IndexKeySpec, LiteralStringInput, MatchingColumnArityInput, NonEmptyColumnInput, NonEmptyStringInput, NormalizeColumns, ReferentialAction } from "./table-options.js"
+export type { NonEmptyFieldMap }
+export type NonEmptySchemaNameInput<Value extends string | undefined> =
+  Value extends string ? NonEmptyStringInput<Value> : Value
 
 export type TableDefinition<
   Name extends string,
@@ -149,10 +244,10 @@ export type TableDefinition<
   PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
   Kind extends TableKind = "schema",
   SchemaName extends string | undefined = DefaultSchemaName
-> = Pipeable & {
+> = TableOptionPipe<Name, Fields, PrimaryKeyColumns, Kind, SchemaName> & Pipeable & {
   readonly name: Name
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
+  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns> & AnyTableSchemas
   readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
   readonly [Plan.TypeId]: Plan.State<
     BoundColumns<Name, Fields>,
@@ -192,7 +287,7 @@ export type TableClassStatic<
   >
   readonly [OptionsSymbol]: readonly TableOptionSpec[]
   readonly [DeclaredOptionsSymbol]?: readonly TableOptionSpec[]
-  readonly [options]?: ClassDeclaredTableOptions
+  readonly [options]?: ClassDeclaredTableOptions<Fields>
   readonly tableName: Name
 } & BoundColumns<Name, Fields> & Plan.RowSet<
     BoundColumns<Name, Fields>,
@@ -202,24 +297,37 @@ export type TableClassStatic<
   >
 
 /** 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>
+
+type FieldsOfAnyTable<Table extends AnyTable> = Table[typeof TypeId]["fields"]
+
+type ColumnNamesOfAnyTable<Table extends AnyTable> = Extract<keyof FieldsOfAnyTable<Table>, string>
 
 /** 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>
+> = Pipeable & {
+  readonly pipe: Pipeable["pipe"]
   readonly option: Spec
-}
+} & (Spec extends { readonly kind: "primaryKey" }
+  ? {
+  <Table extends TableDefinition<any, any, any, "schema", any>>(
+    table: Table,
+    ...validation: OptionValidationArgs<Table, Spec>
+  ): ApplyOption<Table, Spec>
+  }
+  : {
+    <Table extends TableDefinition<any, any, any, "schema", any>>(
+      table: Table,
+      ...validation: OptionValidationArgs<Table, Spec>
+    ): Table
+  })
 
 const TableProto = {
-  pipe(this: unknown) {
+  pipe(this: Pipeable) {
     return pipeArguments(this, arguments)
   }
 }
@@ -228,7 +336,7 @@ const attachPipe = <Value extends object>(value: Value): Value => {
   Object.defineProperty(value, "pipe", {
     configurable: true,
     writable: true,
-    value: function(this: unknown) {
+    value: function(this: Value) {
       return pipeArguments(value, arguments)
     }
   })
@@ -241,7 +349,6 @@ type BuildArtifacts<
   PrimaryKeyColumns extends keyof Fields & string
 > = {
   readonly columns: BoundColumns<Name, Fields>
-  readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>
   readonly normalizedOptions: readonly TableOptionSpec[]
   readonly primaryKey: readonly PrimaryKeyColumns[]
 }
@@ -254,24 +361,159 @@ const buildArtifacts = <
   name: Name,
   fields: Fields,
   declaredOptions: readonly TableOptionSpec[],
-  schemaName: SchemaName
+  schemaName: SchemaName,
+  casing?: Casing.Options
 ): BuildArtifacts<Name, Fields, keyof Fields & string> => {
   const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions]
   validateFieldDialects(name, fields)
   validateOptions(name, fields, declaredOptions)
   const primaryKey = resolvePrimaryKeyColumns(fields, declaredOptions) as readonly (keyof Fields & string)[]
   const columns = Object.fromEntries(
-    Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)])
+    Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName, casing)])
   ) as BoundColumns<Name, Fields>
-  const schemas = deriveSchemas(name, fields, primaryKey)
   return {
     columns,
-    schemas,
     normalizedOptions,
     primaryKey
   }
 }
 
+const getSchemaCache = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): TableSchemaCache<Name, Fields, PrimaryKeyColumns> => {
+  const target = table as {
+    [SchemaCacheSymbol]?: TableSchemaCache<Name, Fields, PrimaryKeyColumns>
+  }
+  if (target[SchemaCacheSymbol] !== undefined) {
+    return target[SchemaCacheSymbol]
+  }
+  const cache: TableSchemaCache<Name, Fields, PrimaryKeyColumns> = {}
+  Object.defineProperty(table, SchemaCacheSymbol, {
+    configurable: true,
+    value: cache
+  })
+  return cache
+}
+
+const deriveTableSchema = <
+  Variant extends TableSchemaVariant,
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>,
+  variant: Variant
+): TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant] => {
+  const state = table[TypeId]
+  switch (variant) {
+    case "select":
+      return deriveSelectSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+    case "insert":
+      return deriveInsertSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+    case "update":
+      return deriveUpdateSchema(state.name, state.fields, state.primaryKey) as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+  }
+}
+
+const schemaFor = <
+  Variant extends TableSchemaVariant,
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>,
+  variant: Variant
+): TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant] => {
+  const cache = getSchemaCache(table)
+  const cached = cache[variant]
+  if (cached !== undefined) {
+    return cached as TableSchemas<Name, Fields, PrimaryKeyColumns>[Variant]
+  }
+  const schema = deriveTableSchema(table, variant)
+  cache[variant] = schema as any
+  return schema
+}
+
+export 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>> {
+  return schemaFor(table, "select") as Schema.Schema<SelectRow<Name, Fields>>
+}
+
+export 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>> {
+  return schemaFor(table, "insert") as Schema.Schema<InsertRow<Name, Fields>>
+}
+
+export 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>> {
+  return schemaFor(table, "update") as Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
+}
+
+const schemasFor = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>
+): TableSchemas<Name, Fields, PrimaryKeyColumns> => {
+  const cache = getSchemaCache(table)
+  if (cache.schemas !== undefined) {
+    return cache.schemas
+  }
+  const schemas = {} as TableSchemas<Name, Fields, PrimaryKeyColumns>
+  Object.defineProperties(schemas, {
+    select: {
+      enumerable: true,
+      get: () => selectSchema(table)
+    },
+    insert: {
+      enumerable: true,
+      get: () => insertSchema(table)
+    },
+    update: {
+      enumerable: true,
+      get: () => updateSchema(table)
+    }
+  })
+  cache.schemas = schemas
+  return schemas
+}
+
+const defineSchemasGetter = <
+  Name extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any>
+): void => {
+  Object.defineProperty(table, "schemas", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return schemasFor(table)
+    }
+  })
+}
+
 const makeTable = <
   Name extends string,
   Fields extends TableFieldMap,
@@ -285,24 +527,26 @@ const makeTable = <
   baseName: string = name,
   kind: Kind = "schema" as Kind,
   schemaName?: SchemaName,
-  schemaMode: "default" | "explicit" = "default"
+  schemaMode: "default" | "explicit" = "default",
+  casing?: Casing.Options
 ): TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName> => {
   const resolvedSchemaName = schemaMode === "explicit"
     ? schemaName
     : ("public" as SchemaName)
-  const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName)
+  const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName, casing)
   const dialect = resolveFieldDialect(fields)
   const table = attachPipe(Object.create(TableProto))
   table.name = name
   table.columns = artifacts.columns
-  table.schemas = artifacts.schemas
+  defineSchemasGetter(table)
   table[TypeId] = {
     name,
     baseName,
     schemaName: resolvedSchemaName,
     fields,
     primaryKey: artifacts.primaryKey,
-    kind
+    kind,
+    casing
   }
   table[Plan.TypeId] = {
     selection: artifacts.columns,
@@ -341,28 +585,25 @@ const applyDeclaredOptions = <
     return table
   }
   return declaredOptions.reduce<TableDefinition<any, any, any, "schema", any>>(
-    (current, option) => option(current),
+    (current, option) =>
+      (option as unknown as (
+        table: TableDefinition<any, any, any, "schema", any>
+      ) => TableDefinition<any, any, any, "schema", any>)(current),
     table
   ) as unknown as Table
 }
 
-const validateClassOptions = (declaredOptions: readonly TableOptionSpec[]): void => {
-  for (const option of declaredOptions) {
-    if (option.kind === "primaryKey") {
-      throw new Error("Table.Class does not support table-level primary keys; declare primary keys inline on columns")
-    }
-  }
-}
-
 const resolveFieldDialect = (fields: TableFieldMap): string => {
   const dialects = [...new Set(Object.values(fields).map((field) => field.metadata.dbType.dialect))]
   if (dialects.length === 0) {
     throw new Error("Cannot infer table dialect from an empty field set")
   }
-  if (dialects.length > 1) {
+  const concreteDialects = dialects.filter((dialect) => dialect !== "standard")
+  const uniqueConcreteDialects = [...new Set(concreteDialects)]
+  if (uniqueConcreteDialects.length > 1) {
     throw new Error(`Mixed table dialects are not supported: ${dialects.join(", ")}`)
   }
-  return dialects[0]!
+  return uniqueConcreteDialects[0] ?? "standard"
 }
 
 const validateFieldDialects = (tableName: string, fields: TableFieldMap): void => {
@@ -388,7 +629,6 @@ const ensureClassArtifacts = <
   }
   const state = self[TypeId]
   const classOptions = self[options]
-  validateClassOptions(extractDeclaredOptions(classOptions))
   const table = applyDeclaredOptions(
     makeTable(
       state.name,
@@ -397,13 +637,13 @@ const ensureClassArtifacts = <
       state.name,
       "schema",
       state.schemaName,
-      state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"
+      state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit",
+      state.casing
     ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", typeof state.schemaName>,
     classOptions
   )
   const artifacts = {
     columns: table.columns,
-    schemas: table.schemas,
     normalizedOptions: table[OptionsSymbol],
     primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[]
   } satisfies BuildArtifacts<Name, Fields, PrimaryKeyColumns>
@@ -422,9 +662,6 @@ const appendOption = <
   option: Spec
 ): ApplyOption<Table, Spec> => {
   const state = table[TypeId]
-  if (state.kind !== "schema") {
-    throw new Error("Table options can only be applied to schema tables, not aliased query sources")
-  }
   return makeTable(
     state.name,
     state.fields,
@@ -432,25 +669,37 @@ const appendOption = <
     state.baseName,
     state.kind,
     state.schemaName,
-    "explicit"
+    "explicit",
+    state.casing
   ) as unknown as ApplyOption<Table, Spec>
 }
 
 const makeOption = <Spec extends TableOptionSpec>(option: Spec): TableOption<Spec> => {
-  const builder = ((table: TableDefinition<any, any, any, "schema", any>) =>
-    appendOption(table, option)) as unknown as TableOption<Spec>
-  ;(builder as { option: Spec }).option = option
-  return builder
+  return attachPipe(Object.assign(
+    <Table extends TableDefinition<any, any, any, "schema", any>>(
+      table: Table,
+      ..._validation: OptionValidationArgs<Table, Spec>
+    ): ApplyTableOption<Table, Spec> =>
+      appendOption(table, option) as unknown as ApplyTableOption<Table, Spec>,
+    { option }
+  )) as TableOption<Spec>
 }
 
 const makeResolvedOption = <Spec extends TableOptionSpec>(
   option: Spec,
   resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec
 ): TableOption<Spec> => {
-  const builder = ((table: TableDefinition<any, any, any, "schema", any>) =>
-    appendOption(table, resolve(table))) as unknown as TableOption<Spec>
-  ;(builder as { option: Spec }).option = option
-  return builder
+  return attachPipe(Object.assign(
+    <Table extends TableDefinition<any, any, any, "schema", any>>(
+      table: Table,
+      ..._validation: OptionValidationArgs<Table, Spec>
+    ): ApplyTableOption<Table, Spec> =>
+      appendOption(
+        table,
+        resolve(table)
+      ) as unknown as ApplyTableOption<Table, Spec>,
+    { option }
+  )) as TableOption<Spec>
 }
 
 export const option = <Spec extends TableOptionSpec>(spec: Spec): TableOption<Spec> =>
@@ -463,18 +712,30 @@ export const optionFromTable = <Spec extends TableOptionSpec>(
   makeResolvedOption(spec, resolve)
 
 /** Creates a table definition from a name and field map. */
+export function make<
+  Name extends string,
+  Fields extends TableFieldMap
+>(
+  name: NonEmptyStringInput<Name>,
+  fields: Fields & NonEmptyFieldMap<Fields>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", DefaultSchemaName>
 export function make<
   Name extends string,
   Fields extends TableFieldMap,
-  SchemaName extends string | undefined = DefaultSchemaName
+  const SchemaName extends string
 >(
-  name: Name,
-  fields: Fields,
-  schemaName?: SchemaName
-): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName> {
+  name: NonEmptyStringInput<Name>,
+  fields: Fields & NonEmptyFieldMap<Fields>,
+  schemaName: NonEmptySchemaNameInput<SchemaName>
+): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>
+export function make(
+  name: string,
+  fields: TableFieldMap,
+  schemaName?: string
+): TableDefinition<string, TableFieldMap, string, "schema", string | undefined> {
   const resolvedSchemaName = arguments.length >= 3
     ? schemaName
-    : ("public" as SchemaName)
+    : "public"
   return makeTable(
     name,
     fields,
@@ -486,35 +747,57 @@ export function make<
   )
 }
 
-/**
- * Creates a namespace-scoped builder for a concrete SQL schema/database.
- */
-export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => ({
-  schemaName,
-  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> =>
-    applyDeclaredOptions(
-      makeTable(
-        name,
-        fields,
-        [],
-        name,
-        "schema",
-        schemaName,
-        "explicit"
-      ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
-      options
-    )
-})
+export const withCasing = <
+  Table extends TableDefinition<any, any, any, any, any>
+>(
+  table: Table,
+  casing: Casing.Options
+): Table => {
+  const state = table[TypeId]
+  return makeTable(
+    state.name,
+    state.fields,
+    table[DeclaredOptionsSymbol],
+    state.baseName,
+    state.kind,
+    state.schemaName,
+    "explicit",
+    Casing.merge(state.casing, casing)
+  ) as Table
+}
+
+export const withSchema = <
+  Table extends TableDefinition<any, any, any, any, any>,
+  SchemaName extends string
+>(
+  table: Table,
+  schemaName: SchemaName,
+  schemaCasing?: Casing.Options
+): TableDefinition<
+  Table[typeof TypeId]["name"],
+  Table[typeof TypeId]["fields"],
+  Table[typeof TypeId]["primaryKey"][number],
+  Table[typeof TypeId]["kind"],
+  SchemaName
+> => {
+  const state = table[TypeId]
+  return makeTable(
+    state.name,
+    state.fields,
+    table[DeclaredOptionsSymbol],
+    state.baseName,
+    state.kind,
+    schemaName,
+    "explicit",
+    Casing.merge(schemaCasing, state.casing)
+  ) as TableDefinition<
+    Table[typeof TypeId]["name"],
+    Table[typeof TypeId]["fields"],
+    Table[typeof TypeId]["primaryKey"][number],
+    Table[typeof TypeId]["kind"],
+    SchemaName
+  >
+}
 
 /**
  * Creates an aliased source from an existing table definition.
@@ -531,7 +814,7 @@ export const alias = <
   AliasName extends string
 >(
   table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, SchemaName> | TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>,
-  aliasName: AliasName
+  aliasName: LiteralStringInput<AliasName>
 ): TableDefinition<
   AliasName,
   Fields,
@@ -541,26 +824,27 @@ export const alias = <
 > => {
   const state = table[TypeId]
   const columns = Object.fromEntries(
-    Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column as AnyColumnDefinition, state.baseName, state.schemaName)])
+    Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName as AliasName, key, column as AnyColumnDefinition, state.baseName, state.schemaName, state.casing)])
   ) as BoundColumns<AliasName, Fields>
   const aliased = attachPipe(Object.create(TableProto))
-  aliased.name = aliasName
+  aliased.name = aliasName as AliasName
   aliased.columns = columns
-  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)
+  defineSchemasGetter(aliased)
   aliased[TypeId] = {
-    name: aliasName,
+    name: aliasName as AliasName,
     baseName: state.baseName,
     schemaName: state.schemaName,
     fields: state.fields,
     primaryKey: state.primaryKey,
-    kind: "alias"
+    kind: "alias",
+    casing: state.casing
   }
   aliased[Plan.TypeId] = {
     selection: columns,
     required: undefined as never,
     available: {
       [aliasName]: {
-        name: aliasName,
+        name: aliasName as AliasName,
         mode: "required",
         baseName: state.baseName
       }
@@ -584,19 +868,38 @@ export const alias = <
  * The returned base class can be extended and configured with
  * `static readonly [Table.options]`.
  */
+export function Class<Self = never>(
+  name: "",
+  schemaName?: string | undefined
+): never
+export function Class<Self = never>(
+  name: string,
+  schemaName: ""
+): never
 export function Class<
   Self = never,
-  SchemaName extends string | undefined = DefaultSchemaName
+  const SchemaName extends string | undefined = DefaultSchemaName,
+  const Name extends string = string
+>(
+  name: NonEmptyStringInput<Name>,
+  schemaName?: NonEmptySchemaNameInput<SchemaName>
+): <Fields extends TableFieldMap>(fields: Fields & NonEmptyFieldMap<Fields>) => [Self] extends [never]
+  ? MissingSelfGeneric
+  : TableClassStatic<Name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName>
+export function Class<
+  Self = never,
+  SchemaName extends string | undefined = DefaultSchemaName,
+  Name extends string = string
 >(
   name: string,
   schemaName?: SchemaName
-) {
+): any {
   const resolvedSchemaName = arguments.length >= 2
     ? schemaName
     : ("public" as SchemaName)
-  return <Fields extends TableFieldMap>(fields: Fields): [Self] extends [never]
+  return <Fields extends TableFieldMap>(fields: Fields & NonEmptyFieldMap<Fields>): [Self] extends [never]
     ? MissingSelfGeneric
-    : TableClassStatic<typeof name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName> => {
+    : TableClassStatic<Name, Fields, InlinePrimaryKeyKeys<Fields>, SchemaName> => {
       abstract class TableClassBase {
         static readonly tableName = name
 
@@ -605,12 +908,11 @@ export function Class<
         }
 
         static get schemas() {
-          return ensureClassArtifacts(this as any).schemas
+          return schemasFor(this as any)
         }
 
         static get [TypeId]() {
-          const declaredOptions = extractDeclaredOptions((this as unknown as TableClassStatic<typeof name, Fields>)[options])
-          validateClassOptions(declaredOptions)
+          const declaredOptions = extractDeclaredOptions((this as unknown as TableClassStatic<Name, Fields>)[options])
           return {
             name,
             baseName: name,
@@ -641,7 +943,7 @@ export function Class<
           return ensureClassArtifacts(this as any).normalizedOptions
         }
 
-        static pipe(this: unknown) {
+        static pipe(this: Pipeable) {
           return pipeArguments(this, arguments)
         }
       }
@@ -664,7 +966,7 @@ export function Class<
 export const primaryKey = <
   const Columns extends string | readonly string[]
 >(
-  columns: Columns
+  columns: Columns & NonEmptyColumnInput<Columns>
 ): TableOption<{
   readonly kind: "primaryKey"
   readonly columns: NormalizeColumns<Columns>
@@ -677,7 +979,7 @@ export const primaryKey = <
 export const unique = <
   const Columns extends string | readonly string[]
 >(
-  columns: Columns
+  columns: Columns & NonEmptyColumnInput<Columns>
 ): TableOption<{
   readonly kind: "unique"
   readonly columns: NormalizeColumns<Columns>
@@ -690,7 +992,7 @@ export const unique = <
 export const index = <
   const Columns extends string | readonly string[]
 >(
-  columns: Columns
+  columns: Columns & NonEmptyColumnInput<Columns>
 ): TableOption<{
   readonly kind: "index"
   readonly columns: NormalizeColumns<Columns>
@@ -705,9 +1007,9 @@ export const foreignKey = <
   TargetTable extends AnyTable,
   const TargetColumns extends string | readonly string[]
 >(
-  columns: LocalColumns,
+  columns: LocalColumns & NonEmptyColumnInput<LocalColumns>,
   target: () => TargetTable,
-  referencedColumns: TargetColumns
+  referencedColumns: TargetColumns & NonEmptyColumnInput<TargetColumns> & MatchingColumnArityInput<LocalColumns, TargetColumns>
 ): TableOption<{
   readonly kind: "foreignKey"
   readonly columns: NormalizeColumns<LocalColumns>
@@ -715,7 +1017,7 @@ export const foreignKey = <
     readonly tableName: string
     readonly schemaName?: string
     readonly columns: NormalizeColumns<TargetColumns>
-    readonly knownColumns: readonly string[]
+    readonly knownColumns: readonly ColumnNamesOfAnyTable<TargetTable>[]
   }
 }> => makeOption({
   kind: "foreignKey",
@@ -723,14 +1025,15 @@ export const foreignKey = <
   references: () => ({
     tableName: target()[TypeId].baseName,
     schemaName: target()[TypeId].schemaName,
+    casing: target()[TypeId].casing,
     columns: normalizeColumnList(referencedColumns) as NormalizeColumns<TargetColumns>,
-    knownColumns: Object.keys(target()[TypeId].fields)
+    knownColumns: Object.keys(target()[TypeId].fields).map((key) => key as ColumnNamesOfAnyTable<TargetTable>)
   })
 })
 
 /** Declares a check constraint expression. */
-export const check = <Name extends string>(
-  name: Name,
+export const check = <const Name extends string>(
+  name: NonEmptyStringInput<Name>,
   predicate: DdlExpressionLike
 ): TableOption<{
   readonly kind: "check"
@@ -742,15 +1045,21 @@ export const check = <Name extends string>(
   predicate
 })
 
-/** 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