effect-qb 0.13.0 → 0.15.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,21 +1,30 @@
+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 { normalizeDbValue } from "./runtime-normalize.js"
-import { expressionRuntimeSchema } from "./runtime-schema.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 { 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>>
 export type DriverMode = "raw" | "normalized"
 
+type AstBackedExpression = Expression.Any & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+}
+
 export interface RowDecodeError {
   readonly _tag: "RowDecodeError"
   readonly message: string
@@ -52,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>
 }
 
 /**
@@ -67,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>>(
+  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 = (
@@ -111,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
     }
   }
@@ -189,24 +204,35 @@ const makeRowDecodeError = (
 
 const hasOptionalSourceDependency = (
   expression: Expression.Any,
-  available: Readonly<Record<string, Plan.Source>>
+  scope: ImplicationScope
 ): boolean => {
   const state = expression[Expression.TypeId]
-  if (state.sourceNullability === "resolved") {
-    return false
-  }
-  return Object.keys(state.dependencies).some((sourceName) => available[sourceName]?.mode === "optional")
+  return Object.keys(state.dependencies).some((sourceName) =>
+    !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional")
 }
 
 const effectiveRuntimeNullability = (
   expression: Expression.Any,
-  available: Readonly<Record<string, Plan.Source>>
+  scope: ImplicationScope
 ): Expression.Nullability => {
   const nullability = expression[Expression.TypeId].nullability
+  const ast = (expression as AstBackedExpression)[ExpressionAst.TypeId]
   if (nullability === "always") {
     return "always"
   }
-  return hasOptionalSourceDependency(expression, available)
+  if (ast.kind === "column") {
+    const key = `${ast.tableName}.${ast.columnName}`
+    if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key)) {
+      return "always"
+    }
+    if (scope.nonNullKeys.has(key)) {
+      return "never"
+    }
+  }
+  if (Object.keys(expression[Expression.TypeId].dependencies).some((sourceName) => scope.absentSourceNames.has(sourceName))) {
+    return "always"
+  }
+  return hasOptionalSourceDependency(expression, scope)
     ? "maybe"
     : nullability
 }
@@ -216,7 +242,7 @@ const decodeProjectionValue = (
   projection: Renderer.RenderedQuery<any, any>["projections"][number],
   expression: Expression.Any,
   raw: unknown,
-  available: Readonly<Record<string, Plan.Source>>,
+  scope: ImplicationScope,
   driverMode: DriverMode
 ): unknown => {
   let normalized = raw
@@ -228,8 +254,9 @@ const decodeProjectionValue = (
     }
   }
 
+  const nullability = effectiveRuntimeNullability(expression, scope)
   if (normalized === null) {
-    if (effectiveRuntimeNullability(expression, available) === "never") {
+    if (nullability === "never") {
       throw makeRowDecodeError(
         rendered,
         projection,
@@ -243,7 +270,19 @@ const decodeProjectionValue = (
     return null
   }
 
-  const schema = expressionRuntimeSchema(expression)
+  if (nullability === "always") {
+    throw makeRowDecodeError(
+      rendered,
+      projection,
+      expression,
+      raw,
+      "schema",
+      new Error("Received non-null for an always-null projection"),
+      normalized
+    )
+  }
+
+  const schema = expressionRuntimeSchema(expression, { assumptions: scope.assumptions })
   if (schema === undefined) {
     return normalized
   }
@@ -259,14 +298,13 @@ 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
   } = {}
-): ReadonlyArray<any> => {
+): ((row: FlatRow) => any) => {
   const projections = flattenSelection(
     Query.getAst(plan).select as Record<string, unknown>
   )
@@ -274,8 +312,8 @@ export const decodeRows = (
     projections.map((projection) => [projection.alias, projection.expression] as const)
   )
   const driverMode = options.driverMode ?? "raw"
-  const available = plan[Plan.TypeId].available
-  return rows.map((row) => {
+  const scope = resolveImplicationScope(plan[Plan.TypeId].available, Query.getQueryState(plan).assumptions)
+  return (row) => {
     const decoded: Record<string, unknown> = {}
     for (const projection of rendered.projections) {
       if (!(projection.alias in row)) {
@@ -288,11 +326,35 @@ export const decodeRows = (
       setPath(
         decoded,
         projection.path,
-        decodeProjectionValue(rendered, projection, expression, row[projection.alias], available, driverMode)
+        decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode)
       )
     }
     return decoded
-  })
+  }
+}
+
+export const decodeChunk = (
+  rendered: Renderer.RenderedQuery<any, any>,
+  plan: Query.Plan.Any,
+  rows: Chunk.Chunk<FlatRow>,
+  options: {
+    readonly driverMode?: DriverMode
+  } = {}
+): 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
+  } = {}
+): ReadonlyArray<any> => {
+  const decodeRow = makeRowDecoder(rendered, plan, options)
+  return rows.map((row) => decodeRow(row))
 }
 
 /**
@@ -304,20 +366,23 @@ export const make = <
   Context = never
 >(
   dialect: Dialect,
-  execute: <PlanValue extends Query.QueryPlan<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
@@ -326,12 +391,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.
@@ -357,20 +468,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>(