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

effect-qb 0.16.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 (128) hide show

package/README.md +4 -0
package/dist/index.js +8065 -0
package/dist/mysql.js +4036 -2418
package/dist/postgres/metadata.js +2536 -625
package/dist/postgres.js +8248 -7857
package/dist/sqlite.js +8854 -0
package/dist/standard.js +8019 -0
package/package.json +15 -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 +7 -13
package/src/internal/dialect-renderers/mysql.ts +2046 -0
package/src/{postgres/internal/sql-expression-renderer.ts → internal/dialect-renderers/postgres.ts} +867 -283
package/src/{mysql/internal/sql-expression-renderer.ts → internal/dialect-renderers/sqlite.ts} +834 -358
package/src/internal/dialect.ts +37 -0
package/src/internal/dsl-mutation-runtime.ts +29 -10
package/src/internal/dsl-plan-runtime.ts +41 -24
package/src/internal/dsl-query-runtime.ts +11 -31
package/src/internal/dsl-transaction-ddl-runtime.ts +61 -15
package/src/internal/executor.ts +57 -15
package/src/internal/expression-ast.ts +3 -2
package/src/internal/grouping-key.ts +216 -9
package/src/internal/implication-runtime.ts +3 -2
package/src/internal/json/types.ts +155 -40
package/src/internal/predicate/context.ts +14 -1
package/src/internal/predicate/key.ts +19 -2
package/src/internal/predicate/runtime.ts +30 -3
package/src/internal/query.d.ts +38 -11
package/src/internal/query.ts +315 -54
package/src/internal/renderer.ts +51 -6
package/src/internal/runtime/driver-value-mapping.ts +58 -0
package/src/internal/runtime/normalize.ts +74 -43
package/src/internal/runtime/schema.ts +5 -3
package/src/internal/runtime/value.ts +153 -30
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 +229 -62
package/src/internal/table.d.ts +33 -32
package/src/internal/table.ts +469 -160
package/src/mysql/column-extension.ts +3 -0
package/src/mysql/column.ts +27 -12
package/src/mysql/datatypes/index.ts +24 -2
package/src/mysql/errors/catalog.ts +5 -5
package/src/mysql/errors/normalize.ts +2 -2
package/src/mysql/executor.ts +7 -5
package/src/mysql/internal/dialect.ts +9 -4
package/src/mysql/internal/dsl.ts +906 -324
package/src/mysql/internal/renderer.ts +7 -2
package/src/mysql/json.ts +37 -0
package/src/mysql/query-extension.ts +16 -0
package/src/mysql/query.ts +9 -2
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 +9 -13
package/src/postgres/datatypes/index.d.ts +2 -1
package/src/postgres/datatypes/index.ts +3 -2
package/src/postgres/errors/normalize.ts +2 -2
package/src/postgres/executor.ts +55 -10
package/src/postgres/function/core.ts +20 -4
package/src/postgres/function/index.ts +1 -17
package/src/postgres/internal/dialect.ts +9 -4
package/src/postgres/internal/dsl.ts +850 -359
package/src/postgres/internal/renderer.ts +7 -2
package/src/postgres/internal/schema-ddl.ts +22 -9
package/src/postgres/internal/schema-model.ts +244 -10
package/src/postgres/json.ts +100 -24
package/src/postgres/jsonb.ts +38 -0
package/src/postgres/query-extension.ts +2 -0
package/src/postgres/query.ts +9 -2
package/src/postgres/renderer.ts +31 -4
package/src/postgres/schema-management.ts +108 -16
package/src/postgres/schema.ts +98 -15
package/src/postgres/table.ts +203 -398
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 +127 -0
package/src/sqlite/datatypes/index.ts +80 -0
package/src/sqlite/datatypes/spec.ts +98 -0
package/src/sqlite/errors/catalog.ts +103 -0
package/src/sqlite/errors/fields.ts +19 -0
package/src/sqlite/errors/index.ts +19 -0
package/src/sqlite/errors/normalize.ts +229 -0
package/src/sqlite/errors/requirements.ts +71 -0
package/src/sqlite/errors/types.ts +29 -0
package/src/sqlite/executor.ts +229 -0
package/src/sqlite/function/aggregate.ts +2 -0
package/src/sqlite/function/core.ts +2 -0
package/src/sqlite/function/index.ts +19 -0
package/src/sqlite/function/string.ts +2 -0
package/src/sqlite/function/temporal.ts +100 -0
package/src/sqlite/function/window.ts +2 -0
package/src/sqlite/internal/dialect.ts +42 -0
package/src/sqlite/internal/dsl.ts +6979 -0
package/src/sqlite/internal/renderer.ts +51 -0
package/src/sqlite/json.ts +39 -0
package/src/sqlite/query-extension.ts +2 -0
package/src/sqlite/query.ts +196 -0
package/src/sqlite/renderer.ts +51 -0
package/src/sqlite.ts +14 -0
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 -157

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"
@@ -15,6 +18,51 @@ export type DdlExpressionLike = AnyExpression | AnySchemaExpression
 export type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull" | "setDefault"
+const referentialActionError = "Foreign key action must be noAction, restrict, cascade, setNull, or setDefault"
+export const renderReferentialAction = (action: unknown): string => {
+  switch (action) {
+    case "noAction":
+      return "no action"
+    case "restrict":
+      return "restrict"
+    case "cascade":
+      return "cascade"
+    case "setNull":
+      return "set null"
+    case "setDefault":
+      return "set default"
+  }
+  throw new Error(referentialActionError)
+}
+const validateReferentialAction = (action: unknown): void => {
+  if (action !== undefined) {
+    renderReferentialAction(action)
+  }
+}
+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"
@@ -67,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[]
       }
@@ -107,6 +156,95 @@ type TupleFromColumns<Columns> = Columns extends readonly [infer Head extends st
       ? readonly [Columns]
       : never
+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[]
+> = TupleFromColumns<Left>["length"] extends TupleFromColumns<Right>["length"]
+  ? TupleFromColumns<Right>["length"] extends TupleFromColumns<Left>["length"]
+    ? unknown
+    : never
+  : never
 type AssertKnownColumns<Fields extends TableFieldMap, Columns extends readonly string[]> = Exclude<
   Columns[number],
   ColumnNameUnion<Fields>
@@ -114,6 +252,47 @@ type AssertKnownColumns<Fields extends TableFieldMap, Columns extends readonly s
   ? Columns
   : never
+type IndexKeyColumnNames<Keys> = Keys extends readonly (infer Key)[]
+  ? Key extends { readonly kind: "column"; readonly column: infer Column extends string }
+    ? Column
+    : never
+  : never
+type IndexOptionColumnNames<Spec> =
+  | (Spec extends { readonly columns: infer Columns extends readonly string[] } ? Columns[number] : never)
+  | (Spec extends { readonly include: infer Include extends readonly string[] } ? Include[number] : never)
+  | (Spec extends { readonly keys: infer Keys } ? IndexKeyColumnNames<Keys> : never)
+type ForeignKeyReferencedColumnNames<Spec> = Spec extends { readonly references: () => infer Reference }
+  ? Reference extends { readonly columns: infer Columns extends readonly string[] }
+    ? Columns[number]
+    : never
+  : never
+type ForeignKeyKnownReferencedColumnNames<Spec> = Spec extends { readonly references: () => infer Reference }
+  ? Reference extends { readonly knownColumns: infer KnownColumns extends readonly string[] }
+    ? KnownColumns[number]
+    : string
+  : string
+type AssertKnownColumnNames<Fields extends TableFieldMap, Columns extends string> = [Columns] extends [never]
+  ? true
+  : string extends Columns
+    ? true
+    : Exclude<Columns, ColumnNameUnion<Fields>> extends never
+      ? true
+      : false
+type AssertKnownReferenceColumnNames<KnownColumns extends string, Columns extends string> = [Columns] extends [never]
+  ? true
+  : string extends Columns
+    ? true
+    : string extends KnownColumns
+      ? true
+      : Exclude<Columns, KnownColumns> extends never
+        ? true
+        : false
 type AssertPrimaryKeyColumns<
   Fields extends TableFieldMap,
   Columns extends readonly string[]
@@ -129,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. */
@@ -169,6 +347,7 @@ export const collectInlineOptions = <Fields extends TableFieldMap>(
           return {
             tableName: bound.baseTableName,
             schemaName: bound.schemaName,
+            casing: bound.casing,
             columns: [bound.columnName]
           }
         },
@@ -208,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
 }
@@ -233,65 +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") {
-          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 (option.columns === undefined && (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
     }
   }
 }
@@ -308,5 +449,31 @@ export type ValidatePrimaryKeyColumns<
   Columns extends readonly string[]
 > = AssertPrimaryKeyColumns<Fields, AssertKnownColumns<Fields, Columns>>
+/** Compile-time validation that index columns, included columns, and column keys exist on the table. */
+export type ValidateIndexOptionColumns<
+  Fields extends TableFieldMap,
+  Spec
+> = AssertKnownColumnNames<Fields, IndexOptionColumnNames<Spec>> extends true ? Spec : never
+/** Compile-time validation that foreign keys reference known local and target columns. */
+export type ValidateForeignKeyOptionColumns<
+  Fields extends TableFieldMap,
+  Spec
+> = Spec extends { readonly columns: infer Columns extends readonly string[] }
+  ? AssertKnownColumns<Fields, Columns> extends never
+    ? never
+    : AssertKnownReferenceColumnNames<
+        ForeignKeyKnownReferencedColumnNames<Spec>,
+        ForeignKeyReferencedColumnNames<Spec>
+      > extends true
+      ? Spec
+      : never
+  : AssertKnownReferenceColumnNames<
+      ForeignKeyKnownReferencedColumnNames<Spec>,
+      ForeignKeyReferencedColumnNames<Spec>
+    > extends true
+    ? Spec
+    : never
 /** Normalizes a public column input into the internal tuple form. */
 export type NormalizeColumns<Columns extends string | readonly string[]> = TupleFromColumns<Columns>

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;