effect-qb 0.14.0 → 0.16.0

package/src/internal/{predicate-context.ts → predicate/context.ts}

@@ -1,5 +1,5 @@
-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"
+import type { EqColumnAtom, EqLiteralAtom, LiteralSetAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
+import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, NotFormula, PredicateFormula, TrueFormula } from "./formula.js"
 
 type Polarity = "positive" | "negative"
 
@@ -8,6 +8,8 @@ export interface Context<
   NullKeys extends string = never,
   EqLiterals = {},
   NeqLiterals = {},
+  LiteralSets = {},
+  JsonLiteralSets = {},
   SourceNames extends string = never,
   Contradiction extends boolean = false,
   Unknown extends boolean = false
@@ -16,6 +18,8 @@ export interface Context<
   readonly nullKeys: NullKeys
   readonly eqLiterals: EqLiterals
   readonly neqLiterals: NeqLiterals
+  readonly literalSets: LiteralSets
+  readonly jsonLiteralSets: JsonLiteralSets
   readonly sourceNames: SourceNames
   readonly contradiction: Contradiction
   readonly unknown: Unknown
@@ -27,6 +31,8 @@ type AnyContext = Context<
   string,
   Record<string, string>,
   Record<string, string>,
+  Record<string, string>,
+  Record<string, Record<string, string>>,
   string,
   boolean,
   boolean
@@ -84,15 +90,75 @@ type MergeNeqLiteralMaps<Left, Right> = {
         : never
 }
 
+type MergeLiteralSetMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Extract<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
+type MergeJsonLiteralSetPathMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? Extract<Left[K], Right[K]>
+        : Left[K]
+      : K extends keyof Right
+        ? Right[K]
+        : never
+}
+
+type MergeJsonLiteralSetMaps<Left, Right> = {
+  readonly [K in Extract<keyof Left | keyof Right, string>]:
+    K extends keyof Left
+      ? K extends keyof Right
+        ? MergeJsonLiteralSetPathMaps<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]
 }
 
+type JsonKeyParts<Key extends string> = string extends Key
+  ? never
+  : Key extends `${infer ColumnKey}#json:${infer Path}`
+    ? readonly [ColumnKey, Path]
+    : never
+
+type LiteralSetMapAfterAdd<
+  LiteralSets,
+  Key extends string,
+  Values extends string
+> = [JsonKeyParts<Key>] extends [never]
+  ? FilterNeverValues<MergeLiteralSetMaps<LiteralSets, { readonly [K in Key]: Values }>>
+  : LiteralSets
+
+type JsonLiteralSetMapAfterAdd<
+  JsonLiteralSets,
+  Key extends string,
+  Values extends string
+> = JsonKeyParts<Key> extends readonly [infer ColumnKey extends string, infer Path extends string]
+  ? MergeJsonLiteralSetMaps<
+      JsonLiteralSets,
+      { readonly [C in ColumnKey]: { readonly [P in Path]: Values } }
+    >
+  : JsonLiteralSets
+
 type MarkContradiction<Ctx extends AnyContext> = Context<
   Ctx["nonNullKeys"],
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"],
   true,
   Ctx["unknown"]
@@ -103,6 +169,8 @@ type MarkUnknown<Ctx extends AnyContext> = Context<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"],
   Ctx["contradiction"],
   true
@@ -116,6 +184,8 @@ type AddNonNull<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
@@ -129,11 +199,35 @@ type AddNull<
   Ctx["nullKeys"] | Key,
   Ctx["eqLiterals"],
   Ctx["neqLiterals"],
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   Key extends Ctx["nonNullKeys"] ? true : Ctx["contradiction"],
   Ctx["unknown"]
 >
 
+type AddLiteralSet<
+  Ctx extends AnyContext,
+  Key extends string,
+  Values extends string
+> = Context<
+  Ctx["nonNullKeys"] | Key,
+  Ctx["nullKeys"],
+  Ctx["eqLiterals"],
+  Ctx["neqLiterals"],
+  LiteralSetMapAfterAdd<Ctx["literalSets"], Key, Values>,
+  JsonLiteralSetMapAfterAdd<Ctx["jsonLiteralSets"], Key, Values>,
+  Ctx["sourceNames"] | SourceNameOfKey<Key>,
+  EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
+    ? [EqValue] extends [never]
+      ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+      : EqValue extends Values
+        ? Key extends Ctx["nullKeys"] ? true : Ctx["contradiction"]
+        : true
+    : true,
+  Ctx["unknown"]
+>
+
 type AddEqLiteral<
   Ctx extends AnyContext,
   Key extends string,
@@ -143,6 +237,8 @@ type AddEqLiteral<
   Ctx["nullKeys"],
   FilterNeverValues<MergeEqLiteralMaps<Ctx["eqLiterals"], { readonly [K in Key]: Value }>>,
   Ctx["neqLiterals"],
+  LiteralSetMapAfterAdd<Ctx["literalSets"], Key, Value>,
+  JsonLiteralSetMapAfterAdd<Ctx["jsonLiteralSets"], Key, Value>,
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends never
     ? NeqLiteralValuesOf<Ctx["neqLiterals"], Key> extends infer NeqValues
@@ -169,6 +265,8 @@ type AddNeqLiteral<
   Ctx["nullKeys"],
   Ctx["eqLiterals"],
   FilterNeverValues<MergeNeqLiteralMaps<Ctx["neqLiterals"], { readonly [K in Key]: Value }>>,
+  Ctx["literalSets"],
+  Ctx["jsonLiteralSets"],
   Ctx["sourceNames"] | SourceNameOfKey<Key>,
   EqLiteralValueOf<Ctx["eqLiterals"], Key> extends infer EqValue
     ? [EqValue] extends [never]
@@ -219,11 +317,13 @@ type ApplyAtom<
         ? 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
+          : Atom extends LiteralSetAtom<infer Key extends string, infer Values extends string>
+            ? AddLiteralSet<Ctx, Key, Values>
+            : 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,
@@ -237,18 +337,23 @@ type ApplyNegativeAtom<
         ? 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>
-            ? AddNonNull<AddNonNull<Ctx, Left>, Right>
-            : Atom extends UnknownAtom<any>
-              ? MarkUnknown<Ctx>
-              : Ctx
+          : Atom extends LiteralSetAtom<infer Key extends string, any>
+            ? AddNonNull<Ctx, Key>
+            : 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
-> = {
-  readonly [K in keyof Items]: Items[K] extends PredicateFormula ? Frame<Items[K], Direction> : never
-} & readonly Frame[]
+> = Items extends readonly [
+  infer Head extends PredicateFormula,
+  ...infer Tail extends readonly PredicateFormula[]
+]
+  ? readonly [Frame<Head, Direction>, ...FramesFromItems<Tail, Direction>]
+  : readonly []
 
 type IntersectEqLiteralMaps<
   Left,
@@ -265,6 +370,27 @@ type IntersectNeqLiteralMaps<
     Extract<Left[K], Right[K]> extends never ? never : Extract<Left[K], Right[K]>
 }>
 
+type UnionLiteralSetMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]: Left[K] | Right[K]
+}>
+
+type UnionJsonLiteralSetPathMaps<
+  Left,
+  Right
+> = FilterNeverValues<{
+  readonly [K in Extract<keyof Left, keyof Right>]: Left[K] | Right[K]
+}>
+
+type UnionJsonLiteralSetMaps<
+  Left,
+  Right
+> = {
+  readonly [K in Extract<keyof Left, keyof Right>]: UnionJsonLiteralSetPathMaps<Left[K], Right[K]>
+}
+
 type IntersectContexts<
   Left extends AnyContext,
   Right extends AnyContext
@@ -273,6 +399,8 @@ type IntersectContexts<
   Extract<Left["nullKeys"], Right["nullKeys"]>,
   IntersectEqLiteralMaps<Left["eqLiterals"], Right["eqLiterals"]>,
   IntersectNeqLiteralMaps<Left["neqLiterals"], Right["neqLiterals"]>,
+  UnionLiteralSetMaps<Left["literalSets"], Right["literalSets"]>,
+  UnionJsonLiteralSetMaps<Left["jsonLiteralSets"], Right["jsonLiteralSets"]>,
   Extract<Left["sourceNames"], Right["sourceNames"]>,
   Left["contradiction"] extends true
     ? Right["contradiction"]
@@ -286,17 +414,20 @@ type AnalyzeAnyBranches<
   Ctx extends AnyContext,
   Items extends readonly PredicateFormula[],
   Direction extends Polarity,
-  Current extends AnyContext | never = never
-> = Items extends readonly [
+  Current extends AnyContext | never = never,
+  Seen extends readonly unknown[] = []
+> = Seen["length"] extends 20
+  ? MarkUnknown<Ctx>
+  : Items extends readonly [
   infer Head extends PredicateFormula,
   ...infer Tail extends readonly PredicateFormula[]
 ]
   ? AnalyzeBranch<Ctx, Head, Direction> extends infer Branch extends AnyContext
     ? Branch["contradiction"] extends true
-      ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current>
+      ? AnalyzeAnyBranches<Ctx, Tail, Direction, Current, readonly [...Seen, unknown]>
       : [Current] extends [never]
-        ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch>
-        : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>>
+        ? AnalyzeAnyBranches<Ctx, Tail, Direction, Branch, readonly [...Seen, unknown]>
+        : AnalyzeAnyBranches<Ctx, Tail, Direction, IntersectContexts<Current, Branch>, readonly [...Seen, unknown]>
     : never
   : [Current] extends [never]
     ? MarkContradiction<Ctx>
@@ -353,3 +484,15 @@ export type AnalyzeStack<
 
 export type AnalyzeFormula<Formula extends PredicateFormula> =
   AnalyzeStack<EmptyContext, readonly [Frame<Formula, "positive">]>
+
+export type PredicateContext = AnyContext
+
+export type AssumeFactsTrue<
+  Ctx extends PredicateContext,
+  Formula extends PredicateFormula
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, "positive">]>
+
+export type AssumeFactsFalse<
+  Ctx extends PredicateContext,
+  Formula extends PredicateFormula
+> = AnalyzeStack<Ctx, readonly [Frame<Formula, "negative">]>

package/src/internal/predicate/formula.d.ts

@@ -0,0 +1,35 @@
+import type { PredicateAtom } from "./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;
+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 : [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] ? 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>>;
+export {};

package/src/internal/{predicate-formula.ts → predicate/formula.ts}

@@ -1,4 +1,4 @@
-import type { PredicateAtom } from "./predicate-atom.js"
+import type { PredicateAtom } from "./atom.js"
 
 export interface TrueFormula {
   readonly kind: "true"

package/src/internal/predicate/key.d.ts

@@ -0,0 +1,11 @@
+import type * as Expression from "../scalar.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>;
+export {};

package/src/internal/predicate/key.ts

@@ -0,0 +1,73 @@
+import type * as Expression from "../scalar.js"
+import type * as ExpressionAst from "../expression-ast.js"
+import type * as JsonPath from "../json/path.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 JsonPathKey<
+  Segments extends ExpressionAst.JsonSegmentTuple,
+  Current extends string = never,
+  Seen extends readonly unknown[] = []
+> = Seen["length"] extends 8
+  ? never
+  : Segments extends readonly [
+    infer Segment,
+    ...infer Tail extends ExpressionAst.JsonSegmentTuple
+  ]
+    ? Segment extends JsonPath.KeySegment<infer Key extends string>
+      ? JsonPathKey<
+          Tail,
+          [Current] extends [never] ? Key : `${Current}.${Key}`,
+          readonly [...Seen, unknown]
+        >
+      : never
+    : Current
+
+export type JsonPathPredicateKey<
+  Base extends Expression.Any,
+  Segments extends ExpressionAst.JsonSegmentTuple
+> = [ColumnKeyOfExpression<Base>] extends [never]
+  ? never
+  : [JsonPathKey<Segments>] extends [never]
+    ? never
+    : `${ColumnKeyOfExpression<Base>}#json:${JsonPathKey<Segments>}`
+
+export type PredicateKeyOfAst<Ast extends ExpressionAst.Any> =
+  [Ast] extends [ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>]
+    ? ColumnKey<TableName, ColumnName>
+    : [Ast] extends [ExpressionAst.CastNode<infer Value extends Expression.Any, infer Target extends Expression.DbType.Any>]
+      ? [Target] extends [Expression.DbTypeOf<Value>]
+        ? [Expression.DbTypeOf<Value>] extends [Target]
+          ? PredicateKeyOfExpression<Value>
+          : never
+        : never
+    : [Ast] extends [ExpressionAst.JsonAccessNode<infer Kind, infer Base extends Expression.Any, infer Segments extends ExpressionAst.JsonSegmentTuple>]
+      ? Kind extends "jsonGetText" | "jsonPathText" | "jsonAccessText" | "jsonTraverseText"
+        ? JsonPathPredicateKey<Base, Segments>
+        : never
+      : 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 PredicateKeyOfExpression<Value extends Expression.Any> = PredicateKeyOfAst<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 → predicate/nnf.ts}

@@ -1,5 +1,5 @@
-import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./predicate-atom.js"
-import type { PredicateFormula } from "./predicate-formula.js"
+import type { EqColumnAtom, EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, PredicateAtom, UnknownAtom } from "./atom.js"
+import type { PredicateFormula } from "./formula.js"
 
 export type NegateAtom<Atom extends PredicateAtom> =
   Atom extends NullAtom<infer Key extends string> ? NonNullAtom<Key> :

package/src/internal/predicate/normalize.d.ts

@@ -0,0 +1,53 @@
+import type * as Expression from "../scalar.js";
+import type * as ExpressionAst from "../expression-ast.js";
+import type { ColumnKeyOfExpression, ValueKey } from "./key.js";
+import type { AllFormula, AnyFormula, AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./formula.js";
+import type { EqLiteralAtom, NeqLiteralAtom, NonNullAtom, NullAtom, UnknownAtom } from "./atom.js";
+type AstOf<Value extends Expression.Any> = Value extends {
+    readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any;
+} ? Ast : never;
+type LiteralValueOfExpression<Value extends Expression.Any> = AstOf<Value> extends ExpressionAst.LiteralNode<infer Literal> ? Literal : never;
+type True = TrueFormula;
+type False = FalseFormula;
+type UnknownTag<Tag extends string> = AtomFormula<UnknownAtom<Tag>>;
+type AtomOf<Atom extends import("./atom.js").PredicateAtom> = AtomFormula<Atom>;
+type FactOf<Atom extends import("./atom.js").PredicateAtom> = AtomFormula<Atom>;
+type NonNullFactsOfExpression<Value extends Expression.Any> = [
+    ColumnKeyOfExpression<Value>
+] extends [never] ? never : FactOf<NonNullAtom<ColumnKeyOfExpression<Value>>>;
+type CombineFacts<Left extends PredicateFormula, Right extends PredicateFormula> = [Left] extends [never] ? Right : [Right] extends [never] ? Left : import("./formula.js").NormalizeBooleanConstants<AllFormula<[Left, Right]>>;
+type FactsOfExpressions<Values extends readonly Expression.Any[]> = Values extends readonly [
+    infer Head extends Expression.Any,
+    ...infer Tail extends readonly Expression.Any[]
+] ? CombineFacts<FormulaOfExpression<Head>, FactsOfExpressions<Tail>> : never;
+type FormulaOfEq<Left extends Expression.Any, Right extends Expression.Any> = [
+    ColumnKeyOfExpression<Left>
+] extends [never] ? [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Left> extends infer LeftLiteral ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : [RightLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : LeftLiteral extends null ? False : RightLiteral extends null ? False : [LeftLiteral] extends [RightLiteral] ? True : False : UnknownTag<"eq:unsupported"> : UnknownTag<"eq:unsupported"> : LiteralValueOfExpression<Left> extends infer LeftLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : LeftLiteral extends null ? False : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>> : UnknownTag<"eq:unsupported"> : [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [RightLiteral] extends [never] ? UnknownTag<"eq:unsupported"> : RightLiteral extends null ? False : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>> : UnknownTag<"eq:unsupported"> : AtomOf<import("./atom.js").EqColumnAtom<ColumnKeyOfExpression<Left>, ColumnKeyOfExpression<Right>>>;
+type FormulaOfNeq<Left extends Expression.Any, Right extends Expression.Any> = [
+    ColumnKeyOfExpression<Left>
+] extends [never] ? [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Left> extends infer LeftLiteral ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : [RightLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : LeftLiteral extends null ? False : RightLiteral extends null ? False : [LeftLiteral] extends [RightLiteral] ? False : True : UnknownTag<"neq:unsupported"> : UnknownTag<"neq:unsupported"> : LiteralValueOfExpression<Left> extends infer LeftLiteral ? [LeftLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : LeftLiteral extends null ? False : AtomOf<NeqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>> : UnknownTag<"neq:unsupported"> : [ColumnKeyOfExpression<Right>] extends [never] ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [RightLiteral] extends [never] ? UnknownTag<"neq:unsupported"> : RightLiteral extends null ? False : AtomOf<NeqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>> : UnknownTag<"neq:unsupported"> : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>;
+type FormulaOfIsNotDistinctFrom<Left extends Expression.Any, Right extends Expression.Any> = LiteralValueOfExpression<Left> extends infer LeftLiteral ? LiteralValueOfExpression<Right> extends infer RightLiteral ? [LeftLiteral] extends [never] ? [RightLiteral] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : RightLiteral extends null ? [ColumnKeyOfExpression<Left>] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>> : UnknownTag<"isNotDistinctFrom:unsupported"> : LeftLiteral extends null ? [ColumnKeyOfExpression<Right>] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Right>>> : RightLiteral extends null ? [ColumnKeyOfExpression<Left>] extends [never] ? UnknownTag<"isNotDistinctFrom:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Left>>> : [ColumnKeyOfExpression<Left>] extends [never] ? [ColumnKeyOfExpression<Right>] extends [never] ? CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>> : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Right>, ValueKey<LeftLiteral>>> : AtomOf<EqLiteralAtom<ColumnKeyOfExpression<Left>, ValueKey<RightLiteral>>> : UnknownTag<"isNotDistinctFrom:unsupported"> : UnknownTag<"isNotDistinctFrom:unsupported">;
+type OrFormulas<Items extends readonly PredicateFormula[]> = import("./formula.js").NormalizeBooleanConstants<AnyFormula<Items>>;
+type AndFormulas<Items extends readonly PredicateFormula[]> = import("./formula.js").NormalizeBooleanConstants<AllFormula<Items>>;
+type FormulaTupleOf<Values extends readonly Expression.Any[]> = {
+    readonly [K in keyof Values]: Values[K] extends Expression.Any ? FormulaOfExpression<Values[K]> : never;
+} & readonly PredicateFormula[];
+type AllFormulaOfValues<Values extends readonly Expression.Any[]> = import("./formula.js").NormalizeBooleanConstants<AllFormula<FormulaTupleOf<Values>>>;
+type AnyFormulaOfValues<Values extends readonly Expression.Any[]> = import("./formula.js").NormalizeBooleanConstants<AnyFormula<FormulaTupleOf<Values>>>;
+type FormulaOfInValues<Left extends Expression.Any, Values extends readonly Expression.Any[], Current extends readonly PredicateFormula[] = []> = Values extends readonly [
+    infer Head extends Expression.Any,
+    ...infer Tail extends readonly Expression.Any[]
+] ? FormulaOfInValues<Left, Tail, [...Current, FormulaOfEq<Left, Head>]> : Current;
+type FormulaOfNotInValues<Left extends Expression.Any, Values extends readonly Expression.Any[], Current extends readonly PredicateFormula[] = []> = Values extends readonly [
+    infer Head extends Expression.Any,
+    ...infer Tail extends readonly Expression.Any[]
+] ? FormulaOfNotInValues<Left, Tail, [...Current, FormulaOfNeq<Left, Head>]> : Current;
+type FormulaOfVariadic<Kind extends ExpressionAst.VariadicKind, Values extends readonly Expression.Any[]> = Kind extends "and" ? AllFormulaOfValues<Values> : Kind extends "or" ? AnyFormulaOfValues<Values> : Kind extends "in" ? Values extends readonly [infer Left extends Expression.Any, ...infer Tail extends readonly Expression.Any[]] ? OrFormulas<FormulaOfInValues<Left, Tail>> : False : Kind extends "notIn" ? Values extends readonly [infer Left extends Expression.Any, ...infer Tail extends readonly Expression.Any[]] ? CombineFacts<NonNullFactsOfExpression<Left>, AndFormulas<FormulaOfNotInValues<Left, Tail>>> : True : Kind extends "between" ? FactsOfExpressions<Values> extends infer Facts extends PredicateFormula ? [Facts] extends [never] ? UnknownTag<"variadic:between"> : CombineFacts<Facts, UnknownTag<"variadic:between">> : UnknownTag<"variadic:between"> : UnknownTag<`variadic:${Kind}`>;
+type FormulaOfUnary<Kind extends ExpressionAst.UnaryKind, Inner extends Expression.Any> = Kind extends "isNull" ? [ColumnKeyOfExpression<Inner>] extends [never] ? UnknownTag<"isNull:unsupported"> : AtomOf<NullAtom<ColumnKeyOfExpression<Inner>>> : Kind extends "isNotNull" ? [ColumnKeyOfExpression<Inner>] extends [never] ? UnknownTag<"isNotNull:unsupported"> : AtomOf<NonNullAtom<ColumnKeyOfExpression<Inner>>> : Kind extends "not" ? import("./formula.js").Not<FormulaOfExpression<Inner>> : UnknownTag<`unary:${Kind}`>;
+type FormulaOfBinary<Kind extends ExpressionAst.BinaryKind, Left extends Expression.Any, Right extends Expression.Any> = Kind extends "eq" ? FormulaOfEq<Left, Right> : Kind extends "neq" ? FormulaOfNeq<Left, Right> : Kind extends "lt" | "lte" | "gt" | "gte" | "like" | "ilike" | "contains" | "containedBy" | "overlaps" ? CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>> : Kind extends "isNotDistinctFrom" ? FormulaOfIsNotDistinctFrom<Left, Right> : Kind extends "isDistinctFrom" ? import("./formula.js").Not<FormulaOfIsNotDistinctFrom<Left, Right>> : CombineFacts<NonNullFactsOfExpression<Left>, NonNullFactsOfExpression<Right>>;
+type FormulaOfAst<Ast extends ExpressionAst.Any> = [Ast] extends [ExpressionAst.LiteralNode<infer Literal>] ? Literal extends true ? True : Literal extends false ? False : UnknownTag<"literal:non-boolean"> : [Ast] extends [ExpressionAst.UnaryNode<infer Kind extends ExpressionAst.UnaryKind, infer Inner extends Expression.Any>] ? FormulaOfUnary<Kind, Inner> : [Ast] extends [ExpressionAst.VariadicNode<infer Kind extends ExpressionAst.VariadicKind, infer Values extends readonly Expression.Any[]>] ? FormulaOfVariadic<Kind, Values> : [Ast] extends [ExpressionAst.BinaryNode<infer Kind extends ExpressionAst.BinaryKind, infer Left extends Expression.Any, infer Right extends Expression.Any>] ? FormulaOfBinary<Kind, Left, Right> : UnknownTag<`expr:${Ast["kind"]}`>;
+export type FormulaOfExpression<Value extends Expression.Any> = [
+    AstOf<Value>
+] extends [infer Ast extends ExpressionAst.Any] ? FormulaOfAst<Ast> : UnknownTag<"missing-ast">;
+export type FormulaOfPredicate<Value> = Value extends true ? True : Value extends false ? False : Value extends Expression.Any ? FormulaOfExpression<Value> : UnknownTag<"predicate:unsupported">;
+export {};