effect-qb 0.12.3

package/src/internal/predicate-atom.ts

@@ -0,0 +1,43 @@
+export interface NullAtom<Key extends string> {
+  readonly kind: "is-null"
+  readonly key: Key
+}
+
+export interface NonNullAtom<Key extends string> {
+  readonly kind: "is-not-null"
+  readonly key: Key
+}
+
+export interface EqLiteralAtom<Key extends string, Value extends string> {
+  readonly kind: "eq-literal"
+  readonly key: Key
+  readonly value: Value
+}
+
+export interface NeqLiteralAtom<Key extends string, Value extends string> {
+  readonly kind: "neq-literal"
+  readonly key: Key
+  readonly value: Value
+}
+
+export interface EqColumnAtom<
+  LeftKey extends string,
+  RightKey extends string
+> {
+  readonly kind: "eq-column"
+  readonly left: LeftKey
+  readonly right: RightKey
+}
+
+export interface UnknownAtom<Tag extends string> {
+  readonly kind: "unknown"
+  readonly tag: Tag
+}
+
+export type PredicateAtom =
+  | NullAtom<string>
+  | NonNullAtom<string>
+  | EqLiteralAtom<string, string>
+  | NeqLiteralAtom<string, string>
+  | EqColumnAtom<string, string>
+  | UnknownAtom<string>

package/src/internal/predicate-branches.ts

@@ -0,0 +1,40 @@
+import type { PredicateAtom } from "./predicate-atom.js"
+import type { AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+
+export interface BranchLimitExceeded {
+  readonly kind: "branch-limit-exceeded"
+}
+
+type Branch = readonly PredicateAtom[]
+type Branches = readonly Branch[]
+
+export type AppendBranch<
+  Left extends Branches | BranchLimitExceeded,
+  Right extends Branches | BranchLimitExceeded,
+  _RemainingBudget extends readonly unknown[]
+> = Left extends BranchLimitExceeded
+  ? BranchLimitExceeded
+  : Right extends BranchLimitExceeded
+    ? BranchLimitExceeded
+    : Left extends Branches
+      ? Right extends Branches
+        ? Left | Right
+        : BranchLimitExceeded
+      : BranchLimitExceeded
+
+export type CrossProductBranches<
+  Left extends Branches | BranchLimitExceeded,
+  Right extends Branches | BranchLimitExceeded,
+  _RemainingBudget extends readonly unknown[]
+> = AppendBranch<Left, Right, []>
+
+export type BranchesOf<
+  Formula extends PredicateFormula,
+  _RemainingBudget extends readonly unknown[] = readonly [1]
+> = Formula extends TrueFormula
+  ? [[]]
+  : Formula extends FalseFormula
+    ? []
+    : Formula extends AtomFormula<infer Atom extends PredicateAtom>
+      ? [[Atom]]
+      : BranchLimitExceeded

package/src/internal/predicate-context.ts

@@ -0,0 +1,279 @@
+import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./predicate-atom.js"
+import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+
+type Polarity = "positive" | "negative"
+
+export interface Context<
+  NonNullKeys extends string = never,
+  NullKeys extends string = never,
+  EqLiterals = {},
+  SourceNames extends string = never,
+  Contradiction extends boolean = false,
+  Unknown extends boolean = false
+> {
+  readonly nonNullKeys: NonNullKeys
+  readonly nullKeys: NullKeys
+  readonly eqLiterals: EqLiterals
+  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 Frame<
+  Formula extends PredicateFormula = PredicateFormula,
+  Direction extends Polarity = Polarity
+> = {
+  readonly formula: Formula
+  readonly polarity: Direction
+}
+
+type SourceNameOfKey<Key extends string> = Key extends `${infer SourceName}.${string}` ? SourceName : never
+
+type EqLiteralValueOf<
+  EqLiterals,
+  Key extends string
+> = EqLiterals extends Record<string, string>
+  ? Key extends keyof EqLiterals
+    ? EqLiterals[Key]
+    : never
+  : never
+
+type MergeEqLiteralMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Left[K] extends Right[K]
+          ? Left[K]
+          : never
+        : 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]
+}
+
+type MarkContradiction<Ctx extends AnyContext> = Context<
+  Ctx["nonNullKeys"],
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  Ctx["sourceNames"],
+  true,
+  Ctx["unknown"]
+>
+
+type MarkUnknown<Ctx extends AnyContext> = Context<
+  Ctx["nonNullKeys"],
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  Ctx["sourceNames"],
+  Ctx["contradiction"],
+  true
+>
+
+type AddNonNull<
+  Ctx extends AnyContext,
+  Key extends string
+> = Context<
+  Ctx["nonNullKeys"] | Key,
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"],
+  Ctx["unknown"]
+>
+
+type AddNull<
+  Ctx extends AnyContext,
+  Key extends string
+> = Context<
+  Ctx["nonNullKeys"],
+  Ctx["nullKeys"] | Key,
+  Ctx["eqLiterals"],
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  Key extends Ctx["nonNullKeys"] ? true : Ctx["contradiction"],
+  Ctx["unknown"]
+>
+
+type AddEqLiteral<
+  Ctx extends AnyContext,
+  Key extends string,
+  Value extends string
+> = Context<
+  Ctx["nonNullKeys"] | Key,
+  Ctx["nullKeys"],
+  FilterNeverValues<MergeEqLiteralMaps<Ctx["eqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  EqLiteralValueOf<Ctx["eqLiterals"], Key> extends never
+    ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+    : EqLiteralValueOf<Ctx["eqLiterals"], Key> extends Value
+      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : true,
+  Ctx["unknown"]
+>
+
+type AddNeqLiteral<
+  Ctx extends AnyContext,
+  Key extends string,
+  _Value extends string
+> = AddNonNull<Ctx, Key>
+
+type ApplyEqColumn<
+  Ctx extends AnyContext,
+  Left extends string,
+  Right extends string
+> =
+  EqLiteralValueOf<Ctx["eqLiterals"], Left> extends infer LeftValue
+    ? EqLiteralValueOf<Ctx["eqLiterals"], Right> extends infer RightValue
+      ? [LeftValue] extends [never]
+        ? [RightValue] extends [never]
+          ? AddNonNull<AddNonNull<Ctx, Left>, Right>
+          : RightValue extends string
+            ? AddEqLiteral<AddNonNull<AddNonNull<Ctx, Left>, Right>, Left, RightValue>
+            : MarkContradiction<Ctx>
+        : [RightValue] extends [never]
+          ? LeftValue extends string
+            ? AddEqLiteral<AddNonNull<AddNonNull<Ctx, Left>, Right>, Right, LeftValue>
+            : MarkContradiction<Ctx>
+          : LeftValue extends RightValue
+            ? LeftValue extends string
+              ? RightValue extends string
+                ? AddEqLiteral<AddEqLiteral<AddNonNull<AddNonNull<Ctx, Left>, Right>, Left, LeftValue>, Right, RightValue>
+                : MarkContradiction<Ctx>
+              : MarkContradiction<Ctx>
+            : MarkContradiction<Ctx>
+      : never
+    : never
+
+type ApplyAtom<
+  Ctx extends AnyContext,
+  Atom extends PredicateAtom
+> =
+  Atom extends NullAtom<infer Key extends string>
+    ? AddNull<Ctx, Key>
+    : Atom extends NonNullAtom<infer Key extends string>
+      ? AddNonNull<Ctx, Key>
+      : Atom extends EqLiteralAtom<infer Key extends string, infer Value extends string>
+        ? AddEqLiteral<Ctx, Key, Value>
+        : Atom extends NeqLiteralAtom<infer Key extends string, infer Value extends string>
+          ? AddNeqLiteral<Ctx, Key, Value>
+          : Atom extends EqColumnAtom<infer Left extends string, infer Right extends string>
+            ? ApplyEqColumn<Ctx, Left, Right>
+            : Atom extends UnknownAtom<any>
+              ? MarkUnknown<Ctx>
+              : Ctx
+
+type ApplyNegativeAtom<
+  Ctx extends AnyContext,
+  Atom extends PredicateAtom
+> =
+  Atom extends NullAtom<infer Key extends string>
+    ? AddNonNull<Ctx, Key>
+    : Atom extends NonNullAtom<infer Key extends string>
+      ? AddNull<Ctx, Key>
+      : Atom extends EqLiteralAtom<infer Key extends string, infer Value extends string>
+        ? AddNonNull<Ctx, Key>
+        : 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>
+            ? AddNonNull<AddNonNull<Ctx, Left>, Right>
+            : Atom extends UnknownAtom<any>
+              ? MarkUnknown<Ctx>
+              : Ctx
+
+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 []
+
+type IntersectEqLiteralMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]: Left[K] extends Right[K] ? Left[K] : never
+}>
+
+type IntersectContexts<
+  Left extends AnyContext,
+  Right extends AnyContext
+> = Context<
+  Extract<Left["nonNullKeys"], Right["nonNullKeys"]>,
+  Extract<Left["nullKeys"], Right["nullKeys"]>,
+  IntersectEqLiteralMaps<Left["eqLiterals"], Right["eqLiterals"]>,
+  Extract<Left["sourceNames"], Right["sourceNames"]>,
+  Left["contradiction"] extends true
+    ? Right["contradiction"]
+    : Right["contradiction"] extends true
+      ? Left["contradiction"]
+      : false,
+  Left["unknown"] extends true ? true : Right["unknown"] extends true ? true : false
+>
+
+type AnalyzeAnyBranches<
+  Ctx extends AnyContext,
+  Items extends readonly PredicateFormula[],
+  Direction extends Polarity,
+  Current extends AnyContext | never = never
+> = Items extends readonly [
+  infer Head extends PredicateFormula,
+  ...infer Tail extends readonly PredicateFormula[]
+]
+  ? AnalyzeStack<Ctx, readonly [Frame<Head, Direction>]> extends infer Branch extends AnyContext
+    ? Branch["contradiction"] extends true
+      ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current>
+      : [Current] extends [never]
+        ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch>
+        : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>>
+    : never
+  : [Current] extends [never]
+    ? MarkContradiction<Ctx>
+    : Current
+
+type Flip<Direction extends Polarity> = Direction extends "positive" ? "negative" : "positive"
+
+export type AnalyzeStack<
+  Ctx extends AnyContext,
+  Stack extends readonly Frame[]
+> = Ctx["contradiction"] extends true
+  ? Ctx
+  : Stack extends readonly [
+      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>
+    : Ctx
+
+export type AnalyzeFormula<Formula extends PredicateFormula> =
+  AnalyzeStack<EmptyContext, readonly [Frame<Formula, "positive">]>

package/src/internal/predicate-formula.ts

@@ -0,0 +1,100 @@
+import type { PredicateAtom } from "./predicate-atom.js"
+
+export interface TrueFormula {
+  readonly kind: "true"
+}
+
+export interface FalseFormula {
+  readonly kind: "false"
+}
+
+export interface AtomFormula<Atom extends PredicateAtom> {
+  readonly kind: "atom"
+  readonly atom: Atom
+}
+
+export interface AllFormula<Items extends readonly PredicateFormula[]> {
+  readonly kind: "all"
+  readonly items: Items
+}
+
+export interface AnyFormula<Items extends readonly PredicateFormula[]> {
+  readonly kind: "any"
+  readonly items: Items
+}
+
+export interface NotFormula<Item extends PredicateFormula> {
+  readonly kind: "not"
+  readonly item: Item
+}
+
+export type PredicateFormula =
+  | TrueFormula
+  | FalseFormula
+  | AtomFormula<PredicateAtom>
+  | AllFormula<readonly PredicateFormula[]>
+  | AnyFormula<readonly PredicateFormula[]>
+  | NotFormula<PredicateFormula>
+
+type NormalizeAllItems<
+  Items extends readonly PredicateFormula[],
+  Current extends readonly PredicateFormula[] = []
+> = Items extends readonly [infer Head extends PredicateFormula, ...infer Tail extends readonly PredicateFormula[]]
+  ? Head extends TrueFormula
+    ? NormalizeAllItems<Tail, Current>
+    : Head extends FalseFormula
+      ? [FalseFormula]
+      : Head extends AllFormula<infer Nested extends readonly PredicateFormula[]>
+        ? NormalizeAllItems<[...Nested, ...Tail], Current>
+        : NormalizeAllItems<Tail, [...Current, Head]>
+  : Current
+
+type NormalizeAnyItems<
+  Items extends readonly PredicateFormula[],
+  Current extends readonly PredicateFormula[] = []
+> = Items extends readonly [infer Head extends PredicateFormula, ...infer Tail extends readonly PredicateFormula[]]
+  ? Head extends FalseFormula
+    ? NormalizeAnyItems<Tail, Current>
+    : Head extends TrueFormula
+      ? [TrueFormula]
+      : Head extends AnyFormula<infer Nested extends readonly PredicateFormula[]>
+        ? NormalizeAnyItems<[...Nested, ...Tail], Current>
+        : NormalizeAnyItems<Tail, [...Current, Head]>
+  : Current
+
+export type NormalizeBooleanConstants<Formula extends PredicateFormula> =
+  Formula extends AllFormula<infer Items extends readonly PredicateFormula[]>
+    ? NormalizeAllItems<Items> extends [FalseFormula]
+      ? 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
+          ? FalseFormula
+          : Item extends FalseFormula
+            ? TrueFormula
+            : Formula
+        : Formula
+
+export type And<
+  Left extends PredicateFormula,
+  Right extends PredicateFormula
+> = NormalizeBooleanConstants<AllFormula<[Left, Right]>>
+
+export type Or<
+  Left extends PredicateFormula,
+  Right extends PredicateFormula
+> = NormalizeBooleanConstants<AnyFormula<[Left, Right]>>
+
+export type Not<Value extends PredicateFormula> = NormalizeBooleanConstants<NotFormula<Value>>

package/src/internal/predicate-key.ts

@@ -0,0 +1,28 @@
+import type * as Expression from "./expression.js"
+import type * as ExpressionAst from "./expression-ast.js"
+
+export type ColumnKey<
+  TableName extends string,
+  ColumnName extends string
+> = `${TableName}.${ColumnName}`
+
+export type ColumnKeyOfAst<Ast extends ExpressionAst.Any> =
+  Ast extends ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>
+    ? ColumnKey<TableName, ColumnName>
+    : never
+
+type AstOf<Value extends Expression.Any> = Value extends {
+  readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any
+} ? Ast : never
+
+export type ColumnKeyOfExpression<Value extends Expression.Any> = ColumnKeyOfAst<AstOf<Value>>
+
+export type LiteralKey<Value> =
+  Value extends string ? `string:${Value}` :
+    Value extends number ? `number:${Value}` :
+      Value extends boolean ? `boolean:${Value}` :
+        Value extends null ? "null" :
+          Value extends Date ? `date:${string}` :
+            "unknown"
+
+export type ValueKey<Value> = LiteralKey<Value>

package/src/internal/predicate-nnf.ts

@@ -0,0 +1,12 @@
+import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./predicate-atom.js"
+import type { PredicateFormula } from "./predicate-formula.js"
+
+export type NegateAtom<Atom extends PredicateAtom> =
+  Atom extends NullAtom<infer Key extends string> ? NonNullAtom<Key> :
+    Atom extends NonNullAtom<infer Key extends string> ? NullAtom<Key> :
+      Atom extends EqLiteralAtom<infer Key extends string, infer Value extends string> ? NeqLiteralAtom<Key, Value> :
+        Atom extends NeqLiteralAtom<infer Key extends string, infer Value extends string> ? EqLiteralAtom<Key, Value> :
+          Atom extends EqColumnAtom<any, any> ? UnknownAtom<"not:eq-column"> :
+            UnknownAtom<"not:unknown">
+
+export type ToNnf<Formula extends PredicateFormula> = Formula