@effect-app/infra 4.0.0-beta.81 → 4.0.0-beta.83

package/src/Store/SQL/Pg.ts

@@ -0,0 +1,296 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { Effect, type NonEmptyReadonlyArray, Option, Struct } from "effect-app"
+import { toNonEmptyArray } from "effect-app/Array"
+import { SqlClient } from "effect/unstable/sql"
+import { OptimisticConcurrencyException } from "../../errors.js"
+import { InfraLogger } from "../../logger.js"
+import type { FieldValues } from "../../Model/filter/types.js"
+import { storeId } from "../Memory.js"
+import { type FilterArgs, type PersistenceModelType, type StorageConfig, type Store, type StoreConfig, StoreMaker } from "../service.js"
+import { makeETag } from "../utils.js"
+import { buildWhereSQLQuery, logQuery, pgDialect } from "./query.js"
+
+const parseRow = <Encoded extends FieldValues>(
+  row: { id: string; _etag: string | null; data: unknown },
+  idKey: PropertyKey,
+  defaultValues: Partial<Encoded>
+): PersistenceModelType<Encoded> => {
+  const data = (typeof row.data === "string" ? JSON.parse(row.data) : row.data) as object
+  return { ...defaultValues, ...data, [idKey]: row.id, _etag: row._etag ?? undefined } as PersistenceModelType<Encoded>
+}
+
+const parseSelectRow = (
+  row: Record<string, unknown>,
+  idKey: PropertyKey,
+  defaultValues: Record<string, unknown>
+): any => {
+  const result: Record<string, unknown> = { ...defaultValues }
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "id") {
+      result[idKey as string] = value
+      result["id"] = value
+    } else {
+      result[key] = value
+    }
+  }
+  return result
+}
+
+function makePgStore({ prefix }: StorageConfig) {
+  return Effect.gen(function*() {
+    const sql = yield* SqlClient.SqlClient
+    return {
+      make: <IdKey extends keyof Encoded, Encoded extends FieldValues, R = never, E = never>(
+        name: string,
+        idKey: IdKey,
+        seed?: Effect.Effect<Iterable<Encoded>, E, R>,
+        config?: StoreConfig<Encoded>
+      ) =>
+        Effect.gen(function*() {
+          type PM = PersistenceModelType<Encoded>
+          const tableName = `${prefix}${name}`
+          const defaultValues = config?.defaultValues ?? {}
+
+          const resolveNamespace = !config?.allowNamespace
+            ? Effect.succeed("primary")
+            : storeId.asEffect().pipe(Effect.map((namespace) => {
+              if (namespace !== "primary" && !config.allowNamespace!(namespace)) {
+                throw new Error(`Namespace ${namespace} not allowed!`)
+              }
+              return namespace
+            }))
+
+          yield* sql
+            .unsafe(
+              `CREATE TABLE IF NOT EXISTS "${tableName}" (id TEXT NOT NULL, _namespace TEXT NOT NULL DEFAULT 'primary', _etag TEXT, data JSONB NOT NULL, PRIMARY KEY (id, _namespace))`
+            )
+            .pipe(Effect.orDie)
+
+          const toRow = (e: PM) => {
+            const newE = makeETag(e)
+            const id = newE[idKey] as string
+            const { _etag, [idKey]: _id, ...rest } = newE as any
+            const data = JSON.stringify(rest)
+            return { id, _etag: newE._etag!, data, item: newE }
+          }
+
+          const exec = (query: string, params?: readonly unknown[]) =>
+            sql.unsafe(query, params as any).pipe(Effect.orDie)
+
+          const s: Store<IdKey, Encoded> = {
+            all: resolveNamespace.pipe(Effect.flatMap((ns) =>
+              exec(`SELECT id, _etag, data FROM "${tableName}" WHERE _namespace = $1`, [ns])
+                .pipe(
+                  Effect.map((rows) => (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues))),
+                  Effect.withSpan("PgSQL.all [effect-app/infra/Store]", {
+                    attributes: {
+                      "repository.table_name": tableName,
+                      "repository.model_name": name,
+                      "repository.namespace": ns
+                    }
+                  }, { captureStackTrace: false })
+                )
+            )),
+
+            find: (id) =>
+              resolveNamespace.pipe(Effect
+                .flatMap((ns) =>
+                  exec(`SELECT id, _etag, data FROM "${tableName}" WHERE id = $1 AND _namespace = $2`, [id, ns])
+                    .pipe(
+                      Effect.map((rows) => {
+                        const row = (rows as any[])[0]
+                        return row
+                          ? Option.some(parseRow<Encoded>(row, idKey, defaultValues))
+                          : Option.none()
+                      }),
+                      Effect.withSpan("PgSQL.find [effect-app/infra/Store]", {
+                        attributes: { "repository.table_name": tableName, "repository.model_name": name, id }
+                      }, { captureStackTrace: false })
+                    )
+                )),
+
+            filter: <U extends keyof Encoded = never>(f: FilterArgs<Encoded, U>) => {
+              const filter = f
+                .filter
+              type M = U extends undefined ? Encoded : Pick<Encoded, U>
+              return resolveNamespace.pipe(Effect.flatMap((ns) =>
+                Effect
+                  .sync(() => {
+                    const q = buildWhereSQLQuery(
+                      pgDialect,
+                      idKey,
+                      filter ? [{ t: "where-scope", result: filter, relation: "some" }] : [],
+                      tableName,
+                      defaultValues,
+                      f.select as
+                        | NonEmptyReadonlyArray<string | { key: string; subKeys: readonly string[] }>
+                        | undefined,
+                      f.order as NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }> | undefined,
+                      f.skip,
+                      f.limit
+                    )
+                    const nsPlaceholder = pgDialect.placeholder(q.params.length + 1)
+                    const hasWhere = q.sql.includes("WHERE")
+                    const nsSql = hasWhere
+                      ? q.sql.replace("WHERE", `WHERE _namespace = ${nsPlaceholder} AND`)
+                      : q.sql.replace(
+                        `FROM "${tableName}"`,
+                        `FROM "${tableName}" WHERE _namespace = ${nsPlaceholder}`
+                      )
+                    return { sql: nsSql, params: [...q.params, ns] }
+                  })
+                  .pipe(
+                    Effect.tap((q) => logQuery(q)),
+                    Effect.flatMap((q) =>
+                      exec(q.sql, q.params).pipe(
+                        Effect.map((rows) => {
+                          if (f.select) {
+                            return (rows as any[]).map((r) => {
+                              const selected = parseSelectRow(r, idKey, {})
+                              return {
+                                ...Struct.pick(
+                                  defaultValues as any,
+                                  f.select!.filter((_) => typeof _ === "string") as never[]
+                                ),
+                                ...selected
+                              } as M
+                            })
+                          }
+                          return (rows as any[]).map((r) => parseRow<Encoded>(r, idKey, defaultValues) as any as M)
+                        })
+                      )
+                    ),
+                    Effect.withSpan("PgSQL.filter [effect-app/infra/Store]", {
+                      attributes: { "repository.table_name": tableName, "repository.model_name": name }
+                    }, { captureStackTrace: false })
+                  )
+              ))
+            },
+
+            set: (e) =>
+              resolveNamespace.pipe(Effect.flatMap((ns) =>
+                Effect
+                  .gen(function*() {
+                    const row = toRow(e)
+                    if (e._etag) {
+                      yield* exec(
+                        `UPDATE "${tableName}" SET _etag = $1, data = $2 WHERE id = $3 AND _etag = $4 AND _namespace = $5`,
+                        [row._etag, row.data, row.id, e._etag, ns]
+                      )
+                      const existing = yield* exec(
+                        `SELECT _etag FROM "${tableName}" WHERE id = $1 AND _namespace = $2`,
+                        [row.id, ns]
+                      )
+                      const current = (existing as any[])[0]
+                      if (!current || current._etag !== row._etag) {
+                        if (current) {
+                          return yield* new OptimisticConcurrencyException({
+                            type: name,
+                            id: row.id,
+                            current: current._etag,
+                            found: e._etag,
+                            code: 412
+                          })
+                        }
+                        return yield* new OptimisticConcurrencyException({
+                          type: name,
+                          id: row.id,
+                          current: "",
+                          found: e._etag,
+                          code: 404
+                        })
+                      }
+                    } else {
+                      yield* exec(
+                        `INSERT INTO "${tableName}" (id, _namespace, _etag, data) VALUES ($1, $2, $3, $4)`,
+                        [row.id, ns, row._etag, row.data]
+                      )
+                    }
+                    return row.item
+                  })
+                  .pipe(
+                    Effect.withSpan("PgSQL.set [effect-app/infra/Store]", {
+                      attributes: { "repository.table_name": tableName, "repository.model_name": name, id: e[idKey] }
+                    }, { captureStackTrace: false })
+                  )
+              )),
+
+            batchSet: (items) =>
+              sql
+                .withTransaction(
+                  Effect.forEach(items, (e) => s.set(e))
+                )
+                .pipe(
+                  Effect.orDie,
+                  Effect.map((_) => _ as unknown as NonEmptyReadonlyArray<PM>),
+                  Effect.withSpan("PgSQL.batchSet [effect-app/infra/Store]", {
+                    attributes: { "repository.table_name": tableName, "repository.model_name": name }
+                  }, { captureStackTrace: false })
+                ),
+
+            bulkSet: (items) =>
+              sql
+                .withTransaction(
+                  Effect.forEach(items, (e) => s.set(e))
+                )
+                .pipe(
+                  Effect.orDie,
+                  Effect.map((_) => _ as unknown as NonEmptyReadonlyArray<PM>),
+                  Effect.withSpan("PgSQL.bulkSet [effect-app/infra/Store]", {
+                    attributes: { "repository.table_name": tableName, "repository.model_name": name }
+                  }, { captureStackTrace: false })
+                ),
+
+            batchRemove: (ids) => {
+              const placeholders = ids.map((_, i) => `$${i + 1}`).join(", ")
+              const nsPlaceholder = `$${ids.length + 1}`
+              return resolveNamespace.pipe(Effect.flatMap((ns) =>
+                exec(
+                  `DELETE FROM "${tableName}" WHERE id IN (${placeholders}) AND _namespace = ${nsPlaceholder}`,
+                  [...ids, ns]
+                )
+                  .pipe(
+                    Effect.asVoid,
+                    Effect.withSpan("PgSQL.batchRemove [effect-app/infra/Store]", {
+                      attributes: { "repository.table_name": tableName, "repository.model_name": name }
+                    }, { captureStackTrace: false })
+                  )
+              ))
+            },
+
+            queryRaw: (query) =>
+              s.all.pipe(
+                Effect.map(query.memory),
+                Effect.withSpan("PgSQL.queryRaw [effect-app/infra/Store]", {
+                  attributes: { "repository.table_name": tableName, "repository.model_name": name }
+                }, { captureStackTrace: false })
+              )
+          }
+
+          if (seed) {
+            const existing = yield* exec(
+              `SELECT COUNT(*) as cnt FROM "${tableName}" WHERE _namespace = $1`,
+              ["primary"]
+            )
+            const count = Number((existing as any[])[0]?.cnt ?? 0)
+            if (count === 0) {
+              yield* InfraLogger.logInfo("Seeding data for " + name)
+              const items = yield* seed
+              yield* Effect.flatMapOption(
+                Effect.succeed(toNonEmptyArray([...items])),
+                (a) => s.bulkSet(a).pipe(Effect.orDie)
+              )
+            }
+          }
+
+          return s
+        })
+    }
+  })
+}
+
+export function PgStoreLayer(cfg: StorageConfig) {
+  return StoreMaker
+    .toLayer(makePgStore(cfg))
+}

package/src/Store/SQL/query.ts

@@ -0,0 +1,372 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Effect, type NonEmptyReadonlyArray } from "effect-app"
+import { assertUnreachable } from "effect-app/utils"
+import { InfraLogger } from "../../logger.js"
+import type { FilterR, FilterResult, Ops } from "../../Model/filter/filterApi.js"
+import { isRelationCheck } from "../codeFilter.js"
+
+export interface SQLDialect {
+  readonly jsonExtract: (path: string) => string
+  readonly jsonExtractJson: (path: string) => string
+  readonly placeholder: (index: number) => string
+  readonly jsonArrayContains: (arrPath: string, valPlaceholder: string) => string
+  readonly jsonArrayNotContains: (arrPath: string, valPlaceholder: string) => string
+  readonly jsonArrayContainsAny: (arrPath: string, valPlaceholders: readonly string[]) => string
+  readonly jsonArrayNotContainsAny: (arrPath: string, valPlaceholders: readonly string[]) => string
+  readonly jsonArrayContainsAll: (arrPath: string, valPlaceholders: readonly string[]) => string
+  readonly jsonArrayNotContainsAll: (arrPath: string, valPlaceholders: readonly string[]) => string
+  readonly caseInsensitiveLike: (expr: string, valPlaceholder: string) => string
+  readonly caseInsensitiveNotLike: (expr: string, valPlaceholder: string) => string
+  readonly jsonColumnType: "JSON" | "JSONB"
+  readonly arrayLength: (path: string) => string
+}
+
+export const sqliteDialect: SQLDialect = {
+  jsonExtract: (path) => `json_extract(data, '$.${path}')`,
+  jsonExtractJson: (path) => `json_extract(data, '$.${path}')`,
+  placeholder: (_index) => "?",
+  jsonArrayContains: (arrPath, val) => `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value = ${val})`,
+  jsonArrayNotContains: (arrPath, val) =>
+    `NOT EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value = ${val})`,
+  jsonArrayContainsAny: (arrPath, vals) =>
+    `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value IN (${vals.join(", ")}))`,
+  jsonArrayNotContainsAny: (arrPath, vals) =>
+    `NOT EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value IN (${vals.join(", ")}))`,
+  jsonArrayContainsAll: (arrPath, vals) =>
+    vals.map((v) => `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value = ${v})`).join(" AND "),
+  jsonArrayNotContainsAll: (arrPath, vals) =>
+    `NOT (${
+      vals.map((v) => `EXISTS(SELECT 1 FROM json_each(data, '$.${arrPath}') WHERE value = ${v})`).join(" AND ")
+    })`,
+  caseInsensitiveLike: (expr, val) => `LOWER(${expr}) LIKE LOWER(${val})`,
+  caseInsensitiveNotLike: (expr, val) => `LOWER(${expr}) NOT LIKE LOWER(${val})`,
+  jsonColumnType: "JSON",
+  arrayLength: (path) => `json_array_length(data, '$.${path}')`
+}
+
+export const pgDialect: SQLDialect = {
+  jsonExtract: (path) => {
+    const parts = path.split(".")
+    if (parts.length === 1) return `data->>'${parts[0]}'`
+    const last = parts.pop()!
+    return `data${parts.map((p) => `->'${p}'`).join("")}->>'${last}'`
+  },
+  jsonExtractJson: (path) => {
+    const parts = path.split(".")
+    if (parts.length === 1) return `data->'${parts[0]}'`
+    return `data${parts.map((p) => `->'${p}'`).join("")}`
+  },
+  placeholder: (index) => `$${index}`,
+  jsonArrayContains: (arrPath, val) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `${jsonPath} @> ${val}::jsonb`
+  },
+  jsonArrayNotContains: (arrPath, val) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `NOT (${jsonPath} @> ${val}::jsonb)`
+  },
+  jsonArrayContainsAny: (arrPath, vals) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `(${vals.map((v) => `${jsonPath} @> ${v}::jsonb`).join(" OR ")})`
+  },
+  jsonArrayNotContainsAny: (arrPath, vals) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `NOT (${vals.map((v) => `${jsonPath} @> ${v}::jsonb`).join(" OR ")})`
+  },
+  jsonArrayContainsAll: (arrPath, vals) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return vals.map((v) => `${jsonPath} @> ${v}::jsonb`).join(" AND ")
+  },
+  jsonArrayNotContainsAll: (arrPath, vals) => {
+    const parts = arrPath.split(".")
+    const jsonPath = parts.length === 1
+      ? `data->'${parts[0]}'`
+      : `data${parts.map((p) => `->'${p}'`).join("")}`
+    return `NOT (${vals.map((v) => `${jsonPath} @> ${v}::jsonb`).join(" AND ")})`
+  },
+  caseInsensitiveLike: (expr, val) => `${expr} ILIKE ${val}`,
+  caseInsensitiveNotLike: (expr, val) => `${expr} NOT ILIKE ${val}`,
+  jsonColumnType: "JSONB",
+  arrayLength: (path) => `jsonb_array_length(data->'${path}')`
+}
+
+export function logQuery(q: { sql: string; params: unknown[] }) {
+  return InfraLogger
+    .logDebug("sql query")
+    .pipe(Effect.annotateLogs({
+      query: q.sql,
+      parameters: JSON.stringify(q.params, undefined, 2)
+    }))
+}
+
+const dottedToJsonPath = (path: string) =>
+  path
+    .split(".")
+    .filter((p) => p !== "-1")
+    .join(".")
+
+export function buildWhereSQLQuery(
+  dialect: SQLDialect,
+  idKey: PropertyKey,
+  filter: readonly FilterResult[],
+  tableName: string,
+  _defaultValues: Record<string, unknown>,
+  select?: NonEmptyReadonlyArray<string | { key: string; subKeys: readonly string[] }>,
+  order?: NonEmptyReadonlyArray<{ key: string; direction: "ASC" | "DESC" }>,
+  skip?: number,
+  limit?: number
+) {
+  const params: unknown[] = []
+  let paramIndex = 1
+
+  const addParam = (value: unknown): string => {
+    params.push(value)
+    return dialect.placeholder(paramIndex++)
+  }
+
+  const fieldExpr = (path: string): string => {
+    if (path === idKey || path === "id") return "id"
+    if (path.endsWith(".length")) {
+      const arrPath = dottedToJsonPath(path.slice(0, -".length".length))
+      return dialect.arrayLength(arrPath)
+    }
+    const jsonPath = dottedToJsonPath(path)
+    return dialect.jsonExtract(jsonPath)
+  }
+
+  const statement = (x: FilterR): string => {
+    const resolvedPath = x.path === idKey ? "id" : x.path
+    const k = fieldExpr(resolvedPath)
+
+    switch (x.op) {
+      case "in": {
+        const vals = x.value as unknown as readonly unknown[]
+        const placeholders = vals.map((v) => addParam(v))
+        return `${k} IN (${placeholders.join(", ")})`
+      }
+      case "notIn": {
+        const vals = x.value as unknown as readonly unknown[]
+        const placeholders = vals.map((v) => addParam(v))
+        return `${k} NOT IN (${placeholders.join(", ")})`
+      }
+
+      case "includes": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(x.value)
+        return dialect.jsonArrayContains(arrPath, v)
+      }
+      case "notIncludes": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const v = addParam(x.value)
+        return dialect.jsonArrayNotContains(arrPath, v)
+      }
+
+      case "includes-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as unknown as readonly unknown[]
+        const placeholders = vals.map((v) => addParam(JSON.stringify(v)))
+        return dialect.jsonArrayContainsAny(arrPath, placeholders)
+      }
+      case "notIncludes-any": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as unknown as readonly unknown[]
+        const placeholders = vals.map((v) => addParam(JSON.stringify(v)))
+        return dialect.jsonArrayNotContainsAny(arrPath, placeholders)
+      }
+
+      case "includes-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as unknown as readonly unknown[]
+        const placeholders = vals.map((v) => addParam(JSON.stringify(v)))
+        return dialect.jsonArrayContainsAll(arrPath, placeholders)
+      }
+      case "notIncludes-all": {
+        const arrPath = dottedToJsonPath(resolvedPath)
+        const vals = x.value as unknown as readonly unknown[]
+        const placeholders = vals.map((v) => addParam(JSON.stringify(v)))
+        return dialect.jsonArrayNotContainsAll(arrPath, placeholders)
+      }
+
+      case "contains": {
+        const v = addParam(`%${x.value}%`)
+        return dialect.caseInsensitiveLike(k, v)
+      }
+      case "notContains": {
+        const v = addParam(`%${x.value}%`)
+        return dialect.caseInsensitiveNotLike(k, v)
+      }
+      case "startsWith": {
+        const v = addParam(`${x.value}%`)
+        return dialect.caseInsensitiveLike(k, v)
+      }
+      case "notStartsWith": {
+        const v = addParam(`${x.value}%`)
+        return dialect.caseInsensitiveNotLike(k, v)
+      }
+      case "endsWith": {
+        const v = addParam(`%${x.value}`)
+        return dialect.caseInsensitiveLike(k, v)
+      }
+      case "notEndsWith": {
+        const v = addParam(`%${x.value}`)
+        return dialect.caseInsensitiveNotLike(k, v)
+      }
+
+      case "lt": {
+        const v = addParam(x.value)
+        return `${k} < ${v}`
+      }
+      case "lte": {
+        const v = addParam(x.value)
+        return `${k} <= ${v}`
+      }
+      case "gt": {
+        const v = addParam(x.value)
+        return `${k} > ${v}`
+      }
+      case "gte": {
+        const v = addParam(x.value)
+        return `${k} >= ${v}`
+      }
+      case "neq": {
+        if (x.value === null) return `${k} IS NOT NULL`
+        const v = addParam(x.value)
+        return `${k} <> ${v}`
+      }
+      case undefined:
+      case "eq": {
+        if (x.value === null) return `${k} IS NULL`
+        const v = addParam(x.value)
+        return `${k} = ${v}`
+      }
+      default:
+        return assertUnreachable(x.op)
+    }
+  }
+
+  const flipOps = {
+    gt: "lt",
+    lt: "gt",
+    gte: "lte",
+    lte: "gte",
+    contains: "notContains",
+    notContains: "contains",
+    startsWith: "notStartsWith",
+    notStartsWith: "startsWith",
+    endsWith: "notEndsWith",
+    notEndsWith: "endsWith",
+    eq: "neq",
+    neq: "eq",
+    includes: "notIncludes",
+    notIncludes: "includes",
+    "includes-any": "notIncludes-any",
+    "notIncludes-any": "includes-any",
+    "includes-all": "notIncludes-all",
+    "notIncludes-all": "includes-all",
+    in: "notIn",
+    notIn: "in"
+  } satisfies Record<Ops, Ops>
+
+  const flippies = {
+    and: "or",
+    or: "and"
+  } satisfies Record<"and" | "or", "and" | "or">
+
+  const flip = (every: boolean) => (_: FilterResult): FilterResult =>
+    every
+      ? _.t === "where" || _.t === "or" || _.t === "and"
+        ? { ..._, t: _.t === "where" ? _.t : flippies[_.t], op: flipOps[_.op] }
+        : _
+      : _
+
+  const print = (state: readonly FilterResult[], isRelation: string | null, every: boolean): string => {
+    let s = ""
+    for (const e of state) {
+      switch (e.t) {
+        case "where":
+          s += statement(e)
+          break
+        case "or":
+          s += ` OR ${statement(e)}`
+          break
+        case "and":
+          s += ` AND ${statement(e)}`
+          break
+        case "or-scope": {
+          if (!every) every = e.relation === "every"
+          const rel = isRelationCheck(e.result, isRelation)
+          if (rel) {
+            s += ` OR (${print(e.result.map(flip(every)), rel, every)})`
+          } else {
+            s += ` OR (${print(e.result, null, every)})`
+          }
+          break
+        }
+        case "and-scope": {
+          if (!every) every = e.relation === "every"
+          const rel = isRelationCheck(e.result, isRelation)
+          if (rel) {
+            s += ` AND (${print(e.result.map(flip(every)), rel, every)})`
+          } else {
+            s += ` AND (${print(e.result, null, every)})`
+          }
+          break
+        }
+        case "where-scope": {
+          if (!every) every = e.relation === "every"
+          const rel = isRelationCheck(e.result, isRelation)
+          if (rel) {
+            s += `(${print(e.result.map(flip(every)), rel, every)})`
+          } else {
+            s += `(${print(e.result, null, every)})`
+          }
+          break
+        }
+      }
+    }
+    return s
+  }
+
+  const getSelectExpr = (): string => {
+    if (!select) return "id, _etag, data"
+    const fields = select.map((s) => {
+      if (typeof s === "string") {
+        if (s === idKey || s === "id") return `id`
+        return `${dialect.jsonExtract(s)} AS "${s}"`
+      }
+      return `${dialect.jsonExtractJson(s.key)} AS "${s.key}"`
+    })
+    return fields.join(", ")
+  }
+
+  const whereClause = filter.length
+    ? `WHERE ${print([{ t: "where-scope", result: filter, relation: "some" }], null, false)}`
+    : ""
+
+  const orderClause = order
+    ? `ORDER BY ${order.map((_) => `${fieldExpr(_.key)} ${_.direction}`).join(", ")}`
+    : ""
+
+  const limitClause = limit !== undefined || skip !== undefined
+    ? `LIMIT ${addParam(limit ?? 999999)} OFFSET ${addParam(skip ?? 0)}`
+    : ""
+
+  const sql = `SELECT ${getSelectExpr()} FROM "${tableName}" ${whereClause} ${orderClause} ${limitClause}`.trim()
+
+  return { sql, params }
+}