effect-qb 0.14.0 → 0.16.0

package/src/internal/dsl-transaction-ddl-runtime.ts

@@ -0,0 +1,263 @@
+import * as Plan from "./row-set.js"
+
+type DslTransactionDdlRuntimeContext = {
+  readonly profile: {
+    readonly dialect: string
+  }
+  readonly makePlan: (...args: readonly any[]) => any
+  readonly targetSourceDetails: (target: any) => { readonly sourceName: string; readonly sourceBaseName: string }
+  readonly normalizeColumnList: (columns: string | readonly string[]) => readonly string[]
+  readonly defaultIndexName: (tableName: string, columns: readonly string[], unique: boolean) => string
+}
+
+export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContext) => {
+  const transaction = (options: { readonly isolationLevel?: any; readonly readOnly?: boolean } = {}) =>
+    ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "transaction",
+      select: {},
+      transaction: {
+        kind: "transaction",
+        isolationLevel: options.isolationLevel,
+        readOnly: options.readOnly
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "transaction")
+
+  const commit = () =>
+    ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "commit",
+      select: {},
+      transaction: {
+        kind: "commit"
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "commit")
+
+  const rollback = () =>
+    ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "rollback",
+      select: {},
+      transaction: {
+        kind: "rollback"
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "rollback")
+
+  const savepoint = (name: string) =>
+    ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "savepoint",
+      select: {},
+      transaction: {
+        kind: "savepoint",
+        name
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "savepoint")
+
+  const rollbackTo = (name: string) =>
+    ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "rollbackTo",
+      select: {},
+      transaction: {
+        kind: "rollbackTo",
+        name
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "rollbackTo")
+
+  const releaseSavepoint = (name: string) =>
+    ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "releaseSavepoint",
+      select: {},
+      transaction: {
+        kind: "releaseSavepoint",
+        name
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "releaseSavepoint")
+
+  const createTable = (target: any, options: { readonly ifNotExists?: boolean } = {}) => {
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[Plan.TypeId].dialect
+    }, {
+      kind: "createTable",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "createTable",
+        ifNotExists: options.ifNotExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "createTable")
+  }
+
+  const dropTable = (target: any, options: { readonly ifExists?: boolean } = {}) => {
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[Plan.TypeId].dialect
+    }, {
+      kind: "dropTable",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "dropTable",
+        ifExists: options.ifExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "dropTable")
+  }
+
+  const createIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly unique?: boolean; readonly ifNotExists?: boolean } = {}) => {
+    const normalizedColumns = ctx.normalizeColumnList(columns)
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[Plan.TypeId].dialect
+    }, {
+      kind: "createIndex",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "createIndex",
+        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, options.unique ?? false),
+        columns: normalizedColumns,
+        unique: options.unique ?? false,
+        ifNotExists: options.ifNotExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "createIndex")
+  }
+
+  const dropIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly ifExists?: boolean } = {}) => {
+    const normalizedColumns = ctx.normalizeColumnList(columns)
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[Plan.TypeId].dialect
+    }, {
+      kind: "dropIndex",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "dropIndex",
+        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
+        ifExists: options.ifExists ?? false
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "dropIndex")
+  }
+
+  return {
+    transaction,
+    commit,
+    rollback,
+    savepoint,
+    rollbackTo,
+    releaseSavepoint,
+    createTable,
+    dropTable,
+    createIndex,
+    dropIndex
+  }
+}

package/src/internal/executor.ts

@@ -1,18 +1,21 @@
+import * as Chunk from "effect/Chunk"
 import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
 import * as Schema from "effect/Schema"
 import * as SqlClient from "@effect/sql/SqlClient"
 import * as SqlError from "@effect/sql/SqlError"
+import * as Stream from "effect/Stream"
 
-import * as Expression from "./expression.js"
+import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
 import { resolveImplicationScope, type ImplicationScope } from "./implication-runtime.js"
-import { normalizeDbValue } from "./runtime-normalize.js"
-import { expressionRuntimeSchema } from "./runtime-schema.js"
+import { fromDriverValue } from "./runtime/driver-value-mapping.js"
+import { expressionRuntimeSchema } from "./runtime/schema.js"
 import { flattenSelection } from "./projections.js"
 import * as Query from "./query.js"
 import * as QueryAst from "./query-ast.js"
 import * as Renderer from "./renderer.js"
-import * as Plan from "./plan.js"
+import * as Plan from "./row-set.js"
 
 /** Flat database row keyed by rendered projection aliases. */
 export type FlatRow = Readonly<Record<string, unknown>>
@@ -58,6 +61,9 @@ export interface Driver<
   execute<Row>(
     query: Renderer.RenderedQuery<Row, Dialect>
   ): Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+  stream<Row>(
+    query: Renderer.RenderedQuery<Row, Dialect>
+  ): Stream.Stream<FlatRow, Error, Context>
 }
 
 /**
@@ -73,9 +79,12 @@ export interface Executor<
   Context = never
 > {
   readonly dialect: Dialect
-  execute<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+  execute<PlanValue extends Query.Plan.Any>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ): Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
+  stream<PlanValue extends Query.Plan.Any>(
+    plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+  ): Stream.Stream<Query.ResultRow<PlanValue>, Error, Context>
 }
 
 const setPath = (
@@ -117,21 +126,21 @@ const hasWriteStatement = (statement: QueryAst.QueryStatement): boolean =>
 
 const hasWriteCapabilityInSource = (source: unknown): boolean =>
   typeof source === "object" && source !== null && "plan" in source
-    ? hasWriteCapability((source as { readonly plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any, any> }).plan)
+    ? hasWriteCapability((source as { readonly plan: Query.Plan.Any }).plan)
     : false
 
 export const hasWriteCapability = (
-  plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>
+  plan: Query.Plan.Any
 ): boolean => {
   const ast = Query.getAst(plan)
   if (hasWriteStatement(ast.kind)) {
     return true
   }
   if (ast.kind === "set") {
-    if (ast.setBase && hasWriteCapability((ast.setBase as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>))) {
+    if (ast.setBase && hasWriteCapability((ast.setBase as Query.Plan.Any))) {
       return true
     }
-    if ((ast.setOperations ?? []).some((entry) => hasWriteCapability(entry.query as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>))) {
+    if ((ast.setOperations ?? []).some((entry) => hasWriteCapability(entry.query as Query.Plan.Any))) {
       return true
     }
   }
@@ -198,9 +207,6 @@ const hasOptionalSourceDependency = (
   scope: ImplicationScope
 ): boolean => {
   const state = expression[Expression.TypeId]
-  if (state.sourceNullability === "resolved") {
-    return false
-  }
   return Object.keys(state.dependencies).some((sourceName) =>
     !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional")
 }
@@ -223,8 +229,7 @@ const effectiveRuntimeNullability = (
       return "never"
     }
   }
-  if (expression[Expression.TypeId].sourceNullability !== "resolved" &&
-      Object.keys(expression[Expression.TypeId].dependencies).some((sourceName) => scope.absentSourceNames.has(sourceName))) {
+  if (Object.keys(expression[Expression.TypeId].dependencies).some((sourceName) => scope.absentSourceNames.has(sourceName))) {
     return "always"
   }
   return hasOptionalSourceDependency(expression, scope)
@@ -238,12 +243,19 @@ const decodeProjectionValue = (
   expression: Expression.Any,
   raw: unknown,
   scope: ImplicationScope,
-  driverMode: DriverMode
+  driverMode: DriverMode,
+  valueMappings?: Expression.DriverValueMappings
 ): unknown => {
   let normalized = raw
   if (driverMode === "raw") {
     try {
-      normalized = normalizeDbValue(expression[Expression.TypeId].dbType, raw)
+      normalized = fromDriverValue(raw, {
+        dialect: rendered.dialect,
+        dbType: expression[Expression.TypeId].dbType,
+        runtimeSchema: expression[Expression.TypeId].runtimeSchema,
+        driverValueMapping: expression[Expression.TypeId].driverValueMapping,
+        valueMappings
+      })
     } catch (cause) {
       throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause)
     }
@@ -293,14 +305,14 @@ const decodeProjectionValue = (
   }
 }
 
-export const decodeRows = (
+export const makeRowDecoder = (
   rendered: Renderer.RenderedQuery<any, any>,
-  plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>,
-  rows: ReadonlyArray<FlatRow>,
+  plan: Query.Plan.Any,
   options: {
     readonly driverMode?: DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
   } = {}
-): ReadonlyArray<any> => {
+): ((row: FlatRow) => any) => {
   const projections = flattenSelection(
     Query.getAst(plan).select as Record<string, unknown>
   )
@@ -308,8 +320,9 @@ export const decodeRows = (
     projections.map((projection) => [projection.alias, projection.expression] as const)
   )
   const driverMode = options.driverMode ?? "raw"
+  const valueMappings = options.valueMappings ?? rendered.valueMappings
   const scope = resolveImplicationScope(plan[Plan.TypeId].available, Query.getQueryState(plan).assumptions)
-  return rows.map((row) => {
+  return (row) => {
     const decoded: Record<string, unknown> = {}
     for (const projection of rendered.projections) {
       if (!(projection.alias in row)) {
@@ -322,11 +335,37 @@ export const decodeRows = (
       setPath(
         decoded,
         projection.path,
-        decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode)
+        decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode, valueMappings)
       )
     }
     return decoded
-  })
+  }
+}
+
+export const decodeChunk = (
+  rendered: Renderer.RenderedQuery<any, any>,
+  plan: Query.Plan.Any,
+  rows: Chunk.Chunk<FlatRow>,
+  options: {
+    readonly driverMode?: DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
+  } = {}
+): Chunk.Chunk<any> => {
+  const decodeRow = makeRowDecoder(rendered, plan, options)
+  return Chunk.unsafeFromArray(Chunk.toReadonlyArray(rows).map((row) => decodeRow(row)))
+}
+
+export const decodeRows = (
+  rendered: Renderer.RenderedQuery<any, any>,
+  plan: Query.Plan.Any,
+  rows: ReadonlyArray<FlatRow>,
+  options: {
+    readonly driverMode?: DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
+  } = {}
+): ReadonlyArray<any> => {
+  const decodeRow = makeRowDecoder(rendered, plan, options)
+  return rows.map((row) => decodeRow(row))
 }
 
 /**
@@ -338,20 +377,23 @@ export const make = <
   Context = never
 >(
   dialect: Dialect,
-  execute: <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+  execute: <PlanValue extends Query.Plan.Any>(
     plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
   ) => Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
 ): Executor<Dialect, Error, Context> => ({
   dialect,
   execute(plan) {
     return (execute as any)(plan)
+  },
+  stream(plan) {
+    return Stream.unwrap(Effect.map((execute as any)(plan), (rows: ReadonlyArray<any>) => Stream.fromIterable(rows)))
   }
 }) as Executor<Dialect, Error, Context>
 
 /**
  * Constructs a driver from a dialect and execution callback.
  */
-export const driver = <
+export function driver<
   Dialect extends string,
   Error = never,
   Context = never
@@ -360,12 +402,58 @@ export const driver = <
   execute: <Row>(
     query: Renderer.RenderedQuery<Row, Dialect>
   ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
-): Driver<Dialect, Error, Context> => ({
+): Driver<Dialect, Error, Context>
+export function driver<
+  Dialect extends string,
+  Error = never,
+  Context = never
+>(
+  dialect: Dialect,
+  handlers: {
+    readonly execute: <Row>(
+      query: Renderer.RenderedQuery<Row, Dialect>
+    ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+    readonly stream: <Row>(
+      query: Renderer.RenderedQuery<Row, Dialect>
+    ) => Stream.Stream<FlatRow, Error, Context>
+  }
+): Driver<Dialect, Error, Context>
+export function driver<
+  Dialect extends string,
+  Error = never,
+  Context = never
+>(
+  dialect: Dialect,
+  executeOrHandlers:
+    | (<Row>(
+      query: Renderer.RenderedQuery<Row, Dialect>
+    ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>)
+    | {
+      readonly execute: <Row>(
+        query: Renderer.RenderedQuery<Row, Dialect>
+      ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+      readonly stream: <Row>(
+        query: Renderer.RenderedQuery<Row, Dialect>
+      ) => Stream.Stream<FlatRow, Error, Context>
+    }
+): Driver<Dialect, Error, Context> {
+  return {
   dialect,
   execute(query) {
-    return execute(query)
+    return typeof executeOrHandlers === "function"
+      ? executeOrHandlers(query)
+      : executeOrHandlers.execute(query)
+  },
+  stream(query) {
+    if (typeof executeOrHandlers === "function") {
+      return Stream.unwrap(
+        Effect.map(executeOrHandlers(query), (rows) => Stream.fromIterable(rows))
+      )
+    }
+    return executeOrHandlers.stream(query)
   }
-})
+  }
+}
 
 /**
  * Creates an executor by composing a renderer with a rendered-query driver.
@@ -391,20 +479,44 @@ export const fromDriver = <
         sqlDriver.execute(rendered),
         (rows) => remapRows<any>(rendered, rows)
       )
+    },
+    stream(plan: any) {
+      const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
+      return Stream.mapChunks(
+        sqlDriver.stream(rendered),
+        (rows) => Chunk.unsafeFromArray(remapRows<any>(rendered, Chunk.toReadonlyArray(rows)))
+      )
     }
   }
   return executor as unknown as Executor<Dialect, Error, Context>
 }
 
-/**
- * Creates an executor backed by `@effect/sql`'s `SqlClient`.
- */
+export const streamFromSqlClient = <Dialect extends string>(
+  query: Renderer.RenderedQuery<any, Dialect>
+): Stream.Stream<FlatRow, SqlError.SqlError, SqlClient.SqlClient> =>
+  Stream.unwrapScoped(
+    Effect.flatMap(SqlClient.SqlClient, (sql) =>
+      Effect.flatMap(
+        Effect.serviceOption(SqlClient.TransactionConnection),
+        Option.match({
+          onNone: () => sql.reserve,
+          onSome: ([connection]) => Effect.succeed(connection)
+        })
+      ).pipe(
+        Effect.map((connection) => connection.executeStream(query.sql, [...query.params], undefined))
+      )
+    )
+  )
+
 export const fromSqlClient = <Dialect extends string>(
   renderer: Renderer.Renderer<Dialect>
 ): Executor<Dialect, unknown, SqlClient.SqlClient> =>
-  fromDriver(renderer, driver(renderer.dialect, (query) =>
-    Effect.flatMap(SqlClient.SqlClient, (sql) =>
-      sql.unsafe<FlatRow>(query.sql, [...query.params]))))
+  fromDriver(renderer, driver(renderer.dialect, {
+    execute: (query) =>
+      Effect.flatMap(SqlClient.SqlClient, (sql) =>
+        sql.unsafe<FlatRow>(query.sql, [...query.params])),
+    stream: (query) => streamFromSqlClient(query)
+  }))
 
 /** Runs an effect within the ambient `@effect/sql` transaction service. */
 export const withTransaction = <A, E, R>(

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,
@@ -136,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
@@ -144,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
@@ -153,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
@@ -165,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
@@ -339,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;