effect-qb 0.13.0 → 0.15.0

package/src/internal/expression-ast.ts

@@ -1,4 +1,4 @@
-import type * as Expression from "./expression.js"
+import type * as Expression from "./scalar.js"
 import type * as Query from "./query.js"
 import type * as JsonPath from "./json/path.js"
 import type { JsonNode } from "./json/ast.js"
@@ -34,6 +34,15 @@ export interface CastNode<
   readonly target: Target
 }
 
+/** Explicit collation captured by the internal expression AST. */
+export interface CollateNode<
+  Value extends Expression.Any = Expression.Any
+> {
+  readonly kind: "collate"
+  readonly value: Value
+  readonly collation: readonly [string, ...string[]]
+}
+
 /** General SQL function call captured by the internal expression AST. */
 export interface FunctionCallNode<
   Name extends string = string,
@@ -82,6 +91,10 @@ export type BinaryKind =
   | "gte"
   | "like"
   | "ilike"
+  | "regexMatch"
+  | "regexIMatch"
+  | "regexNotMatch"
+  | "regexNotIMatch"
   | "isDistinctFrom"
   | "isNotDistinctFrom"
   | "contains"
@@ -132,7 +145,7 @@ export interface CaseNode<
 
 /** `exists (<subquery>)` expression node. */
 export interface ExistsNode<
-  PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any> = Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>
+  PlanValue extends Query.Plan.Any = Query.Plan.Any
 > {
   readonly kind: "exists"
   readonly plan: PlanValue
@@ -140,7 +153,7 @@ export interface ExistsNode<
 
 /** Scalar subquery expression node. */
 export interface ScalarSubqueryNode<
-  PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any> = Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>
+  PlanValue extends Query.Plan.Any = Query.Plan.Any
 > {
   readonly kind: "scalarSubquery"
   readonly plan: PlanValue
@@ -149,7 +162,7 @@ export interface ScalarSubqueryNode<
 /** `value in (<subquery>)` expression node. */
 export interface InSubqueryNode<
   Left extends Expression.Any = Expression.Any,
-  PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any> = Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>
+  PlanValue extends Query.Plan.Any = Query.Plan.Any
 > {
   readonly kind: "inSubquery"
   readonly left: Left
@@ -161,7 +174,7 @@ export interface QuantifiedComparisonNode<
   Kind extends "comparisonAny" | "comparisonAll" = "comparisonAny" | "comparisonAll",
   Operator extends "eq" | "neq" | "lt" | "lte" | "gt" | "gte" = "eq" | "neq" | "lt" | "lte" | "gt" | "gte",
   Left extends Expression.Any = Expression.Any,
-  PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any> = Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>
+  PlanValue extends Query.Plan.Any = Query.Plan.Any
 > {
   readonly kind: Kind
   readonly operator: Operator
@@ -335,6 +348,7 @@ export type Any =
   | ColumnNode
   | LiteralNode
   | CastNode
+  | CollateNode
   | FunctionCallNode
   | ExcludedNode
   | UnaryNode

package/src/internal/grouping-key.d.ts

@@ -0,0 +1,3 @@
+import * as Expression from "./scalar.js";
+export declare const groupingKeyOfExpression: (expression: Expression.Any) => string;
+export declare const dedupeGroupedExpressions: <Values extends readonly Expression.Any[]>(values: Values) => Values;

package/src/internal/grouping-key.ts

@@ -1,4 +1,4 @@
-import * as Expression from "./expression.js"
+import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
 
 const literalGroupingKey = (value: unknown): string => {

package/src/internal/implication-runtime.d.ts

@@ -0,0 +1,15 @@
+import * as Plan from "./row-set.js";
+import type { PredicateFormula } from "./predicate/formula.js";
+import type { SourceLike } from "./query.js";
+export interface ImplicationScope {
+    readonly assumptions: PredicateFormula;
+    readonly nonNullKeys: ReadonlySet<string>;
+    readonly nullKeys: ReadonlySet<string>;
+    readonly requiredSourceNames: ReadonlySet<string>;
+    readonly absentSourceNames: ReadonlySet<string>;
+    readonly sourceModes: ReadonlyMap<string, Plan.SourceMode>;
+}
+export declare const presentFormulaOfSource: (source: Plan.Source<string, Plan.SourceMode, PredicateFormula, never>) => PredicateFormula;
+export declare const presenceWitnessesOfSource: (source: Plan.Source<string, Plan.SourceMode, PredicateFormula, never>) => ReadonlySet<string>;
+export declare const presenceWitnessesOfSourceLike: (source: SourceLike) => readonly string[];
+export declare const resolveImplicationScope: (available: Readonly<Record<string, Plan.Source<string, Plan.SourceMode, PredicateFormula, never>>>, initialAssumptions: PredicateFormula) => ImplicationScope;

package/src/internal/implication-runtime.ts

@@ -0,0 +1,171 @@
+import * as Expression from "./scalar.js"
+import * as ExpressionAst from "./expression-ast.js"
+import * as Plan from "./row-set.js"
+import * as Table from "./table.js"
+import type { PredicateFormula } from "./predicate/formula.js"
+import {
+  assumeFormulaTrue,
+  contradictsFormula,
+  guaranteedNonNullKeys,
+  guaranteedNullKeys,
+  guaranteedSourceNames,
+  trueFormula
+} from "./predicate/runtime.js"
+import type { SourceLike } from "./query.js"
+
+export interface ImplicationScope {
+  readonly assumptions: PredicateFormula
+  readonly nonNullKeys: ReadonlySet<string>
+  readonly nullKeys: ReadonlySet<string>
+  readonly requiredSourceNames: ReadonlySet<string>
+  readonly absentSourceNames: ReadonlySet<string>
+  readonly sourceModes: ReadonlyMap<string, Plan.SourceMode>
+}
+
+type AstBackedExpression = Expression.Any & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+}
+
+export const presentFormulaOfSource = (source: Plan.Source): PredicateFormula =>
+  source._presentFormula ?? trueFormula()
+
+export const presenceWitnessesOfSource = (source: Plan.Source): ReadonlySet<string> =>
+  new Set(source._presenceWitnesses ?? [])
+
+const collectPresenceWitnesses = (
+  selection: unknown,
+  output: Set<string>
+): void => {
+  if (typeof selection !== "object" || selection === null) {
+    return
+  }
+  if (Expression.TypeId in selection && ExpressionAst.TypeId in selection) {
+    const expression = selection as unknown as AstBackedExpression
+    const ast = expression[ExpressionAst.TypeId]
+    if (ast.kind === "column" && expression[Expression.TypeId].nullability === "never") {
+      output.add(`${ast.tableName}.${ast.columnName}`)
+    }
+    return
+  }
+  for (const value of Object.values(selection as Record<string, unknown>)) {
+    collectPresenceWitnesses(value, output)
+  }
+}
+
+export const presenceWitnessesOfSourceLike = (source: SourceLike): readonly string[] => {
+  const output = new Set<string>()
+  if (typeof source !== "object" || source === null) {
+    return []
+  }
+  if (Table.TypeId in source) {
+    collectPresenceWitnesses((source as Plan.Any)[Plan.TypeId].selection, output)
+    return [...output]
+  }
+  if ("columns" in source) {
+    collectPresenceWitnesses((source as { readonly columns: unknown }).columns, output)
+  }
+  return [...output]
+}
+
+const directAbsentSourceNames = (
+  available: Readonly<Record<string, Plan.Source>>,
+  assumptions: PredicateFormula
+): Set<string> => {
+  const nullKeys = guaranteedNullKeys(assumptions)
+  const absent = new Set<string>()
+  for (const [name, source] of Object.entries(available)) {
+    if (source._presenceWitnesses?.some((key) => nullKeys.has(key))) {
+      absent.add(name)
+      continue
+    }
+    if (contradictsFormula(assumptions, presentFormulaOfSource(source))) {
+      absent.add(name)
+    }
+  }
+  return absent
+}
+
+const propagateAbsentSourceNames = (
+  available: Readonly<Record<string, Plan.Source>>,
+  seed: ReadonlySet<string>
+): Set<string> => {
+  const absent = new Set(seed)
+  let changed = true
+  while (changed) {
+    changed = false
+    for (const [name, source] of Object.entries(available)) {
+      if (absent.has(name)) {
+        continue
+      }
+      const required = guaranteedSourceNames(presentFormulaOfSource(source))
+      if (Array.from(required).some((dependency) => absent.has(dependency))) {
+        absent.add(name)
+        changed = true
+      }
+    }
+  }
+  return absent
+}
+
+export const resolveImplicationScope = (
+  available: Readonly<Record<string, Plan.Source>>,
+  initialAssumptions: PredicateFormula
+): ImplicationScope => {
+  let assumptions = initialAssumptions
+  const required = new Set<string>(
+    Object.entries(available)
+      .filter(([, source]) => source.mode === "required")
+      .map(([name]) => name)
+  )
+  const appliedRequired = new Set<string>()
+  let absent = new Set<string>()
+
+  let changed = true
+  while (changed) {
+    changed = false
+
+    for (const name of guaranteedSourceNames(assumptions)) {
+      if (!required.has(name)) {
+        required.add(name)
+        changed = true
+      }
+    }
+
+    for (const name of required) {
+      if (absent.has(name) || appliedRequired.has(name)) {
+        continue
+      }
+      const source = available[name]
+      if (source === undefined) {
+        continue
+      }
+      assumptions = assumeFormulaTrue(assumptions, presentFormulaOfSource(source))
+      appliedRequired.add(name)
+      changed = true
+    }
+
+    const nextAbsent = propagateAbsentSourceNames(available, directAbsentSourceNames(available, assumptions))
+    if (nextAbsent.size !== absent.size || Array.from(nextAbsent).some((name) => !absent.has(name))) {
+      absent = nextAbsent
+      changed = true
+    }
+  }
+
+  for (const name of absent) {
+    required.delete(name)
+  }
+
+  const sourceModes = new Map<string, Plan.SourceMode>()
+  for (const [name, source] of Object.entries(available)) {
+    sourceModes.set(name, required.has(name) ? "required" : source.mode)
+  }
+
+  return {
+    assumptions,
+    nonNullKeys: guaranteedNonNullKeys(assumptions),
+    nullKeys: guaranteedNullKeys(assumptions),
+    requiredSourceNames: required,
+    absentSourceNames: absent,
+    sourceModes
+  }
+}

package/src/internal/json/ast.d.ts

@@ -0,0 +1,30 @@
+import type * as Expression from "../scalar.js";
+import type * as JsonPath from "./path.js";
+export type JsonKind = "jsonGet" | "jsonPath" | "jsonAccess" | "jsonTraverse" | "jsonGetText" | "jsonPathText" | "jsonAccessText" | "jsonTraverseText" | "jsonHasKey" | "jsonKeyExists" | "jsonHasAnyKeys" | "jsonHasAllKeys" | "jsonConcat" | "jsonMerge" | "jsonDelete" | "jsonDeletePath" | "jsonRemove" | "jsonSet" | "jsonInsert" | "jsonPathExists" | "jsonPathMatch" | "jsonBuildObject" | "jsonBuildArray" | "jsonToJson" | "jsonToJsonb" | "jsonTypeOf" | "jsonLength" | "jsonKeys" | "jsonStripNulls";
+/**
+ * Broad JSON AST node accepted by the renderer.
+ *
+ * The JSON subsystem is intentionally shaped as a small grammar rather than a
+ * collection of bespoke node interfaces. The renderer uses the `kind` plus the
+ * common field names below to lower the nodes into dialect SQL.
+ */
+export interface JsonNode<Kind extends JsonKind = JsonKind> {
+    readonly kind: Kind;
+    readonly value?: Expression.Any;
+    readonly base?: Expression.Any;
+    readonly left?: Expression.Any;
+    readonly right?: Expression.Any;
+    readonly path?: JsonPath.Path<any> | readonly any[];
+    readonly segments?: readonly any[];
+    readonly keys?: readonly string[];
+    readonly query?: string | Expression.Any;
+    readonly newValue?: Expression.Any;
+    readonly insert?: Expression.Any;
+    readonly createMissing?: boolean;
+    readonly insertAfter?: boolean;
+    readonly entries?: readonly {
+        readonly key: string;
+        readonly value: Expression.Any;
+    }[];
+    readonly values?: readonly Expression.Any[];
+}

package/src/internal/json/ast.ts

@@ -1,4 +1,4 @@
-import type * as Expression from ".././expression.js"
+import type * as Expression from "../scalar.js"
 import type * as JsonPath from "./path.js"
 
 export type JsonKind =

package/src/internal/json/errors.d.ts

@@ -0,0 +1,8 @@
+export type JsonPathUsageError<Operation extends string, Root, Path, Reason extends string> = {
+    readonly __effect_qb_error__: "effect-qb: invalid json path usage";
+    readonly __effect_qb_json_operation__: Operation;
+    readonly __effect_qb_json_reason__: Reason;
+    readonly __effect_qb_json_root__: Root;
+    readonly __effect_qb_json_path__: Path;
+    readonly __effect_qb_hint__: "Use key(...) on objects, index(...) on arrays, and prefer exact key/index paths when you want precise output typing";
+};

package/src/internal/json/path.d.ts

@@ -0,0 +1,75 @@
+import type * as Expression from "../scalar.js";
+import type { JsonPathUsageError } from "./errors.js";
+import type { JsonBuildArray as JsonBuildArrayResult, JsonBuildObject as JsonBuildObjectResult, JsonConcatResult, JsonDeleteAtPath, JsonLiteralInput, JsonStripNullsResult as JsonStripNullsResultValue, JsonValueAtPath, JsonSetAtPath } from "./types.js";
+import type { JsonKeysResult as JsonKeysResultValue, JsonLengthResult as JsonLengthResultValue, JsonTextResult as JsonTextResultValue, JsonTypeName as JsonTypeNameValue } from "./types.js";
+export declare const SegmentTypeId: unique symbol;
+export type SegmentTypeId = typeof SegmentTypeId;
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
+type SegmentState<Kind extends string> = {
+    readonly kind: Kind;
+};
+export interface KeySegment<Key extends string = string> {
+    readonly [SegmentTypeId]: SegmentState<"key">;
+    readonly kind: "key";
+    readonly key: Key;
+}
+export interface IndexSegment<Index extends number = number> {
+    readonly [SegmentTypeId]: SegmentState<"index">;
+    readonly kind: "index";
+    readonly index: Index;
+}
+export interface WildcardSegment {
+    readonly [SegmentTypeId]: SegmentState<"wildcard">;
+    readonly kind: "wildcard";
+}
+export interface SliceSegment<Start extends number | undefined = number | undefined, End extends number | undefined = number | undefined> {
+    readonly [SegmentTypeId]: SegmentState<"slice">;
+    readonly kind: "slice";
+    readonly start: Start;
+    readonly end: End;
+}
+export interface DescendSegment {
+    readonly [SegmentTypeId]: SegmentState<"descend">;
+    readonly kind: "descend";
+}
+export type CanonicalSegment = KeySegment | IndexSegment | WildcardSegment | SliceSegment | DescendSegment;
+export type AnySegment = any;
+export type ExactSegment = KeySegment | IndexSegment;
+type PathState<Segments extends readonly CanonicalSegment[]> = {
+    readonly segments: Segments;
+};
+export interface Path<Segments extends readonly CanonicalSegment[] = readonly CanonicalSegment[]> {
+    readonly [TypeId]: PathState<Segments>;
+    readonly segments: Segments;
+}
+export type JsonPath<Segments extends readonly CanonicalSegment[] = readonly CanonicalSegment[]> = Path<Segments>;
+export type JsonPathSegments = readonly CanonicalSegment[];
+export type JsonPrimitive = JsonLiteralInput;
+export type JsonLiteral = JsonLiteralInput;
+export type JsonInput = Expression.Any | JsonLiteral;
+export declare const key: <Key extends string>(value: Key) => KeySegment<Key>;
+export declare const index: <Index extends number>(value: Index) => IndexSegment<Index>;
+export declare const wildcard: () => WildcardSegment;
+export declare const slice: <Start extends number | undefined = undefined, End extends number | undefined = undefined>(start?: Start | undefined, end?: End | undefined) => SliceSegment<Start, End>;
+export declare const descend: () => DescendSegment;
+export declare const path: <Segments extends readonly CanonicalSegment[]>(...segments: Segments) => Path<Segments>;
+export declare const makeJsonPath: <Segments extends readonly CanonicalSegment[]>(...segments: Segments) => Path<Segments>;
+export type SegmentsOf<Value extends Path<any>> = Value[typeof TypeId]["segments"];
+export type IsExactSegment<Segment extends CanonicalSegment> = Segment extends ExactSegment ? true : false;
+export type IsExactPath<PathValue extends Path<any>> = SegmentsOf<PathValue> extends readonly [infer Head extends CanonicalSegment, ...infer Tail extends readonly CanonicalSegment[]] ? IsExactSegment<Head> extends true ? Tail extends readonly [] ? true : IsExactPath<Path<Tail>> : false : true;
+export type JsonPathValue<Root, PathValue extends Path<any>, Operation extends string = "json.get"> = JsonValueAtPath<Root, PathValue, Operation>;
+export type JsonPathOutput<Root, PathValue extends Path<any>, Operation extends string = "json.get"> = JsonValueAtPath<Root, PathValue, Operation>;
+export type JsonPathCompatible<Root, PathValue extends Path<any>, Operation extends string = "json.get"> = JsonValueAtPath<Root, PathValue, Operation> extends JsonPathUsageError<any, any, any, any> ? JsonValueAtPath<Root, PathValue, Operation> : PathValue;
+export type JsonPathUpdate<Root, PathValue extends Path<any>, Next, Operation extends string = "json.set"> = JsonSetAtPath<Root, PathValue, Next, Operation>;
+export type JsonPathDelete<Root, PathValue extends Path<any>, Operation extends string = "json.delete"> = JsonDeleteAtPath<Root, PathValue, Operation>;
+export type JsonConcat<Left, Right> = JsonConcatResult<Left, Right>;
+export type JsonBuildObject<Shape extends Record<string, JsonInput>> = JsonBuildObjectResult<Shape>;
+export type JsonBuildArray<Values extends readonly JsonInput[]> = JsonBuildArrayResult<Values>;
+export type JsonTextResult<Value> = JsonTextResultValue<Value>;
+export type JsonTypeName<Value> = JsonTypeNameValue<Value>;
+export type JsonLengthResult<Value> = JsonLengthResultValue<Value>;
+export type JsonKeysResult<Value> = JsonKeysResultValue<Value>;
+export type JsonStripNullsResult<Value> = JsonStripNullsResultValue<Value>;
+export type JsonValueOfInput<Input> = Input extends Expression.Any ? Expression.RuntimeOf<Input> : Input extends JsonLiteral ? Input : never;
+export {};

package/src/internal/json/path.ts

@@ -1,4 +1,4 @@
-import type * as Expression from ".././expression.js"
+import type * as Expression from "../scalar.js"
 import type { JsonPathUsageError } from "./errors.js"
 import type {
   JsonBuildArray as JsonBuildArrayResult,

package/src/internal/json/types.d.ts

@@ -0,0 +1,62 @@
+import type * as JsonPath from "./path.js";
+import type { JsonPathUsageError } from "./errors.js";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+type OptionalKeyOf<ObjectType extends object, Key extends PropertyKey> = Key extends keyof ObjectType ? {} extends Pick<ObjectType, Key> ? true : false : true;
+type NormalizeJsonTuple<Values extends readonly unknown[]> = Values extends readonly [] ? readonly [] : Values extends readonly [infer Head, ...infer Tail] ? readonly [NormalizeJsonLiteral<Head>, ...NormalizeJsonTuple<Tail>] : readonly NormalizeJsonLiteral<Values[number]>[];
+type NormalizeJsonObject<ObjectType extends object> = {
+    readonly [Key in keyof ObjectType as Key extends string ? Key : never]: NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>>;
+};
+export type NormalizeJsonLiteral<Value> = [
+    Value
+] extends [never] ? never : Value extends JsonPrimitive ? Value : Value extends undefined | bigint | symbol | Date | ((...args: readonly any[]) => any) ? never : Value extends readonly unknown[] ? NormalizeJsonTuple<Value> : Value extends object ? NormalizeJsonObject<Value> : never;
+export type JsonLiteralInput = JsonPrimitive | readonly JsonLiteralInput[] | {
+    readonly [key: string]: JsonLiteralInput;
+};
+type StripNull<Value> = Exclude<Value, null>;
+type KeyStep<Root, Key extends string, Operation extends string> = Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, JsonPath.KeySegment<Key>, "key segments cannot be applied to arrays"> : Root extends object ? Key extends keyof Root ? NormalizeJsonLiteral<Exclude<Root[Key], undefined>> | (OptionalKeyOf<Root, Key> extends true ? null : never) : Root extends Record<string, infer Value> ? NormalizeJsonLiteral<Value> | null : null : JsonPathUsageError<Operation, Root, JsonPath.KeySegment<Key>, "key segments require an object-like json value">;
+type TupleIndex<Values extends readonly unknown[], Index extends number, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? Head : TupleIndex<Tail, Index, [...Count, unknown]> : never;
+type DropTupleIndex<Values extends readonly unknown[], Index extends number, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? readonly [...Tail] : readonly [Head, ...DropTupleIndex<Tail, Index, [...Count, unknown]>] : readonly [];
+type SetTupleIndex<Values extends readonly unknown[], Index extends number, Next, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? readonly [Next, ...Tail] : readonly [Head, ...SetTupleIndex<Tail, Index, Next, [...Count, unknown]>] : readonly NormalizeJsonLiteral<Next>[];
+type InsertTupleIndex<Values extends readonly unknown[], Index extends number, Next, After extends boolean, Count extends readonly unknown[] = []> = Values extends readonly [infer Head, ...infer Tail] ? Count["length"] extends Index ? After extends true ? readonly [Head, NormalizeJsonLiteral<Next>, ...Tail] : readonly [NormalizeJsonLiteral<Next>, Head, ...Tail] : readonly [Head, ...InsertTupleIndex<Tail, Index, Next, After, [...Count, unknown]>] : readonly NormalizeJsonLiteral<Next>[];
+type IndexStep<Root, Index extends number, Operation extends string> = Root extends readonly unknown[] ? number extends Root["length"] ? NormalizeJsonLiteral<Root[number]> | null : NormalizeJsonLiteral<TupleIndex<Root, Index>> | (TupleIndex<Root, Index> extends never ? null : never) : JsonPathUsageError<Operation, Root, JsonPath.IndexSegment<Index>, "index segments require an array-like json value">;
+type NonExactStep<Root, Segment extends JsonPath.CanonicalSegment> = Segment extends JsonPath.WildcardSegment ? NormalizeJsonLiteral<Root> | null : Segment extends JsonPath.SliceSegment<any, any> ? NormalizeJsonLiteral<Root> | null : Segment extends JsonPath.DescendSegment ? NormalizeJsonLiteral<Root> | null : never;
+type StepValue<Root, Segment extends JsonPath.CanonicalSegment, Operation extends string> = Segment extends JsonPath.KeySegment<infer Key extends string> ? KeyStep<Root, Key, Operation> : Segment extends JsonPath.IndexSegment<infer Index extends number> ? IndexStep<Root, Index, Operation> : NonExactStep<Root, Segment>;
+type StepSet<Root, Segment extends JsonPath.CanonicalSegment, Next, Operation extends string> = Segment extends JsonPath.KeySegment<infer Key extends string> ? Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot update arrays"> : Root extends object ? Omit<Root, Key> & {
+    readonly [K in Key]: NormalizeJsonLiteral<Next>;
+} : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value"> : Segment extends JsonPath.IndexSegment<infer Index extends number> ? Root extends readonly unknown[] ? number extends Root["length"] ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[] : SetTupleIndex<Root, Index, Next> : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value"> : NormalizeJsonLiteral<Root>;
+type StepDelete<Root, Segment extends JsonPath.CanonicalSegment, Operation extends string> = Segment extends JsonPath.KeySegment<infer Key extends string> ? Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot delete from arrays"> : Root extends object ? Omit<Root, Key> : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value"> : Segment extends JsonPath.IndexSegment<infer Index extends number> ? Root extends readonly unknown[] ? number extends Root["length"] ? Root : DropTupleIndex<Root, Index> : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value"> : NormalizeJsonLiteral<Root>;
+type StepInsert<Root, Segment extends JsonPath.CanonicalSegment, Next, After extends boolean, Operation extends string> = Segment extends JsonPath.IndexSegment<infer Index extends number> ? Root extends readonly unknown[] ? number extends Root["length"] ? readonly (NormalizeJsonLiteral<Root[number]> | NormalizeJsonLiteral<Next>)[] : InsertTupleIndex<Root, Index, Next, After> : JsonPathUsageError<Operation, Root, Segment, "index segments require an array-like json value"> : Segment extends JsonPath.KeySegment<infer Key extends string> ? Root extends readonly unknown[] ? JsonPathUsageError<Operation, Root, Segment, "key segments cannot insert into arrays"> : Root extends object ? Key extends keyof Root ? Root : Root & {
+    readonly [K in Key]: NormalizeJsonLiteral<Next>;
+} : JsonPathUsageError<Operation, Root, Segment, "key segments require an object-like json value"> : NormalizeJsonLiteral<Root>;
+type RecurseValue<Current, Segments extends readonly JsonPath.CanonicalSegment[], Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? StepValue<Current, Head, Operation> extends infer Next ? Next extends JsonPathUsageError<any, any, any, any> ? Next : Tail extends readonly [] ? Next : null extends Next ? RecurseValue<StripNull<Next>, Tail, Operation> | null : RecurseValue<Next, Tail, Operation> : never : NormalizeJsonLiteral<Current>;
+type RecurseSet<Current, Segments extends readonly JsonPath.CanonicalSegment[], Next, Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? Tail extends readonly [] ? StepSet<Current, Head, Next, Operation> : StepValue<Current, Head, Operation> extends infer Child ? Child extends JsonPathUsageError<any, any, any, any> ? Child : StepSet<Current, Head, RecurseSet<StripNull<Child>, Tail, Next, Operation>, Operation> : never : NormalizeJsonLiteral<Next>;
+type RecurseDelete<Current, Segments extends readonly JsonPath.CanonicalSegment[], Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? Tail extends readonly [] ? StepDelete<Current, Head, Operation> : StepValue<Current, Head, Operation> extends infer Child ? Child extends JsonPathUsageError<any, any, any, any> ? Child : StepSet<Current, Head, RecurseDelete<StripNull<Child>, Tail, Operation>, Operation> : never : NormalizeJsonLiteral<Current>;
+type RecurseInsert<Current, Segments extends readonly JsonPath.CanonicalSegment[], Next, After extends boolean, Operation extends string> = Segments extends readonly [infer Head extends JsonPath.CanonicalSegment, ...infer Tail extends readonly JsonPath.CanonicalSegment[]] ? Tail extends readonly [] ? StepInsert<Current, Head, Next, After, Operation> : StepValue<Current, Head, Operation> extends infer Child ? Child extends JsonPathUsageError<any, any, any, any> ? Child : StepSet<Current, Head, RecurseInsert<StripNull<Child>, Tail, Next, After, Operation>, Operation> : never : NormalizeJsonLiteral<Current>;
+export type JsonValueAtPath<Root, PathValue extends JsonPath.Path<any>, Operation extends string = "json.get"> = RecurseValue<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Operation>;
+export type JsonSetAtPath<Root, PathValue extends JsonPath.Path<any>, Next, Operation extends string = "json.set"> = RecurseSet<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Next, Operation>;
+export type JsonInsertAtPath<Root, PathValue extends JsonPath.Path<any>, Next, After extends boolean = false, Operation extends string = "json.insert"> = RecurseInsert<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Next, After, Operation>;
+export type JsonDeleteAtPath<Root, PathValue extends JsonPath.Path<any>, Operation extends string = "json.delete"> = RecurseDelete<NormalizeJsonLiteral<Root>, JsonPath.SegmentsOf<PathValue>, Operation>;
+type ArrayElement<Value> = Value extends readonly (infer Element)[] ? Element : never;
+type MergeJsonObjects<Left extends object, Right extends object> = Omit<Left, keyof Right> & Right;
+type StripNullsTuple<Values extends readonly unknown[]> = Values extends readonly [] ? readonly [] : Values extends readonly [infer Head, ...infer Tail] ? readonly [JsonStripNullsResult<Head>, ...StripNullsTuple<Tail>] : readonly JsonStripNullsResult<Values[number]>[];
+type StripNullsObject<ObjectType extends object> = ({
+    readonly [Key in keyof ObjectType as Key extends string ? null extends NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>> ? never : Key : never]-?: JsonStripNullsResult<Exclude<ObjectType[Key], null>>;
+} & {
+    readonly [Key in keyof ObjectType as Key extends string ? null extends NormalizeJsonLiteral<Exclude<ObjectType[Key], undefined>> ? Key : never : never]?: JsonStripNullsResult<Exclude<ObjectType[Key], null>>;
+});
+export type JsonStripNullsResult<Value> = Value extends null ? null : Value extends readonly unknown[] ? StripNullsTuple<Value> : Value extends object ? StripNullsObject<Value> : Value;
+export type JsonConcatResult<Left, Right> = NormalizeJsonLiteral<Left> extends infer NormalizedLeft ? NormalizeJsonLiteral<Right> extends infer NormalizedRight ? NormalizedLeft extends readonly unknown[] ? NormalizedRight extends readonly unknown[] ? number extends NormalizedLeft["length"] | NormalizedRight["length"] ? readonly (ArrayElement<NormalizedLeft> | ArrayElement<NormalizedRight>)[] : readonly [...NormalizedLeft, ...NormalizedRight] : unknown : NormalizedLeft extends object ? NormalizedRight extends object ? MergeJsonObjects<NormalizedLeft, NormalizedRight> : unknown : unknown : never : never;
+export type JsonBuildObject<Shape extends Record<string, unknown>> = {
+    readonly [K in keyof Shape]: NormalizeJsonLiteral<Shape[K]>;
+};
+export type JsonBuildArray<Values extends readonly unknown[]> = {
+    readonly [K in keyof Values]: NormalizeJsonLiteral<Values[K]>;
+} & readonly unknown[];
+export type JsonTextResult<Value> = Value extends JsonPrimitive ? `${Value}` : string;
+export type JsonTypeName<Value> = NormalizeJsonLiteral<Value> extends null ? "null" : NormalizeJsonLiteral<Value> extends string ? "string" : NormalizeJsonLiteral<Value> extends number ? "number" : NormalizeJsonLiteral<Value> extends boolean ? "boolean" : NormalizeJsonLiteral<Value> extends readonly unknown[] ? "array" : NormalizeJsonLiteral<Value> extends object ? "object" : "unknown";
+export type JsonLengthResult<Value> = NormalizeJsonLiteral<Value> extends readonly unknown[] ? number : NormalizeJsonLiteral<Value> extends object ? number : null;
+export type JsonKeysResult<Value> = NormalizeJsonLiteral<Value> extends object ? NormalizeJsonLiteral<Value> extends readonly unknown[] ? readonly [] : readonly Extract<keyof NormalizeJsonLiteral<Value>, string>[] : null;
+export {};

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

@@ -0,0 +1,20 @@
+import type { AnalyzeFormula } from "./context.js";
+import type { FormulaOfPredicate } from "./normalize.js";
+import type { And, Not, PredicateFormula, TrueFormula } from "./formula.js";
+type ContextOf<Formula extends PredicateFormula> = AnalyzeFormula<Formula>;
+export type GuaranteedNonNullKeys<Assumptions extends PredicateFormula> = ContextOf<Assumptions>["nonNullKeys"];
+export type GuaranteedNullKeys<Assumptions extends PredicateFormula> = ContextOf<Assumptions>["nullKeys"];
+export type GuaranteedSourceNames<Assumptions extends PredicateFormula> = ContextOf<Assumptions>["sourceNames"];
+export type GuaranteedEqLiteral<Assumptions extends PredicateFormula, Key extends string> = Key extends keyof ContextOf<Assumptions>["eqLiterals"] ? ContextOf<Assumptions>["eqLiterals"][Key] : never;
+type IsContradiction<Formula extends PredicateFormula> = ContextOf<Formula>["contradiction"] extends true ? true : false;
+type ContradictoryAssumption<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = IsContradiction<And<Assumptions, Formula>>;
+type ContradictionFromNegation<Assumptions extends PredicateFormula, 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> = Assumptions extends TrueFormula ? Formula : And<Assumptions, Formula>;
+export type AssumeFormulaFalse<Assumptions extends PredicateFormula, Formula extends PredicateFormula> = Assumptions extends TrueFormula ? Not<Formula> : And<Assumptions, Not<Formula>>;
+export type AssumeTrue<Assumptions extends PredicateFormula, Predicate> = AssumeFormulaTrue<Assumptions, FormulaOfPredicate<Predicate>>;
+export type AssumeFalse<Assumptions extends PredicateFormula, Predicate> = AssumeFormulaFalse<Assumptions, FormulaOfPredicate<Predicate>>;
+export type Contradicts<Assumptions extends PredicateFormula, Predicate> = ContradictoryAssumption<Assumptions, FormulaOfPredicate<Predicate>>;
+export type Implies<Assumptions extends PredicateFormula, Predicate> = ContradictionFromNegation<Assumptions, FormulaOfPredicate<Predicate>>;
+export {};

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

@@ -1,6 +1,6 @@
-import type { AnalyzeFormula } from "./predicate-context.js"
-import type { FormulaOfPredicate } from "./predicate-normalize.js"
-import type { And, Not, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+import type { AnalyzeFormula } from "./context.js"
+import type { FormulaOfPredicate } from "./normalize.js"
+import type { And, Not, PredicateFormula, TrueFormula } from "./formula.js"
 
 type ContextOf<Formula extends PredicateFormula> = AnalyzeFormula<Formula>
 
@@ -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/atom.d.ts

@@ -0,0 +1,28 @@
+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 → predicate/branches.ts}

@@ -1,5 +1,5 @@
-import type { PredicateAtom } from "./predicate-atom.js"
-import type { AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./predicate-formula.js"
+import type { PredicateAtom } from "./atom.js"
+import type { AtomFormula, FalseFormula, PredicateFormula, TrueFormula } from "./formula.js"
 
 export interface BranchLimitExceeded {
   readonly kind: "branch-limit-exceeded"