effect-qb 0.13.0 → 0.14.0

package/src/internal/postgres-renderer.ts

@@ -19,7 +19,7 @@ export interface PostgresRenderResult {
 /**
  * Renders the current query AST into Postgres SQL plus bind parameters.
  */
-export const renderPostgresPlan = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any>>(
+export const renderPostgresPlan = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
   plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
 ): PostgresRenderResult => {
   const state: RenderState = {
@@ -28,7 +28,7 @@ export const renderPostgresPlan = <PlanValue extends Query.QueryPlan<any, any, a
     cteNames: new Set<string>()
   }
   const rendered = renderQueryAst(
-    Query.getAst(plan as Query.QueryPlan<any, any, any, any, any, any, any, any, any>) as any,
+    Query.getAst(plan as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as any,
     state,
     postgresDialect
   )

package/src/internal/postgres-schema-model.ts

@@ -0,0 +1,144 @@
+import * as Table from "./table.js"
+import type { AnyColumnDefinition } from "./column-state.js"
+import { normalizeDdlExpressionSql } from "./schema-ddl.js"
+import type { TableOptionSpec } from "./table-options.js"
+import type { EnumDefinition } from "../postgres/schema-management.js"
+import { EnumTypeId } from "../postgres/schema-management.js"
+
+export interface EnumModel {
+  readonly kind: "enum"
+  readonly schemaName?: string
+  readonly name: string
+  readonly values: readonly string[]
+}
+
+export interface ColumnModel {
+  readonly name: string
+  readonly ddlType: string
+  readonly dbTypeKind: string
+  readonly typeKind?: string
+  readonly typeSchema?: string
+  readonly nullable: boolean
+  readonly hasDefault: boolean
+  readonly generated: boolean
+  readonly defaultSql?: string
+  readonly generatedSql?: string
+  readonly identity?: {
+    readonly generation: "always" | "byDefault"
+  }
+  readonly column?: AnyColumnDefinition
+}
+
+export interface TableModel {
+  readonly kind: "table"
+  readonly schemaName?: string
+  readonly name: string
+  readonly columns: readonly ColumnModel[]
+  readonly options: readonly TableOptionSpec[]
+  readonly table?: Table.AnyTable
+}
+
+export interface SchemaModel {
+  readonly dialect: "postgres"
+  readonly enums: readonly EnumModel[]
+  readonly tables: readonly TableModel[]
+}
+
+export const isTableDefinition = (value: unknown): value is Table.AnyTable =>
+  value !== null &&
+  (typeof value === "object" || typeof value === "function") &&
+  Table.TypeId in value
+
+export const isEnumDefinition = (value: unknown): value is EnumDefinition =>
+  typeof value === "object" && value !== null && EnumTypeId in value
+
+export const toTableModel = (table: Table.AnyTable): TableModel => {
+  const state = table[Table.TypeId]
+  const fields = state.fields as Record<string, AnyColumnDefinition>
+  const columns = Object.entries(fields).map(([name, column]) => {
+    const metadata = column.metadata
+    const enumDefinition = metadata.enum
+    const ddlType = metadata.ddlType ?? metadata.dbType.kind
+    return {
+      name,
+      ddlType,
+      dbTypeKind: enumDefinition?.name ?? column.metadata.dbType.kind,
+      typeKind: enumDefinition === undefined ? undefined : "e",
+      typeSchema: enumDefinition?.schemaName,
+      nullable: column.metadata.nullable,
+      hasDefault: column.metadata.hasDefault,
+      generated: column.metadata.generated,
+      defaultSql: column.metadata.defaultValue === undefined
+        ? undefined
+        : normalizeDdlExpressionSql(column.metadata.defaultValue),
+      generatedSql: column.metadata.generatedValue === undefined
+        ? undefined
+        : normalizeDdlExpressionSql(column.metadata.generatedValue),
+      identity: column.metadata.identity,
+      column
+    }
+  }) satisfies ReadonlyArray<ColumnModel>
+  return {
+    kind: "table",
+    schemaName: state.schemaName,
+    name: state.baseName,
+    columns,
+    options: table[Table.OptionsSymbol],
+    table
+  }
+}
+
+export const toEnumModel = (definition: EnumDefinition): EnumModel => ({
+  kind: "enum",
+  schemaName: definition.schemaName,
+  name: definition.name,
+  values: [...definition.values]
+})
+
+const enumModelsOfTable = (table: Table.AnyTable): readonly EnumModel[] => {
+  const state = table[Table.TypeId]
+  const fields = state.fields as Record<string, AnyColumnDefinition>
+  return Object.values(fields)
+    .flatMap((column) => column.metadata.enum === undefined
+      ? []
+      : [{
+          kind: "enum" as const,
+          schemaName: column.metadata.enum.schemaName,
+          name: column.metadata.enum.name,
+          values: [...column.metadata.enum.values]
+        } satisfies EnumModel
+      ])
+}
+
+export const fromDiscoveredValues = (values: ReadonlyArray<unknown>): SchemaModel => {
+  const tables = values.filter(isTableDefinition).map(toTableModel)
+  const enums = new Map<string, EnumModel>()
+  for (const value of values) {
+    if (isEnumDefinition(value)) {
+      enums.set(enumKey(value.schemaName, value.name), toEnumModel(value))
+    } else if (isTableDefinition(value)) {
+      for (const enumModel of enumModelsOfTable(value)) {
+        const key = enumKey(enumModel.schemaName, enumModel.name)
+        const existing = enums.get(key)
+        if (existing === undefined) {
+          enums.set(key, enumModel)
+          continue
+        }
+        if (JSON.stringify(existing.values) !== JSON.stringify(enumModel.values)) {
+          throw new Error(`Conflicting enum definitions discovered for '${key}'`)
+        }
+      }
+    }
+  }
+  return {
+    dialect: "postgres",
+    enums: [...enums.values()],
+    tables
+  }
+}
+
+export const tableKey = (schemaName: string | undefined, name: string): string =>
+  `${schemaName ?? "public"}.${name}`
+
+export const enumKey = (schemaName: string | undefined, name: string): string =>
+  `${schemaName ?? "public"}.${name}`

package/src/internal/predicate-analysis.ts

@@ -36,6 +36,16 @@ type ContradictionFromNegation<
   Formula extends PredicateFormula
 > = IsContradiction<And<Assumptions, Not<Formula>>>
 
+export type ContradictsFormula<
+  Assumptions extends PredicateFormula,
+  Formula extends PredicateFormula
+> = ContradictoryAssumption<Assumptions, Formula>
+
+export type ImpliesFormula<
+  Assumptions extends PredicateFormula,
+  Formula extends PredicateFormula
+> = ContradictionFromNegation<Assumptions, Formula>
+
 export type AssumeFormulaTrue<
   Assumptions extends PredicateFormula,
   Formula extends PredicateFormula

package/src/internal/predicate-context.ts

@@ -7,6 +7,7 @@ export interface Context<
   NonNullKeys extends string = never,
   NullKeys extends string = never,
   EqLiterals = {},
+  NeqLiterals = {},
   SourceNames extends string = never,
   Contradiction extends boolean = false,
   Unknown extends boolean = false
@@ -14,13 +15,22 @@ export interface Context<
   readonly nonNullKeys: NonNullKeys
   readonly nullKeys: NullKeys
   readonly eqLiterals: EqLiterals
+  readonly neqLiterals: NeqLiterals
   readonly sourceNames: SourceNames
   readonly contradiction: Contradiction
   readonly unknown: Unknown
 }
 
 export type EmptyContext = Context
-type AnyContext = Context<string, string, Record<string, string>, string, boolean, boolean>
+type AnyContext = Context<
+  string,
+  string,
+  Record<string, string>,
+  Record<string, string>,
+  string,
+  boolean,
+  boolean
+>
 
 type Frame<
   Formula extends PredicateFormula = PredicateFormula,
@@ -41,6 +51,15 @@ type EqLiteralValueOf<
     : never
   : never
 
+type NeqLiteralValuesOf<
+  NeqLiterals,
+  Key extends string
+> = NeqLiterals extends Record<string, string>
+  ? Key extends keyof NeqLiterals
+    ? NeqLiterals[Key]
+    : never
+  : never
+
 type MergeEqLiteralMaps<Left, Right> = {
   readonly [K in Extract<keyof Left | keyof Right, string>]:
     K extends keyof Left
@@ -54,6 +73,17 @@ type MergeEqLiteralMaps<Left, Right> = {
         : never
 }
 
+type MergeNeqLiteralMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Left[K] | Right[K]
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
 type FilterNeverValues<Map> = {
   readonly [K in keyof Map as Map[K] extends never ? never : K]: Map[K]
 }
@@ -62,6 +92,7 @@ type MarkContradiction<Ctx extends AnyContext> = Context<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"],
   true,
   Ctx["unknown"]
@@ -71,6 +102,7 @@ type MarkUnknown<Ctx extends AnyContext> = Context<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"],
   Ctx["contradiction"],
   true
@@ -83,6 +115,7 @@ type AddNonNull<
   Ctx["nonNullKeys"] | Key,
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
@@ -95,6 +128,7 @@ type AddNull<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"] | Key,
   Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nonNullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
@@ -108,11 +142,20 @@ type AddEqLiteral<
   Ctx["nonNullKeys"] | Key,
   Ctx["nullKeys"],
   FilterNeverValues<MergeEqLiteralMaps<Ctx["eqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["neqLiterals"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends never
-    ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+    ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues
+      ? Value extends NeqValues
+        ? true
+        : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : true
     : EqLiteralValueOf<Ctx["eqLiterals"], Key> extends Value
-      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues
+        ? Value extends NeqValues
+          ? true
+          : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+        : true
       : true,
   Ctx["unknown"]
 >
@@ -120,8 +163,22 @@ type AddEqLiteral<
 type AddNeqLiteral<
   Ctx extends AnyContext,
   Key extends string,
-  _Value extends string
-> = AddNonNull<Ctx, Key>
+  Value extends string
+> = Context<
+  Ctx["nonNullKeys"] | Key,
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  FilterNeverValues<MergeNeqLiteralMaps<Ctx["neqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
+    ? [EqValue] extends [never]
+      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : EqValue extends Value
+        ? true
+        : Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+    : true,
+  Ctx["unknown"]
+>
 
 type ApplyEqColumn<
   Ctx extends AnyContext,
@@ -177,7 +234,7 @@ type ApplyNegativeAtom<
     : Atom extends NonNullAtom<infer Key extends string>
       ? AddNull<Ctx, Key>
       : Atom extends EqLiteralAtom<infer Key extends string, infer Value extends string>
-        ? AddNonNull<Ctx, Key>
+        ? AddNeqLiteral<Ctx, Key, Value>
         : Atom extends NeqLiteralAtom<infer Key extends string, infer Value extends string>
           ? AddEqLiteral<Ctx, Key, Value>
           : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
@@ -189,12 +246,9 @@ type ApplyNegativeAtom<
 type FramesFromItems<
   Items extends readonly PredicateFormula[],
   Direction extends Polarity
-> = Items extends readonly [
-  infer Head extends PredicateFormula,
-  ...infer Tail extends readonly PredicateFormula[]
-]
-  ? readonly [Frame<Head, Direction>, ...FramesFromItems<Tail, Direction>]
-  : readonly []
+> = {
+  readonly [K in keyof Items]: Items[K] extends PredicateFormula ? Frame<Items[K], Direction> : never
+} & readonly Frame[]
 
 type IntersectEqLiteralMaps<
   Left,
@@ -203,6 +257,14 @@ type IntersectEqLiteralMaps<
   readonly [K in Extract<keyof Left, keyof Right>]: Left[K] extends Right[K] ? Left[K] : never
 }>
 
+type IntersectNeqLiteralMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]:
+    Extract<Left[K], Right[K]> extends never ? never : Extract<Left[K], Right[K]>
+}>
+
 type IntersectContexts<
   Left extends AnyContext,
   Right extends AnyContext
@@ -210,6 +272,7 @@ type IntersectContexts<
   Extract<Left["nonNullKeys"], Right["nonNullKeys"]>,
   Extract<Left["nullKeys"], Right["nullKeys"]>,
   IntersectEqLiteralMaps<Left["eqLiterals"], Right["eqLiterals"]>,
+  IntersectNeqLiteralMaps<Left["neqLiterals"], Right["neqLiterals"]>,
   Extract<Left["sourceNames"], Right["sourceNames"]>,
   Left["contradiction"] extends true
     ? Right["contradiction"]
@@ -228,7 +291,7 @@ type AnalyzeAnyBranches<
   infer Head extends PredicateFormula,
   ...infer Tail extends readonly PredicateFormula[]
 ]
-  ? AnalyzeStack<Ctx, readonly [Frame<Head, Direction>]> extends infer Branch extends AnyContext
+  ? AnalyzeBranch<Ctx, Head, Direction> extends infer Branch extends AnyContext
     ? Branch["contradiction"] extends true
       ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current>
       : [Current] extends [never]
@@ -241,6 +304,41 @@ type AnalyzeAnyBranches<
 
 type Flip<Direction extends Polarity> = Direction extends "positive" ? "negative" : "positive"
 
+type AnalyzeBranch<
+  Ctx extends AnyContext,
+  Formula extends PredicateFormula,
+  Direction extends Polarity
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, Direction>]>
+
+type AnalyzeFrame<
+  Ctx extends AnyContext,
+  Formula extends PredicateFormula,
+  Direction extends Polarity,
+  Tail extends readonly Frame[]
+> = [Formula] extends [TrueFormula]
+  ? Direction extends "positive"
+    ? AnalyzeStack<Ctx, Tail>
+    : MarkContradiction<Ctx>
+  : [Formula] extends [FalseFormula]
+    ? Direction extends "positive"
+      ? MarkContradiction<Ctx>
+      : AnalyzeStack<Ctx, Tail>
+    : [Formula] extends [AtomFormula<infer Atom extends PredicateAtom>]
+      ? Direction extends "positive"
+        ? AnalyzeStack<ApplyAtom<Ctx, Atom>, Tail>
+        : AnalyzeStack<ApplyNegativeAtom<Ctx, Atom>, Tail>
+      : [Formula] extends [NotFormula<infer Item extends PredicateFormula>]
+        ? AnalyzeStack<Ctx, readonly [Frame<Item, Flip<Direction>>, ...Tail]>
+        : [Formula] extends [AllFormula<infer Items extends readonly PredicateFormula[]>]
+          ? Direction extends "positive"
+            ? AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "positive">, ...Tail]>
+            : AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "negative">, Tail>
+          : [Formula] extends [AnyFormula<infer Items extends readonly PredicateFormula[]>]
+            ? Direction extends "positive"
+              ? AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "positive">, Tail>
+              : AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "negative">, ...Tail]>
+            : AnalyzeStack<MarkUnknown<Ctx>, Tail>
+
 export type AnalyzeStack<
   Ctx extends AnyContext,
   Stack extends readonly Frame[]
@@ -250,29 +348,7 @@ export type AnalyzeStack<
       infer Head extends Frame,
       ...infer Tail extends readonly Frame[]
     ]
-    ? Head["formula"] extends TrueFormula
-      ? Head["polarity"] extends "positive"
-        ? AnalyzeStack<Ctx, Tail>
-        : MarkContradiction<Ctx>
-      : Head["formula"] extends FalseFormula
-        ? Head["polarity"] extends "positive"
-          ? MarkContradiction<Ctx>
-          : AnalyzeStack<Ctx, Tail>
-        : Head["formula"] extends AtomFormula<infer Atom extends PredicateAtom>
-          ? Head["polarity"] extends "positive"
-            ? AnalyzeStack<ApplyAtom<Ctx, Atom>, Tail>
-            : AnalyzeStack<ApplyNegativeAtom<Ctx, Atom>, Tail>
-          : Head["formula"] extends NotFormula<infer Item extends PredicateFormula>
-            ? AnalyzeStack<Ctx, readonly [Frame<Item, Flip<Head["polarity"]>>, ...Tail]>
-            : Head["formula"] extends AllFormula<infer Items extends readonly PredicateFormula[]>
-              ? Head["polarity"] extends "positive"
-                ? AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "positive">, ...Tail]>
-                : AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "negative">, Tail>
-              : Head["formula"] extends AnyFormula<infer Items extends readonly PredicateFormula[]>
-                ? Head["polarity"] extends "positive"
-                  ? AnalyzeStack<AnalyzeAnyBranches<Ctx, Items, "positive">, Tail>
-                  : AnalyzeStack<Ctx, readonly [...FramesFromItems<Items, "negative">, ...Tail]>
-                : AnalyzeStack<MarkUnknown<Ctx>, Tail>
+    ? AnalyzeFrame<Ctx, Head["formula"], Head["polarity"], Tail>
     : Ctx
 
 export type AnalyzeFormula<Formula extends PredicateFormula> =

package/src/internal/predicate-formula.ts

@@ -62,27 +62,39 @@ type NormalizeAnyItems<
         : NormalizeAnyItems<Tail, [...Current, Head]>
   : Current
 
-export type NormalizeBooleanConstants<Formula extends PredicateFormula> =
-  Formula extends AllFormula<infer Items extends readonly PredicateFormula[]>
-    ? NormalizeAllItems<Items> extends [FalseFormula]
+type CollapseNormalizedAll<
+  Items extends readonly PredicateFormula[]
+> = NormalizeAllItems<Items> extends infer Normalized extends readonly PredicateFormula[]
+  ? [Normalized] extends [readonly [FalseFormula]]
+    ? FalseFormula
+    : [Normalized] extends [readonly []]
+      ? TrueFormula
+      : [Normalized] extends [readonly [infer Only extends PredicateFormula]]
+        ? Only
+        : AllFormula<Normalized>
+  : never
+
+type CollapseNormalizedAny<
+  Items extends readonly PredicateFormula[]
+> = NormalizeAnyItems<Items> extends infer Normalized extends readonly PredicateFormula[]
+  ? [Normalized] extends [readonly [TrueFormula]]
+    ? TrueFormula
+    : [Normalized] extends [readonly []]
       ? FalseFormula
-      : NormalizeAllItems<Items> extends readonly []
-        ? TrueFormula
-        : NormalizeAllItems<Items> extends readonly [infer Only extends PredicateFormula]
-          ? Only
-          : AllFormula<NormalizeAllItems<Items>>
-    : Formula extends AnyFormula<infer Items extends readonly PredicateFormula[]>
-      ? NormalizeAnyItems<Items> extends [TrueFormula]
-        ? TrueFormula
-        : NormalizeAnyItems<Items> extends readonly []
-          ? FalseFormula
-          : NormalizeAnyItems<Items> extends readonly [infer Only extends PredicateFormula]
-            ? Only
-            : AnyFormula<NormalizeAnyItems<Items>>
-      : Formula extends NotFormula<infer Item extends PredicateFormula>
-        ? Item extends TrueFormula
+      : [Normalized] extends [readonly [infer Only extends PredicateFormula]]
+        ? Only
+        : AnyFormula<Normalized>
+  : never
+
+export type NormalizeBooleanConstants<Formula extends PredicateFormula> =
+  [Formula] extends [AllFormula<infer Items extends readonly PredicateFormula[]>]
+    ? CollapseNormalizedAll<Items>
+    : [Formula] extends [AnyFormula<infer Items extends readonly PredicateFormula[]>]
+      ? CollapseNormalizedAny<Items>
+      : [Formula] extends [NotFormula<infer Item extends PredicateFormula>]
+        ? [Item] extends [TrueFormula]
           ? FalseFormula
-          : Item extends FalseFormula
+          : [Item] extends [FalseFormula]
             ? TrueFormula
             : Formula
         : Formula