effect-qb 0.15.0 → 0.17.0

package/src/sqlite/executor.ts

@@ -0,0 +1,227 @@
+import * as Effect from "effect/Effect"
+import * as SqlClient from "@effect/sql/SqlClient"
+import * as Stream from "effect/Stream"
+
+import * as CoreExecutor from "../internal/executor.js"
+import * as CoreQuery from "../internal/query.js"
+import * as CoreRenderer from "../internal/renderer.js"
+import type * as Expression from "../internal/scalar.js"
+import { renderSqlitePlan } from "./internal/renderer.js"
+import {
+  narrowSqliteDriverErrorForReadQuery,
+  normalizeSqliteDriverError,
+  type SqliteDriverError,
+  type SqliteReadQueryError
+} from "./errors/index.js"
+
+/** SQLite-specialized flat row returned by SQL drivers. */
+export type FlatRow = CoreExecutor.FlatRow
+/** Runtime decode failure raised after SQL execution but before row remapping. */
+export type RowDecodeError = CoreExecutor.RowDecodeError
+/** SQLite-specialized rendered-query driver. */
+export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"sqlite", Error, Context>
+/** SQLite-specialized executor contract. */
+export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"sqlite", Error, Context>
+/** SQLite-specialized renderer contract. */
+export type Renderer = CoreRenderer.Renderer<"sqlite">
+/** Optional renderer / driver overrides for the standard SQLite executor pipeline. */
+export interface MakeOptions<Error = never, Context = never> {
+  readonly renderer?: Renderer
+  readonly driver?: Driver<Error, Context>
+  readonly driverMode?: CoreExecutor.DriverMode
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+/** Standard composed error shape for SQLite executors. */
+export type SqliteExecutorError = SqliteDriverError | RowDecodeError
+/** Read-query error surface emitted by built-in SQLite executors. */
+export type SqliteQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? SqliteReadQueryError : SqliteExecutorError
+
+/** Runs an effect within the ambient SQLite SQL transaction service. */
+export const withTransaction = CoreExecutor.withTransaction
+/** Runs an effect in a nested SQLite SQL transaction scope. */
+export const withSavepoint = CoreExecutor.withSavepoint
+
+/** SQLite executor whose error channel narrows based on the query plan. */
+export interface QueryExecutor<Context = never> {
+  readonly dialect: "sqlite"
+  execute<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "sqlite">
+  ): Effect.Effect<CoreQuery.ResultRows<PlanValue>, SqliteQueryError<PlanValue>, Context>
+  stream<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read" | "locking"> extends never
+      ? CoreQuery.DialectCompatiblePlan<PlanValue, "sqlite">
+      : never
+  ): Stream.Stream<CoreQuery.ResultRow<PlanValue>, SqliteQueryError<PlanValue>, Context>
+}
+
+type DriverExecute<Error, Context> = <Row>(
+  query: CoreRenderer.RenderedQuery<Row, "sqlite">
+) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+
+type DriverHandlers<Error, Context> = {
+  readonly execute: DriverExecute<Error, Context>
+  readonly stream: <Row>(
+    query: CoreRenderer.RenderedQuery<Row, "sqlite">
+  ) => Stream.Stream<FlatRow, Error, Context>
+}
+
+/** Constructs a SQLite-specialized SQL driver. */
+export function driver<
+  Error = never,
+  Context = never
+>(
+  execute: DriverExecute<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  handlers: DriverHandlers<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialect: "sqlite",
+  execute: DriverExecute<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialect: "sqlite",
+  handlers: DriverHandlers<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialectOrExecute: "sqlite" | DriverExecute<Error, Context> | DriverHandlers<Error, Context>,
+  maybeExecute?: DriverExecute<Error, Context> | DriverHandlers<Error, Context>
+): Driver<Error, Context> {
+  const executeOrHandlers = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute
+  return typeof executeOrHandlers === "function"
+    ? CoreExecutor.driver("sqlite", executeOrHandlers)
+    : CoreExecutor.driver("sqlite", executeOrHandlers as DriverHandlers<Error, Context>)
+}
+
+const fromDriver = <
+  Error = never,
+  Context = never
+>(
+  renderer: Renderer,
+  sqlDriver: Driver<Error, Context>,
+  driverMode: CoreExecutor.DriverMode = "raw",
+  valueMappings?: Expression.DriverValueMappings
+): QueryExecutor<Context> => ({
+  dialect: "sqlite",
+  execute(plan) {
+    const rendered = renderer.render(plan)
+    return Effect.mapError(
+      Effect.flatMap(
+        sqlDriver.execute(rendered),
+        (rows) => Effect.try({
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
+          catch: (error) => error as RowDecodeError
+        })
+      ),
+      (error) => {
+        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
+          return error as RowDecodeError
+        }
+        const normalized = normalizeSqliteDriverError(error, rendered)
+        return CoreExecutor.hasWriteCapability(plan)
+          ? normalized
+          : narrowSqliteDriverErrorForReadQuery(normalized)
+      }
+    ) as Effect.Effect<any, any, Context>
+  },
+  stream(plan) {
+    const rendered = renderer.render(plan)
+    return Stream.mapError(
+      Stream.mapChunksEffect(
+        sqlDriver.stream(rendered),
+        (rows) => Effect.try({
+          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+          catch: (error) => error as RowDecodeError
+        })
+      ),
+      (error) => {
+        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
+          return error as RowDecodeError
+        }
+        const normalized = normalizeSqliteDriverError(error, rendered)
+        return CoreExecutor.hasWriteCapability(plan)
+          ? normalized
+          : narrowSqliteDriverErrorForReadQuery(normalized)
+      }
+    ) as Stream.Stream<any, any, Context>
+  }
+})
+
+const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
+  driver({
+    execute: (query: CoreRenderer.RenderedQuery<any, "sqlite">) =>
+      Effect.flatMap(SqlClient.SqlClient, (sql) =>
+        sql.unsafe<FlatRow>(query.sql, [...query.params])),
+    stream: (query: CoreRenderer.RenderedQuery<any, "sqlite">) =>
+      Stream.unwrap(
+        Effect.map(
+          Effect.flatMap(SqlClient.SqlClient, (sql) =>
+            sql.unsafe<FlatRow>(query.sql, [...query.params])),
+          (rows) => Stream.fromIterable(rows)
+        )
+      )
+  })
+
+/**
+ * Creates the standard SQLite executor pipeline.
+ *
+ * By default this uses the built-in SQLite renderer plus the ambient
+ * `@effect/sql` `SqlClient`. Advanced callers can override the renderer,
+ * driver, or both.
+ */
+export function make(): QueryExecutor<SqlClient.SqlClient>
+export function make(options: {
+  readonly renderer?: Renderer
+  readonly driverMode?: CoreExecutor.DriverMode
+  readonly valueMappings?: Expression.DriverValueMappings
+}): QueryExecutor<SqlClient.SqlClient>
+export function make<Error = never, Context = never>(
+  options: {
+    readonly renderer?: Renderer
+    readonly driver: Driver<Error, Context>
+    readonly driverMode?: CoreExecutor.DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
+  }
+): QueryExecutor<Context>
+export function make<Error = never, Context = never>(
+  options: MakeOptions<Error, Context> = {}
+): QueryExecutor<any> {
+  if (options.driver) {
+    return fromDriver(
+      options.renderer ?? CoreRenderer.make("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options.valueMappings })),
+      options.driver,
+      options.driverMode,
+      options.valueMappings
+    )
+  }
+  return fromDriver(
+    options.renderer ?? CoreRenderer.make("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options.valueMappings })),
+    sqlClientDriver(),
+    options.driverMode,
+    options.valueMappings
+  )
+}
+
+/** Creates a SQLite-specialized executor from a typed implementation callback. */
+export const custom = <
+  Error = never,
+  Context = never
+>(
+  execute: <PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: CoreQuery.DialectCompatiblePlan<PlanValue, "sqlite">
+  ) => Effect.Effect<CoreQuery.ResultRows<PlanValue>, Error, Context>
+): Executor<Error, Context> =>
+  CoreExecutor.make("sqlite", execute as any) as Executor<Error, Context>

package/src/sqlite/function/aggregate.ts

@@ -0,0 +1,2 @@
+/** SQLite aggregate functions. */
+export { count, max, min } from "../internal/dsl.js"

package/src/sqlite/function/core.ts

@@ -0,0 +1,2 @@
+/** SQLite scalar core functions. */
+export { coalesce, call } from "../internal/dsl.js"

package/src/sqlite/function/index.ts

@@ -0,0 +1,19 @@
+export * as core from "./core.js"
+export * as string from "./string.js"
+export * as aggregate from "./aggregate.js"
+export * as window from "./window.js"
+export * as temporal from "./temporal.js"
+
+export { coalesce } from "./core.js"
+export { call } from "./core.js"
+export { lower, upper, concat } from "./string.js"
+export { count, max, min } from "./aggregate.js"
+export { over, rowNumber, rank, denseRank } from "./window.js"
+export {
+  currentDate,
+  currentTime,
+  currentTimestamp,
+  localTime,
+  localTimestamp,
+  now
+} from "./temporal.js"

package/src/sqlite/function/string.ts

@@ -0,0 +1,2 @@
+/** SQLite string functions. */
+export { lower, upper, concat } from "../internal/dsl.js"

package/src/sqlite/function/temporal.ts

@@ -0,0 +1,100 @@
+import type * as Schema from "effect/Schema"
+
+import type * as Expression from "../../internal/scalar.js"
+import type * as ExpressionAst from "../../internal/expression-ast.js"
+import { makeExpression } from "../../internal/query.js"
+import { sqliteDatatypes } from "../datatypes/index.js"
+import {
+  LocalDateStringSchema,
+  LocalDateTimeStringSchema,
+  LocalTimeStringSchema,
+  type LocalDateString,
+  type LocalDateTimeString,
+  type LocalTimeString
+} from "../../internal/runtime/value.js"
+
+type TemporalExpression<
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+> = Expression.Scalar<
+  Runtime,
+  Db,
+  "never",
+  "sqlite",
+  "scalar",
+  never
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<Name, readonly []>
+}
+
+const makeTemporal = <
+  Runtime,
+  Db extends Expression.DbType.Any,
+  Name extends string
+>(
+  name: Name,
+  dbType: Db,
+  runtimeSchema: Schema.Schema<Runtime, any, any>
+): TemporalExpression<Runtime, Db, Name> =>
+  makeExpression({
+    runtime: undefined as unknown as Runtime,
+    dbType,
+    runtimeSchema,
+    nullability: "never",
+    dialect: "sqlite",
+    kind: "scalar",
+    dependencies: {},
+  }, {
+    kind: "function",
+    name,
+    args: []
+  }) as TemporalExpression<Runtime, Db, Name>
+
+/** SQLite current date. */
+export const currentDate = () =>
+  makeTemporal(
+    "current_date",
+    sqliteDatatypes.date(),
+    LocalDateStringSchema
+  )
+
+/** SQLite current time. */
+export const currentTime = () =>
+  makeTemporal(
+    "current_time",
+    sqliteDatatypes.time(),
+    LocalTimeStringSchema
+  )
+
+/** SQLite current timestamp. */
+export const currentTimestamp = () =>
+  makeTemporal(
+    "current_timestamp",
+    sqliteDatatypes.timestamp(),
+    LocalDateTimeStringSchema
+  )
+
+/** SQLite local time. */
+export const localTime = () =>
+  makeTemporal(
+    "localtime",
+    sqliteDatatypes.time(),
+    LocalTimeStringSchema
+  )
+
+/** SQLite local timestamp. */
+export const localTimestamp = () =>
+  makeTemporal(
+    "localtimestamp",
+    sqliteDatatypes.timestamp(),
+    LocalDateTimeStringSchema
+  )
+
+/** SQLite current instant-like timestamp. */
+export const now = () =>
+  makeTemporal(
+    "now",
+    sqliteDatatypes.timestamp(),
+    LocalDateTimeStringSchema
+  )

package/src/sqlite/function/window.ts

@@ -0,0 +1,2 @@
+/** SQLite window functions. */
+export { over, rowNumber, rank, denseRank } from "../internal/dsl.js"

package/src/sqlite/internal/dialect.ts

@@ -0,0 +1,37 @@
+import type { RenderState, RenderValueContext, SqlDialect } from "../../internal/dialect.js"
+import { toDriverValue } from "../../internal/runtime/driver-value-mapping.js"
+
+const quoteIdentifier = (value: string): string => `"${value.replaceAll("\"", "\"\"")}"`
+
+const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
+  const driverValue = toDriverValue(value, {
+    dialect: "sqlite",
+    valueMappings: state.valueMappings,
+    ...context
+  })
+  if (driverValue === null) {
+    return "null"
+  }
+  state.params.push(driverValue)
+  return "?"
+}
+
+/**
+ * Built-in runtime dialect implementation for SQLite.
+ */
+export const sqliteDialect: SqlDialect<"sqlite"> = {
+  name: "sqlite",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName
+      ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
+      : quoteIdentifier(baseTableName)
+    return tableName === baseTableName
+      ? renderedBase
+      : `${renderedBase} as ${quoteIdentifier(tableName)}`
+  },
+  renderConcat(values) {
+    return `(${values.join(" || ")})`
+  }
+}