effect-qb 0.16.0 → 0.19.0

package/src/sqlite/errors/normalize.ts

@@ -0,0 +1,229 @@
+import type * as Renderer from "../../internal/renderer.js"
+import {
+  findSqliteErrorDescriptorsByNumberLoose,
+  getSqliteErrorDescriptor,
+  isSqliteErrorNumber,
+  isSqliteErrorSymbol,
+  type SqliteErrorDescriptor,
+  type SqliteErrorNumber,
+  type SqliteErrorSymbol,
+} from "./catalog.js"
+import type {
+  SqliteErrorFields,
+  SqliteQueryContext
+} from "./fields.js"
+import type {
+  SqliteErrorLike,
+  SqliteKnownErrorBase
+} from "./types.js"
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null
+
+const unwrapSqliteDriverCause = (cause: unknown): unknown => {
+  let current = cause
+  while (
+    isRecord(current) &&
+    "_tag" in current &&
+    current._tag === "SqlError" &&
+    "cause" in current
+  ) {
+    current = current.cause
+  }
+  return current
+}
+
+const asString = (value: unknown): string | undefined =>
+  typeof value === "string" ? value : undefined
+
+const asBoolean = (value: unknown): boolean | undefined =>
+  typeof value === "boolean" ? value : undefined
+
+const asNumber = (value: unknown): number | undefined => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value
+  }
+  if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {
+    const parsed = Number(value.trim())
+    return Number.isFinite(parsed) ? parsed : undefined
+  }
+  return undefined
+}
+
+const normalizeFields = (error: Record<string, unknown>): SqliteErrorFields => ({
+  code: asString(error.code),
+  errno: asNumber(error.errno),
+  sqlState: asString(error.sqlState),
+  sqlMessage: asString(error.sqlMessage),
+  fatal: asBoolean(error.fatal),
+  sql: asString(error.sql),
+  syscall: asString(error.syscall),
+  address: asString(error.address),
+  port: asNumber(error.port),
+  hostname: asString(error.hostname)
+})
+
+export type { SqliteErrorLike } from "./types.js"
+
+/** Structured known SQLite error derived from the SQLite result-code catalog. */
+export type KnownSqliteError<Symbol extends SqliteErrorSymbol = SqliteErrorSymbol> =
+  SqliteKnownErrorBase & { readonly symbol: Symbol }
+
+/** Extracts the normalized SQLite error variant for a specific symbol. */
+export type KnownSqliteErrorBySymbol<Symbol extends SqliteErrorSymbol> = KnownSqliteError<Symbol>
+
+/** SQLite-like error whose symbol or number is not in the current catalog. */
+export type UnknownSqliteCodeError = Readonly<{
+  readonly _tag: "@sqlite/unknown/code"
+  readonly code?: string
+  readonly errno?: string | number
+  readonly message: string
+  readonly query?: SqliteQueryContext
+  readonly raw: SqliteErrorLike
+} & SqliteErrorFields>
+
+/** Fallback for non-SQLite driver failures in the SQLite executor path. */
+export type UnknownSqliteDriverError = Readonly<{
+  readonly _tag: "@sqlite/unknown/driver"
+  readonly message: string
+  readonly query?: SqliteQueryContext
+  readonly cause: unknown
+}>
+
+/** Any SQLite-specific driver failure surfaced by the SQLite executor. */
+export type SqliteDriverError =
+  | KnownSqliteError
+  | UnknownSqliteCodeError
+  | UnknownSqliteDriverError
+
+/** Runtime guard for objects that look like SQLite driver errors. */
+export const isSqliteErrorLike = (value: unknown): value is SqliteErrorLike =>
+  isRecord(value) &&
+  (
+    typeof value.code === "string" ||
+    typeof value.errno === "string" ||
+    typeof value.errno === "number" ||
+    typeof value.sqlState === "string" ||
+    typeof value.sqlMessage === "string" ||
+    typeof value.message === "string" ||
+    typeof value.fatal === "boolean"
+  )
+
+const errorMessageOf = (error: SqliteErrorLike): string =>
+  error.sqlMessage ?? error.message ?? "SQLite driver error"
+
+const numberOf = (error: SqliteErrorLike): string | undefined => {
+  if (typeof error.errno === "number" && Number.isFinite(error.errno)) {
+    return String(error.errno)
+  }
+  if (typeof error.errno === "string" && error.errno.trim() !== "") {
+    return error.errno
+  }
+  return undefined
+}
+
+const findDescriptor = (error: SqliteErrorLike): SqliteErrorDescriptor | undefined => {
+  if (typeof error.code === "string" && isSqliteErrorSymbol(error.code)) {
+    return getSqliteErrorDescriptor(error.code)
+  }
+  if (typeof error.code === "string" && isSqliteErrorNumber(error.code)) {
+    const matches = findSqliteErrorDescriptorsByNumberLoose(error.code)
+    if (matches?.length === 1) {
+      return matches[0]
+    }
+  }
+  const number = numberOf(error)
+  if (number !== undefined) {
+    const matches = findSqliteErrorDescriptorsByNumberLoose(number)
+    if (!matches || matches.length === 0) {
+      return undefined
+    }
+    if (matches.length === 1) {
+      return matches[0]
+    }
+    if (typeof error.code === "string") {
+      return matches.find((descriptor) => descriptor.symbol === error.code)
+    }
+  }
+  return undefined
+}
+
+const makeKnownSqliteError = (
+  descriptor: SqliteErrorDescriptor,
+  raw: SqliteErrorLike,
+  query?: SqliteQueryContext
+): SqliteKnownErrorBase => {
+  const fields = normalizeFields(raw as Record<string, unknown>)
+  return {
+    _tag: descriptor.tag,
+    category: descriptor.category,
+    number: descriptor.number,
+    symbol: descriptor.symbol,
+    messageTemplate: descriptor.messageTemplate,
+    message: errorMessageOf(raw),
+    query,
+    raw,
+    ...fields
+  } as SqliteKnownErrorBase
+}
+
+/** Normalizes an unknown failure into a structured SQLite driver error. */
+export const normalizeSqliteDriverError = (
+  cause: unknown,
+  query?: SqliteQueryContext | Renderer.RenderedQuery<any, "sqlite">
+): SqliteDriverError => {
+  const normalizedCause = unwrapSqliteDriverCause(cause)
+  const context = query === undefined
+    ? undefined
+    : "sql" in query
+      ? { sql: query.sql, params: query.params }
+      : query
+
+  if (!isSqliteErrorLike(normalizedCause)) {
+    return {
+      _tag: "@sqlite/unknown/driver",
+      message: normalizedCause instanceof Error ? normalizedCause.message : "Unknown SQLite driver failure",
+      query: context,
+      cause
+    } as UnknownSqliteDriverError
+  }
+
+  const descriptor = findDescriptor(normalizedCause)
+  if (descriptor !== undefined) {
+    return makeKnownSqliteError(descriptor, normalizedCause, context)
+  }
+
+  if (typeof normalizedCause.code === "string" || numberOf(normalizedCause) !== undefined) {
+    return {
+      _tag: "@sqlite/unknown/code",
+      code: asString(normalizedCause.code),
+      errno: normalizedCause.errno,
+      message: errorMessageOf(normalizedCause),
+      query: context,
+      raw: normalizedCause,
+      ...normalizeFields(normalizedCause as Record<string, unknown>)
+    } as UnknownSqliteCodeError
+  }
+
+  return {
+    _tag: "@sqlite/unknown/driver",
+    message: errorMessageOf(normalizedCause),
+    query: context,
+    cause
+  } as UnknownSqliteDriverError
+}
+
+/** Type guard for a specific SQLite catalog symbol. */
+export const hasSymbol = <Symbol extends SqliteErrorSymbol>(
+  error: SqliteDriverError | { readonly symbol?: string },
+  symbol: Symbol
+): error is KnownSqliteErrorBySymbol<Symbol> =>
+  "symbol" in error && error.symbol === symbol
+
+/** Type guard for a specific documented SQLite error number. */
+export const hasNumber = <Number extends SqliteErrorNumber>(
+  error: SqliteDriverError | { readonly number?: string; readonly errno?: string | number },
+  number: Number
+): error is KnownSqliteError & { readonly number: Number } =>
+  ("number" in error && error.number === number) ||
+  ("errno" in error && String(error.errno) === number)

package/src/sqlite/errors/requirements.ts

@@ -0,0 +1,71 @@
+import { read_query_capabilities, type QueryCapability, type QueryRequirement } from "../../internal/query-requirements.js"
+import type { SqliteQueryContext } from "./fields.js"
+import type {
+  KnownSqliteError,
+  SqliteDriverError,
+  UnknownSqliteCodeError,
+  UnknownSqliteDriverError
+} from "./normalize.js"
+
+export type SqliteQueryRequirement = Extract<QueryRequirement, "write" | "ddl" | "transaction" | "locking">
+
+export const sqlite_requirements_by_sqlstate_prefix = {
+  "23": ["write"]
+} as const satisfies Partial<Record<string, readonly SqliteQueryRequirement[]>>
+
+export type SqliteQueryRequirementsError = Readonly<{
+  readonly _tag: "@sqlite/unknown/query-requirements"
+  readonly message: string
+  readonly query?: SqliteQueryContext
+  readonly requiredCapabilities: readonly SqliteQueryRequirement[]
+  readonly actualCapabilities: readonly QueryCapability[]
+  readonly cause: SqliteDriverError
+}>
+
+export type SqliteReadQueryError =
+  | KnownSqliteError
+  | UnknownSqliteCodeError
+  | UnknownSqliteDriverError
+  | SqliteQueryRequirementsError
+
+const requiresWriteSqliteError = (error: SqliteDriverError): boolean =>
+  requirements_of_sqlite_error(error).length > 0
+
+const lookup_sqlite_requirements = (
+  sqlState: string
+): readonly SqliteQueryRequirement[] => {
+  const prefix = sqlState.slice(0, 2)
+  return prefix in sqlite_requirements_by_sqlstate_prefix
+    ? sqlite_requirements_by_sqlstate_prefix[prefix as keyof typeof sqlite_requirements_by_sqlstate_prefix]
+    : []
+}
+
+export const requirements_of_sqlite_error = (
+  error: SqliteDriverError
+): readonly SqliteQueryRequirement[] => {
+  if ("sqlState" in error && typeof error.sqlState === "string") {
+    return lookup_sqlite_requirements(error.sqlState)
+  }
+  if ("symbol" in error && (error.symbol === "SQLITE_READONLY" || error.symbol.startsWith("SQLITE_CONSTRAINT"))) {
+    return ["write"]
+  }
+  return []
+}
+
+export const narrowSqliteDriverErrorForReadQuery = (
+  error: SqliteDriverError
+): SqliteReadQueryError => {
+  const requiredCapabilities = requirements_of_sqlite_error(error)
+  if (!requiresWriteSqliteError(error)) {
+    return error as SqliteReadQueryError
+  }
+
+  return {
+    _tag: "@sqlite/unknown/query-requirements",
+    message: "SQLite driver error requires query capabilities not provided by this plan",
+    query: error.query,
+    requiredCapabilities,
+    actualCapabilities: read_query_capabilities,
+    cause: error
+  } satisfies SqliteQueryRequirementsError
+}

package/src/sqlite/errors/types.ts

@@ -0,0 +1,29 @@
+import type { SqliteErrorNumber, SqliteErrorSymbol, SqliteErrorTag } from "./catalog.js"
+import type { SqliteErrorFields, SqliteQueryContext } from "./fields.js"
+
+/** Raw SQLite-like error shape as commonly exposed by client libraries. */
+export interface SqliteErrorLike {
+  readonly code?: string
+  readonly errno?: string | number
+  readonly sqlState?: string
+  readonly sqlMessage?: string
+  readonly message?: string
+  readonly fatal?: boolean
+  readonly sql?: string
+  readonly syscall?: string
+  readonly address?: string
+  readonly port?: string | number
+  readonly hostname?: string
+}
+
+/** Broad known-SQLite error surface used by the normalizer return type. */
+export interface SqliteKnownErrorBase extends SqliteErrorFields {
+  readonly _tag: SqliteErrorTag
+  readonly category: "sqlite"
+  readonly number: SqliteErrorNumber
+  readonly symbol: SqliteErrorSymbol
+  readonly messageTemplate: string
+  readonly message: string
+  readonly query?: SqliteQueryContext
+  readonly raw: SqliteErrorLike
+}

package/src/sqlite/executor.ts

@@ -0,0 +1,229 @@
+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 type { SqliteDatatypeFamily, SqliteDatatypeKind } from "./datatypes/spec.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">
+export type ValueMappings = Expression.DriverValueMappingsFor<SqliteDatatypeKind | "uuid", SqliteDatatypeFamily | "uuid">
+/** 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?: ValueMappings
+}
+/** 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?: ValueMappings
+}): 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?: ValueMappings
+  }
+): QueryExecutor<Context>
+export function make<Error = never, Context = never>(
+  options: MakeOptions<Error, Context> = {}
+): QueryExecutor<any> {
+  if (options.driver) {
+    return fromDriver(
+      options.renderer ?? CoreRenderer.makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options.valueMappings })),
+      options.driver,
+      options.driverMode,
+      options.valueMappings
+    )
+  }
+  return fromDriver(
+    options.renderer ?? CoreRenderer.makeTrusted("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"