effect-qb 0.17.0 → 4.0.0-beta.66

package/src/internal/schema-derivation.d.ts

@@ -1,64 +1,7 @@
-import * as VariantSchema from "@effect/experimental/VariantSchema";
 import type * as Brand from "effect/Brand";
 import * as Schema from "effect/Schema";
 import { type AnyColumnDefinition, type HasDefault, type InsertType, type IsGenerated, type IsNullable, type SelectType, type UpdateType } from "./column-state.js";
-/** Variant-schema helper used to derive select / insert / update schemas. */
-export declare const TableSchema: {
-    readonly Struct: <const A extends VariantSchema.Struct.Fields>(fields: A & VariantSchema.Struct.Validate<A, "insert" | "select" | "update">) => VariantSchema.Struct<A>;
-    readonly Field: <const A extends VariantSchema.Field.ConfigWithKeys<"insert" | "select" | "update">>(config: A & { readonly [K in Exclude<keyof A, "insert" | "select" | "update">]: never; }) => VariantSchema.Field<A>;
-    readonly FieldOnly: <const Keys extends readonly ("insert" | "select" | "update")[]>(...keys: Keys) => <S extends Schema.Schema.All | Schema.PropertySignature.All<PropertyKey>>(schema: S) => VariantSchema.Field<{ readonly [K in Keys[number]]: S; }>;
-    readonly FieldExcept: <const Keys extends readonly ("insert" | "select" | "update")[]>(...keys: Keys) => <S extends Schema.Schema.All | Schema.PropertySignature.All<PropertyKey>>(schema: S) => VariantSchema.Field<{ readonly [K in Exclude<"insert", Keys[number]> | Exclude<"select", Keys[number]> | Exclude<"update", Keys[number]>]: S; }>;
-    readonly fieldEvolve: {
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: ((variant: S[K]) => VariantSchema.Field.ValueAny) | undefined; } : {
-            readonly insert?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly select?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly update?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-        }>(f: Mapping): (self: Self) => VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping ? Mapping[K] extends (arg: any) => any ? ReturnType<Mapping[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping ? Mapping[T] extends (arg: any) => any ? ReturnType<Mapping[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping ? Mapping[T_1] extends (arg: any) => any ? ReturnType<Mapping[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping ? Mapping[T_2] extends (arg: any) => any ? ReturnType<Mapping[T_2]> : Self : Self : never : never;
-        }>;
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping_1 extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: ((variant: S[K]) => VariantSchema.Field.ValueAny) | undefined; } : {
-            readonly insert?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly select?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-            readonly update?: ((variant: Self) => VariantSchema.Field.ValueAny) | undefined;
-        }>(self: Self, f: Mapping_1): VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping_1 ? Mapping_1[K] extends (arg: any) => any ? ReturnType<Mapping_1[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping_1 ? Mapping_1[T] extends (arg: any) => any ? ReturnType<Mapping_1[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping_1 ? Mapping_1[T_1] extends (arg: any) => any ? ReturnType<Mapping_1[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping_1 ? Mapping_1[T_2] extends (arg: any) => any ? ReturnType<Mapping_1[T_2]> : Self : Self : never : never;
-        }>;
-    };
-    readonly fieldFromKey: {
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping_2 extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: string | undefined; } : {
-            readonly insert?: string | undefined;
-            readonly select?: string | undefined;
-            readonly update?: string | undefined;
-        }>(mapping: Mapping_2): (self: Self) => VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping_2 ? Mapping_2[K] extends string ? VariantSchema.fromKey.Rename<S_1[K], Mapping_2[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping_2 ? Mapping_2[T] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_2[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping_2 ? Mapping_2[T_1] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_2[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping_2 ? Mapping_2[T_2] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_2[T_2]> : Self : Self : never : never;
-        }>;
-        <Self extends VariantSchema.Field<any> | VariantSchema.Field.ValueAny, const Mapping_3 extends Self extends VariantSchema.Field<infer S extends VariantSchema.Field.Config> ? { readonly [K in keyof S]?: string | undefined; } : {
-            readonly insert?: string | undefined;
-            readonly select?: string | undefined;
-            readonly update?: string | undefined;
-        }>(self: Self, mapping: Mapping_3): VariantSchema.Field<Self extends VariantSchema.Field<infer S_1 extends VariantSchema.Field.Config> ? { readonly [K in keyof S_1]: K extends keyof Mapping_3 ? Mapping_3[K] extends string ? VariantSchema.fromKey.Rename<S_1[K], Mapping_3[K]> : S_1[K] : S_1[K]; } : {
-            readonly insert: "insert" extends infer T ? T extends "insert" ? T extends keyof Mapping_3 ? Mapping_3[T] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_3[T]> : Self : Self : never : never;
-            readonly select: "select" extends infer T_1 ? T_1 extends "select" ? T_1 extends keyof Mapping_3 ? Mapping_3[T_1] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_3[T_1]> : Self : Self : never : never;
-            readonly update: "update" extends infer T_2 ? T_2 extends "update" ? T_2 extends keyof Mapping_3 ? Mapping_3[T_2] extends string ? VariantSchema.fromKey.Rename<Self, Mapping_3[T_2]> : Self : Self : never : never;
-        }>;
-    };
-    readonly Class: <Self = never>(identifier: string) => <const Fields extends VariantSchema.Struct.Fields>(fields: Fields & VariantSchema.Struct.Validate<Fields, "insert" | "select" | "update">, annotations?: Schema.Annotations.Schema<Self, readonly []> | undefined) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Class<Self>()({ ... })`" : VariantSchema.Class<Self, Fields, VariantSchema.ExtractFields<"select", Fields, true>, Schema.Struct.Type<VariantSchema.ExtractFields<"select", Fields, true>>, Schema.Struct.Encoded<VariantSchema.ExtractFields<"select", Fields, true>>, Schema.Schema.Context<VariantSchema.ExtractFields<"select", Fields, true>[keyof VariantSchema.ExtractFields<"select", Fields, true>]>, Schema.Struct.Constructor<VariantSchema.ExtractFields<"select", Fields, true>>> & {
-        readonly insert: Schema.Struct<VariantSchema.ExtractFields<"insert", Fields, false> extends infer T ? { [K in keyof T]: T[K]; } : never>;
-        readonly select: Schema.Struct<VariantSchema.ExtractFields<"select", Fields, false> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never>;
-        readonly update: Schema.Struct<VariantSchema.ExtractFields<"update", Fields, false> extends infer T_2 ? { [K in keyof T_2]: T_2[K]; } : never>;
-    };
-    readonly Union: <const Members extends readonly VariantSchema.Struct<any>[]>(...members: Members) => VariantSchema.Union<Members> & VariantSchema.Union.Variants<Members, "insert" | "select" | "update">;
-    readonly extract: {
-        <V extends "insert" | "select" | "update">(variant: V): <A extends VariantSchema.Struct<any>>(self: A) => VariantSchema.Extract<V, A, V extends "select" ? true : false>;
-        <V extends "insert" | "select" | "update", A extends VariantSchema.Struct<any>>(self: A, variant: V): VariantSchema.Extract<V, A, V extends "select" ? true : false>;
-    };
-};
+export type TableSchemaVariant = "select" | "insert" | "update";
 /** Normalized field map used by table definitions. */
 export type TableFieldMap = Record<string, AnyColumnDefinition>;
 type GeneratedKeys<Fields extends TableFieldMap> = {
@@ -91,15 +34,23 @@ export type InsertRow<TableName extends string, Fields extends TableFieldMap> =
 export type UpdateRow<TableName extends string, Fields extends TableFieldMap, PrimaryKey extends keyof Fields> = Simplify<Partial<{
     [K in UpdateKeys<Fields, PrimaryKey>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>;
 }>>;
+type SchemaOfVariant<Variant extends TableSchemaVariant, TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string> = Variant extends "select" ? Schema.Decoder<SelectRow<TableName, Fields>, never> : Variant extends "insert" ? Schema.Decoder<InsertRow<TableName, Fields>, never> : Schema.Decoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>;
+export declare const deriveSchema: <Variant extends TableSchemaVariant, TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(variant: Variant, tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => SchemaOfVariant<Variant, TableName, Fields, PrimaryKeyColumns>;
+export declare const deriveSelectSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Decoder<SelectRow<TableName, Fields>, never>;
+export declare const deriveInsertSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Decoder<InsertRow<TableName, Fields>, never>;
+export declare const deriveUpdateSchema: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => Schema.Decoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>;
 /**
  * Derives the `select`, `insert`, and `update` schemas for a table.
  *
  * This is the central place where the column capability flags are turned into
  * real runtime schemas.
+ *
+ * @deprecated Prefer `deriveSelectSchema`, `deriveInsertSchema`, and
+ * `deriveUpdateSchema` so individual variants are derived lazily.
  */
 export declare const deriveSchemas: <TableName extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(tableName: TableName, fields: Fields, primaryKeyColumns: readonly PrimaryKeyColumns[]) => {
-    readonly select: Schema.Schema<{ [K in keyof { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }]: { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }[K]; }, { [K in keyof { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }]: { [K in keyof Fields]: BrandedSelectType<Fields[K], TableName, Extract<K, string>>; }[K]; }, never>;
-    readonly insert: Schema.Schema<{ [K in Exclude<keyof Fields, GeneratedKeys<Fields> | OptionalInsertKeys<Fields>>]: BrandedInsertType<Fields[K], TableName, Extract<K, string>>; } & { [K in OptionalInsertKeys<Fields>]?: BrandedInsertType<Fields[K], TableName, Extract<K, string>> | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never, { [K in Exclude<keyof Fields, GeneratedKeys<Fields> | OptionalInsertKeys<Fields>>]: BrandedInsertType<Fields[K], TableName, Extract<K, string>>; } & { [K in OptionalInsertKeys<Fields>]?: BrandedInsertType<Fields[K], TableName, Extract<K, string>> | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never, never>;
-    readonly update: Schema.Schema<Partial<{ [K in Exclude<keyof Fields, PrimaryKeyColumns | GeneratedKeys<Fields>>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>; }> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never, Partial<{ [K in Exclude<keyof Fields, PrimaryKeyColumns | GeneratedKeys<Fields>>]: BrandedUpdateType<Fields[K], TableName, Extract<K, string>>; }> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never, never>;
+    readonly select: Schema.Decoder<SelectRow<TableName, Fields>, never>;
+    readonly insert: Schema.Decoder<InsertRow<TableName, Fields>, never>;
+    readonly update: Schema.Decoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>;
 };
 export {};

package/src/internal/schema-derivation.ts

@@ -1,4 +1,3 @@
-import * as VariantSchema from "@effect/experimental/VariantSchema"
 import type * as Brand from "effect/Brand"
 import * as Schema from "effect/Schema"
 
@@ -12,13 +11,7 @@ import {
   type UpdateType
 } from "./column-state.js"
 
-/** Variant-schema helper used to derive select / insert / update schemas. */
-export const TableSchema = VariantSchema.make({
-  variants: ["select", "insert", "update"] as const,
-  defaultVariant: "select"
-})
-
-type Variants = "select" | "insert" | "update"
+export type TableSchemaVariant = "select" | "insert" | "update"
 
 /** Normalized field map used by table definitions. */
 export type TableFieldMap = Record<string, AnyColumnDefinition>
@@ -112,7 +105,7 @@ const maybeBrandSchema = (
   column: AnyColumnDefinition,
   tableName: string,
   columnName: string
-): Schema.Schema.Any =>
+): Schema.Top =>
   column.metadata.brand === true
     ? Schema.brand(`${tableName}.${columnName}`)(column.schema)
     : column.schema
@@ -121,7 +114,7 @@ const selectSchema = (
   column: AnyColumnDefinition,
   tableName: string,
   columnName: string
-): Schema.Schema.Any =>
+): Schema.Top =>
   column.metadata.nullable ? Schema.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName)
 
 const insertSchema = (
@@ -153,11 +146,95 @@ const updateSchema = (
   return Schema.optional(base)
 }
 
+type SchemaOfVariant<
+  Variant extends TableSchemaVariant,
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+> = Variant extends "select" ? Schema.Decoder<SelectRow<TableName, Fields>, never>
+  : Variant extends "insert" ? Schema.Decoder<InsertRow<TableName, Fields>, never>
+  : Schema.Decoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>
+
+const fieldSchemaForVariant = (
+  variant: TableSchemaVariant,
+  column: AnyColumnDefinition,
+  tableName: string,
+  columnName: string,
+  primaryKeySet: ReadonlySet<string>
+): any | undefined => {
+  switch (variant) {
+    case "select":
+      return selectSchema(column, tableName, columnName)
+    case "insert":
+      return insertSchema(column, tableName, columnName)
+    case "update":
+      return updateSchema(column, tableName, columnName, primaryKeySet.has(columnName))
+  }
+}
+
+export const deriveSchema = <
+  Variant extends TableSchemaVariant,
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  variant: Variant,
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): SchemaOfVariant<Variant, TableName, Fields, PrimaryKeyColumns> => {
+  const primaryKeySet = new Set<string>(primaryKeyColumns)
+  const structFields: Record<string, any> = {}
+  for (const [key, column] of Object.entries(fields)) {
+    const schema = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet)
+    if (schema !== undefined) {
+      structFields[key] = schema
+    }
+  }
+  return Schema.Struct(structFields) as unknown as SchemaOfVariant<Variant, TableName, Fields, PrimaryKeyColumns>
+}
+
+export const deriveSelectSchema = <
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): Schema.Decoder<SelectRow<TableName, Fields>, never> =>
+  deriveSchema("select", tableName, fields, primaryKeyColumns)
+
+export const deriveInsertSchema = <
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): Schema.Decoder<InsertRow<TableName, Fields>, never> =>
+  deriveSchema("insert", tableName, fields, primaryKeyColumns)
+
+export const deriveUpdateSchema = <
+  TableName extends string,
+  Fields extends TableFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string
+>(
+  tableName: TableName,
+  fields: Fields,
+  primaryKeyColumns: readonly PrimaryKeyColumns[]
+): Schema.Decoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never> =>
+  deriveSchema("update", tableName, fields, primaryKeyColumns)
+
 /**
  * Derives the `select`, `insert`, and `update` schemas for a table.
  *
  * This is the central place where the column capability flags are turned into
  * real runtime schemas.
+ *
+ * @deprecated Prefer `deriveSelectSchema`, `deriveInsertSchema`, and
+ * `deriveUpdateSchema` so individual variants are derived lazily.
  */
 export const deriveSchemas = <
   TableName extends string,
@@ -168,36 +245,11 @@ export const deriveSchemas = <
   fields: Fields,
   primaryKeyColumns: readonly PrimaryKeyColumns[]
 ): {
-  readonly select: Schema.Schema<SelectRow<TableName, Fields>>
-  readonly insert: Schema.Schema<InsertRow<TableName, Fields>>
-  readonly update: Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
-} => {
-  const primaryKeySet = new Set<string>(primaryKeyColumns)
-  const variants: Record<string, VariantSchema.Field<any>> = {}
-  for (const [key, column] of Object.entries(fields)) {
-    const config: Record<Variants, any> = {
-      select: selectSchema(column, tableName, key),
-      insert: undefined,
-      update: undefined
-    }
-    const insert = insertSchema(column, tableName, key)
-    const update = updateSchema(column, tableName, key, primaryKeySet.has(key))
-    if (insert !== undefined) {
-      config.insert = insert
-    } else {
-      delete config.insert
-    }
-    if (update !== undefined) {
-      config.update = update
-    } else {
-      delete config.update
-    }
-    variants[key] = TableSchema.Field(config)
-  }
-  const struct = TableSchema.Struct(variants as any)
-  return {
-    select: TableSchema.extract(struct, "select") as unknown as Schema.Schema<SelectRow<TableName, Fields>>,
-    insert: TableSchema.extract(struct, "insert") as unknown as Schema.Schema<InsertRow<TableName, Fields>>,
-    update: TableSchema.extract(struct, "update") as unknown as Schema.Schema<UpdateRow<TableName, Fields, PrimaryKeyColumns>>
-  }
-}
+  readonly select: Schema.Decoder<SelectRow<TableName, Fields>, never>
+  readonly insert: Schema.Decoder<InsertRow<TableName, Fields>, never>
+  readonly update: Schema.Decoder<UpdateRow<TableName, Fields, PrimaryKeyColumns>, never>
+} => ({
+  select: deriveSelectSchema(tableName, fields, primaryKeyColumns),
+  insert: deriveInsertSchema(tableName, fields, primaryKeyColumns),
+  update: deriveUpdateSchema(tableName, fields, primaryKeyColumns)
+})

package/src/internal/table.d.ts

@@ -47,9 +47,9 @@ export type BoundColumns<Name extends string, Fields extends TableFieldMap> = {
 };
 /** Derived runtime schemas exposed by a table definition. */
 export interface TableSchemas<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string> {
-    readonly select: Schema.Schema<SelectRow<Name, Fields>>;
-    readonly insert: Schema.Schema<InsertRow<Name, Fields>>;
-    readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>;
+    readonly select: Schema.Decoder<SelectRow<Name, Fields>, never>;
+    readonly insert: Schema.Decoder<InsertRow<Name, Fields>, never>;
+    readonly update: Schema.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>;
 }
 interface TableState<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> {
     readonly name: Name;
@@ -92,7 +92,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>;
@@ -114,6 +117,12 @@ 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.Decoder<SelectRow<Name, Fields>, never>;
+/** 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.Decoder<InsertRow<Name, Fields>, never>;
+/** 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.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>;
 /**
  * Class-based table constructor mirroring `Schema.Class`.
  *
@@ -153,21 +162,19 @@ export declare const check: <Name extends string>(name: Name, predicate: DdlExpr
     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;

package/src/internal/table.ts

@@ -24,10 +24,13 @@ 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"
 
@@ -39,6 +42,7 @@ 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<{
@@ -148,9 +152,17 @@ export interface TableSchemas<
   Fields extends TableFieldMap,
   PrimaryKeyColumns extends keyof Fields & string
 > {
-  readonly select: Schema.Schema<SelectRow<Name, Fields>>
-  readonly insert: Schema.Schema<InsertRow<Name, Fields>>
-  readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>
+  readonly select: Schema.Decoder<SelectRow<Name, Fields>, never>
+  readonly insert: Schema.Decoder<InsertRow<Name, Fields>, never>
+  readonly update: Schema.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>
+}
+
+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<
@@ -245,13 +257,12 @@ 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>
 
@@ -292,7 +303,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[]
 }
@@ -314,15 +324,149 @@ const buildArtifacts = <
   const columns = Object.fromEntries(
     Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)])
   ) 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 unknown 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.Decoder<SelectRow<Name, Fields>, never> {
+  return schemaFor(table, "select") as Schema.Decoder<SelectRow<Name, Fields>, never>
+}
+
+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.Decoder<InsertRow<Name, Fields>, never> {
+  return schemaFor(table, "insert") as Schema.Decoder<InsertRow<Name, Fields>, never>
+}
+
+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.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never> {
+  return schemaFor(table, "update") as Schema.Decoder<UpdateRow<Name, Fields, PrimaryKeyColumns>, never>
+}
+
+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,
@@ -346,7 +490,7 @@ const makeTable = <
   const table = attachPipe(Object.create(TableProto))
   table.name = name
   table.columns = artifacts.columns
-  table.schemas = artifacts.schemas
+  defineSchemasGetter(table)
   table[TypeId] = {
     name,
     baseName,
@@ -457,7 +601,6 @@ const ensureClassArtifacts = <
   )
   const artifacts = {
     columns: table.columns,
-    schemas: table.schemas,
     normalizedOptions: table[OptionsSymbol],
     primaryKey: table[TypeId].primaryKey as readonly PrimaryKeyColumns[]
   } satisfies BuildArtifacts<Name, Fields, PrimaryKeyColumns>
@@ -604,7 +747,7 @@ export const alias = <
   const aliased = attachPipe(Object.create(TableProto))
   aliased.name = aliasName
   aliased.columns = columns
-  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey)
+  defineSchemasGetter(aliased)
   aliased[TypeId] = {
     name: aliasName,
     baseName: state.baseName,
@@ -663,7 +806,7 @@ export function Class<
         }
 
         static get schemas() {
-          return ensureClassArtifacts(this as any).schemas
+          return schemasFor(this as any)
         }
 
         static get [TypeId]() {
@@ -800,15 +943,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