effect-qb 0.17.0 → 0.19.0

package/src/internal/table.ts

@@ -12,8 +12,10 @@ import {
   resolvePrimaryKeyColumns,
   type DdlExpressionLike,
   type IndexKeySpec,
+  type LiteralStringInput,
   type MatchingColumnArityInput,
   type NonEmptyColumnInput,
+  type NonEmptyStringInput,
   type NormalizeColumns,
   type ReferentialAction,
   type TableOptionSpec,
@@ -24,12 +26,16 @@ import {
   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")
@@ -39,15 +45,22 @@ 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 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> =
@@ -74,43 +87,79 @@ interface TableOptionBuilderLike<
 
 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
+  ? ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : unknown
   : Spec extends { readonly kind: "index" }
-    ? ValidateIndexOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : Table
+    ? ValidateIndexOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : unknown
     : Spec extends { readonly kind: "foreignKey" }
-      ? ValidateForeignKeyOptionColumns<Table[typeof TypeId]["fields"], Spec> extends never ? never : Table
+      ? 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 : Table
-        : Table
+        ? 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>,
@@ -153,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,
@@ -166,25 +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,
-    const Options extends DeclaredTableOptions,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...options: Options & ValidateDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  ) => ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  readonly casing?: Casing.Options
 }
 
 export type DeclaredTableOptions = readonly TableOptionBuilderLike[]
-export type { DdlExpressionLike, IndexKeySpec, MatchingColumnArityInput, NonEmptyColumnInput, 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,
@@ -192,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>,
@@ -245,32 +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 extends TableDefinition<any, infer Fields extends TableFieldMap, any, any, any>
-  ? Fields
-  : Table extends TableClassStatic<any, infer Fields extends TableFieldMap, any, any>
-    ? Fields
-    : never
+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)
   }
 }
@@ -279,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)
     }
   })
@@ -292,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[]
 }
@@ -305,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,
@@ -336,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,
@@ -400,23 +593,17 @@ const applyDeclaredOptions = <
   ) 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 => {
@@ -442,7 +629,6 @@ const ensureClassArtifacts = <
   }
   const state = self[TypeId]
   const classOptions = self[options]
-  validateClassOptions(extractDeclaredOptions(classOptions))
   const table = applyDeclaredOptions(
     makeTable(
       state.name,
@@ -451,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>
@@ -476,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,
@@ -486,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> =>
@@ -517,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,
@@ -540,38 +747,56 @@ export function make<
   )
 }
 
-/**
- * Creates a namespace-scoped builder for a concrete SQL schema/database.
- */
-export const schema = <SchemaName extends string>(
-  schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => {
-  const table = <
-    Name extends string,
-    Fields extends TableFieldMap,
-    const Options extends DeclaredTableOptions,
-    PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
-  >(
-    name: Name,
-    fields: Fields,
-    ...options: Options & ValidateDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  ): ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options> =>
-    applyDeclaredOptions(
-      makeTable(
-        name,
-        fields,
-        [],
-        name,
-        "schema",
-        schemaName,
-        "explicit"
-      ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
-      options as unknown as Options
-    ) as ApplyDeclaredOptions<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
-  return {
+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,
-    table
-  } as unknown as TableSchemaNamespace<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
+  >
 }
 
 /**
@@ -589,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,
@@ -599,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
       }
@@ -642,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
 
@@ -663,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,
@@ -699,7 +943,7 @@ export function Class<
           return ensureClassArtifacts(this as any).normalizedOptions
         }
 
-        static pipe(this: unknown) {
+        static pipe(this: Pipeable) {
           return pipeArguments(this, arguments)
         }
       }
@@ -781,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) as unknown as readonly ColumnNamesOfAnyTable<TargetTable>[]
+    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"
@@ -800,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