@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/zqlite/src/internal/sql-inline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-inline.js","sources":["../../../../../zqlite/src/internal/sql-inline.ts"],"sourcesContent":["import type {FormatConfig} from '@databases/sql';\nimport type {SQLQuery} from '@databases/sql';\nimport {escapeSQLiteIdentifier} from '@databases/escape-identifier';\n\n/**\n * Escapes a SQLite string value by doubling single quotes.\n * SQLite uses single quotes for string literals and doubles them for escaping.\n */\nfunction escapeSQLiteString(str: string): string {\n  return `'${str.replace(/'/g, \"''\")}'`;\n}\n\n/**\n * Formats a value for inline inclusion in SQL (not as a placeholder).\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner,\n * not for user-facing queries. All production queries must use parameterized\n * statements to prevent SQL injection.\n *\n * @param value The value to inline into SQL\n * @returns SQL literal representation of the value\n */\nfunction inlineValue(value: unknown): string {\n  if (value === null) {\n    return 'NULL';\n  }\n  if (typeof value === 'string') {\n    return escapeSQLiteString(value);\n  }\n  if (typeof value === 'number') {\n    return String(value);\n  }\n  if (typeof value === 'boolean') {\n    // SQLite uses 1 and 0 for booleans\n    return value ? '1' : '0';\n  }\n  if (Array.isArray(value)) {\n    // For arrays, use JSON representation (same as query-builder.ts does for IN clauses)\n    return escapeSQLiteString(JSON.stringify(value));\n  }\n  // For objects/other JSON types\n  return escapeSQLiteString(JSON.stringify(value));\n}\n\n/**\n * Format configuration that inlines values directly into SQL instead of using placeholders.\n *\n * This is used ONLY for cost estimation in the SQLite cost model, where we want SQLite's\n * query planner to see actual values to make better decisions about index usage and query plans.\n *\n * Production code must use the standard parameterized format from sql.ts.\n */\nconst sqliteInlineFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value =>\n    // undefined is our signal to use a placeholder\n    // IMPORTANT. Changing this will break the planner as it will assume `NULL`\n    // for constraints!\n    value === undefined\n      ? {\n          placeholder: '?',\n          value,\n        }\n      : {\n          placeholder: inlineValue(value),\n          value: undefined, // No binding needed since value is inlined\n        },\n};\n\n/**\n * Compiles a SQL query with values inlined directly into the SQL string.\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner.\n * Never use this for user-facing queries - always use the standard `compile()`\n * function from sql.ts which uses parameterized queries.\n *\n * @param sql The SQL query to compile\n * @returns SQL string with values inlined\n */\nexport function compileInline(sql: SQLQuery): string {\n  return sql.format(sqliteInlineFormat).text;\n}\n"],"names":[],"mappings":";AAQA,SAAS,mBAAmB,KAAqB;AAC/C,SAAO,IAAI,IAAI,QAAQ,MAAM,IAAI,CAAC;AACpC;AAYA,SAAS,YAAY,OAAwB;AAC3C,MAAI,UAAU,MAAM;AAClB,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,mBAAmB,KAAK;AAAA,EACjC;AACA,MAAI,OAAO,UAAU,UAAU;AAC7B,WAAO,OAAO,KAAK;AAAA,EACrB;AACA,MAAI,OAAO,UAAU,WAAW;AAE9B,WAAO,QAAQ,MAAM;AAAA,EACvB;AACA,MAAI,MAAM,QAAQ,KAAK,GAAG;AAExB,WAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;AAAA,EACjD;AAEA,SAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;AACjD;AAUA,MAAM,qBAAmC;AAAA,EACvC,kBAAkB,CAAA,QAAO,uBAAuB,GAAG;AAAA,EACnD,aAAa,CAAA;AAAA;AAAA;AAAA;AAAA,IAIX,UAAU,SACN;AAAA,MACE,aAAa;AAAA,MACb;AAAA,IAAA,IAEF;AAAA,MACE,aAAa,YAAY,KAAK;AAAA,MAC9B,OAAO;AAAA;AAAA,IAAA;AAAA;AAEjB;AAYO,SAAS,cAAc,KAAuB;AACnD,SAAO,IAAI,OAAO,kBAAkB,EAAE;AACxC;"}

package/out/zqlite/src/internal/sql.js

@@ -1,14 +1,19 @@
-import baseSql from '@databases/sql';
-import { escapeSQLiteIdentifier } from '@databases/escape-identifier';
+import baseSql from "@databases/sql";
+import { escapeSQLiteIdentifier } from "@databases/escape-identifier";
 const sqliteFormat = {
-    escapeIdentifier: str => escapeSQLiteIdentifier(str),
-    formatValue: value => ({ placeholder: '?', value }),
+  escapeIdentifier: (str) => escapeSQLiteIdentifier(str),
+  formatValue: (value) => ({ placeholder: "?", value })
 };
-export function compile(sql) {
-    return sql.format(sqliteFormat).text;
+function compile(sql2) {
+  return sql2.format(sqliteFormat).text;
 }
-export function format(sql) {
-    return sql.format(sqliteFormat);
+function format(sql2) {
+  return sql2.format(sqliteFormat);
 }
-export const sql = baseSql.default;
-//# sourceMappingURL=sql.js.map
+const sql = baseSql.default;
+export {
+  compile,
+  format,
+  sql
+};
+//# sourceMappingURL=sql.js.map

package/out/zqlite/src/internal/sql.js.map

@@ -1 +1 @@
-{"version":3,"file":"sql.js","sourceRoot":"","sources":["../../../../../zqlite/src/internal/sql.ts"],"names":[],"mappings":"AACA,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAC,sBAAsB,EAAC,MAAM,8BAA8B,CAAC;AAEpE,MAAM,YAAY,GAAiB;IACjC,gBAAgB,EAAE,GAAG,CAAC,EAAE,CAAC,sBAAsB,CAAC,GAAG,CAAC;IACpD,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,EAAC,WAAW,EAAE,GAAG,EAAE,KAAK,EAAC,CAAC;CAClD,CAAC;AAEF,MAAM,UAAU,OAAO,CAAC,GAAa;IACnC,OAAO,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,IAAI,CAAC;AACvC,CAAC;AAED,MAAM,UAAU,MAAM,CAAC,GAAa;IAClC,OAAO,GAAG,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,CAAC,MAAM,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC"}
+{"version":3,"file":"sql.js","sources":["../../../../../zqlite/src/internal/sql.ts"],"sourcesContent":["import type {SQLQuery, FormatConfig} from '@databases/sql';\nimport baseSql from '@databases/sql';\nimport {escapeSQLiteIdentifier} from '@databases/escape-identifier';\n\nconst sqliteFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value => ({placeholder: '?', value}),\n};\n\nexport function compile(sql: SQLQuery): string {\n  return sql.format(sqliteFormat).text;\n}\n\nexport function format(sql: SQLQuery) {\n  return sql.format(sqliteFormat);\n}\n\nexport const sql = baseSql.default;\n"],"names":["sql"],"mappings":";;AAIA,MAAM,eAA6B;AAAA,EACjC,kBAAkB,CAAA,QAAO,uBAAuB,GAAG;AAAA,EACnD,aAAa,CAAA,WAAU,EAAC,aAAa,KAAK,MAAA;AAC5C;AAEO,SAAS,QAAQA,MAAuB;AAC7C,SAAOA,KAAI,OAAO,YAAY,EAAE;AAClC;AAEO,SAAS,OAAOA,MAAe;AACpC,SAAOA,KAAI,OAAO,YAAY;AAChC;AAEO,MAAM,MAAM,QAAQ;"}

package/out/zqlite/src/internal/statement-cache.js

@@ -1,119 +1,95 @@
 import { assert } from "../../../shared/src/asserts.js";
-/**
- * SQLite statement preparation isn't cheap as it involves evaluating possible
- * query plans and picking the best one (in addition to parsing the SQL).
- *
- * This statement cache prevents the need to re-prepare the same statement
- * multiple times.
- *
- * One extra wrinkle is that a single statement cannot be used by multiple
- * callers at the same time. As in, we can't `iterate` the same statement
- * many times concurrently.
- *
- * Given that, statements are removed from the cache while in use.
- * - `get` removes the statement from the cache
- * - `return` adds it back.
- *
- * If a request for the same sql is made while a
- * statement is gotten, a new statement will be prepared.
- * Both statements can be returned to the cache even though they both
- * serve the same SQL. Having both copies returned to the cache allows
- * the cache to serve multiple callers concurrently in the future.
- *
- * It is not an error to fail to call `return` on a statement.
- * Failing to call return will only prevent the statement from being reused
- * by other callers. It will not cause a resource leak.
- */
-export class StatementCache {
-    #cache = new Map();
-    #db;
-    #size = 0;
-    /**
-     * The db connection used to prepare the statement.
-     * It is an error to use a statement prepared on one connection with another connection.
-     * @param db
-     */
-    constructor(db) {
-        this.#db = db;
+class StatementCache {
+  #cache = /* @__PURE__ */ new Map();
+  #db;
+  #size = 0;
+  /**
+   * The db connection used to prepare the statement.
+   * It is an error to use a statement prepared on one connection with another connection.
+   * @param db
+   */
+  constructor(db) {
+    this.#db = db;
+  }
+  // the number of statements in the cache
+  get size() {
+    return this.#size;
+  }
+  drop(n) {
+    assert(n >= 0, "Cannot drop a negative number of items");
+    assert(n <= this.#size, "Cannot drop more items than are in the cache");
+    let remaining = n;
+    for (const [sql, statements] of this.#cache.entries()) {
+      if (remaining >= statements.length) {
+        this.#cache.delete(sql);
+        remaining -= statements.length;
+        this.#size -= statements.length;
+      } else {
+        statements.splice(0, remaining);
+        this.#size -= remaining;
+        break;
+      }
     }
-    // the number of statements in the cache
-    get size() {
-        return this.#size;
+  }
+  /**
+   * Prepares a statement for the given sql unless one is already cached.
+   * If one is cached, it is removed from the cache and returned.
+   *
+   * Since `get` removes the item from the cache it is not an error to fail to call
+   * `return`. The gotten statement will be correctly garbage collected.
+   *
+   * When a gotten statement is not returned, future calls to
+   * `get` with the same `sql` will prepare a new statement.
+   *
+   * @param sql
+   * @returns
+   */
+  get(sql) {
+    sql = normalizeWhitespace(sql);
+    const statements = this.#cache.get(sql);
+    if (statements && statements.length > 0) {
+      const statement2 = statements.pop();
+      this.#size--;
+      if (statements.length === 0) {
+        this.#cache.delete(sql);
+      }
+      return { sql, statement: statement2 };
     }
-    drop(n) {
-        assert(n >= 0, 'Cannot drop a negative number of items');
-        assert(n <= this.#size, 'Cannot drop more items than are in the cache');
-        let remaining = n;
-        for (const [sql, statements] of this.#cache.entries()) {
-            if (remaining >= statements.length) {
-                this.#cache.delete(sql);
-                remaining -= statements.length;
-                this.#size -= statements.length;
-            }
-            else {
-                statements.splice(0, remaining);
-                this.#size -= remaining;
-                break;
-            }
-        }
+    const statement = this.#db.prepare(sql);
+    return { sql, statement };
+  }
+  /**
+   * Handles `get` and `return` for the caller by invoking them before
+   * and after the callback.
+   */
+  use(sql, cb) {
+    const statement = this.get(sql);
+    try {
+      return cb(statement);
+    } finally {
+      this.return(statement);
     }
-    /**
-     * Prepares a statement for the given sql unless one is already cached.
-     * If one is cached, it is removed from the cache and returned.
-     *
-     * Since `get` removes the item from the cache it is not an error to fail to call
-     * `return`. The gotten statement will be correctly garbage collected.
-     *
-     * When a gotten statement is not returned, future calls to
-     * `get` with the same `sql` will prepare a new statement.
-     *
-     * @param sql
-     * @returns
-     */
-    get(sql) {
-        sql = normalizeWhitespace(sql);
-        const statements = this.#cache.get(sql);
-        if (statements && statements.length > 0) {
-            const statement = statements.pop();
-            this.#size--;
-            if (statements.length === 0) {
-                this.#cache.delete(sql);
-            }
-            return { sql, statement };
-        }
-        const statement = this.#db.prepare(sql);
-        return { sql, statement };
+  }
+  /**
+   * Add a statement back to the cache so someone else can use it later.
+   * @param statement
+   */
+  return(statement) {
+    const { sql } = statement;
+    if (!this.#cache.has(sql)) {
+      this.#cache.set(sql, []);
     }
-    /**
-     * Handles `get` and `return` for the caller by invoking them before
-     * and after the callback.
-     */
-    use(sql, cb) {
-        const statement = this.get(sql);
-        try {
-            return cb(statement);
-        }
-        finally {
-            this.return(statement);
-        }
-    }
-    /**
-     * Add a statement back to the cache so someone else can use it later.
-     * @param statement
-     */
-    return(statement) {
-        const { sql } = statement;
-        if (!this.#cache.has(sql)) {
-            this.#cache.set(sql, []);
-        }
-        const statements = this.#cache.get(sql);
-        if (statements) {
-            statements.push(statement.statement);
-            this.#size++;
-        }
+    const statements = this.#cache.get(sql);
+    if (statements) {
+      statements.push(statement.statement);
+      this.#size++;
     }
+  }
 }
 function normalizeWhitespace(sql) {
-    return sql.replaceAll(/\s+/g, ' ');
+  return sql.replaceAll(/\s+/g, " ");
 }
-//# sourceMappingURL=statement-cache.js.map
+export {
+  StatementCache
+};
+//# sourceMappingURL=statement-cache.js.map

package/out/zqlite/src/internal/statement-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"statement-cache.js","sourceRoot":"","sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"statement-cache.js","sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Database, Statement} from '../db.ts';\n\nexport type CachedStatementMap = Map<string, Statement[]>;\nexport type CachedStatement = {\n  sql: string;\n  statement: Statement;\n};\n/**\n * SQLite statement preparation isn't cheap as it involves evaluating possible\n * query plans and picking the best one (in addition to parsing the SQL).\n *\n * This statement cache prevents the need to re-prepare the same statement\n * multiple times.\n *\n * One extra wrinkle is that a single statement cannot be used by multiple\n * callers at the same time. As in, we can't `iterate` the same statement\n * many times concurrently.\n *\n * Given that, statements are removed from the cache while in use.\n * - `get` removes the statement from the cache\n * - `return` adds it back.\n *\n * If a request for the same sql is made while a\n * statement is gotten, a new statement will be prepared.\n * Both statements can be returned to the cache even though they both\n * serve the same SQL. Having both copies returned to the cache allows\n * the cache to serve multiple callers concurrently in the future.\n *\n * It is not an error to fail to call `return` on a statement.\n * Failing to call return will only prevent the statement from being reused\n * by other callers. It will not cause a resource leak.\n */\nexport class StatementCache {\n  #cache: CachedStatementMap = new Map<string, Statement[]>();\n  readonly #db: Database;\n  #size: number = 0;\n\n  /**\n   * The db connection used to prepare the statement.\n   * It is an error to use a statement prepared on one connection with another connection.\n   * @param db\n   */\n  constructor(db: Database) {\n    this.#db = db;\n  }\n\n  // the number of statements in the cache\n  get size() {\n    return this.#size;\n  }\n\n  drop(n: number) {\n    assert(n >= 0, 'Cannot drop a negative number of items');\n    assert(n <= this.#size, 'Cannot drop more items than are in the cache');\n\n    let remaining = n;\n    for (const [sql, statements] of this.#cache.entries()) {\n      if (remaining >= statements.length) {\n        this.#cache.delete(sql);\n        remaining -= statements.length;\n        this.#size -= statements.length;\n      } else {\n        statements.splice(0, remaining);\n        this.#size -= remaining;\n        break;\n      }\n    }\n  }\n\n  /**\n   * Prepares a statement for the given sql unless one is already cached.\n   * If one is cached, it is removed from the cache and returned.\n   *\n   * Since `get` removes the item from the cache it is not an error to fail to call\n   * `return`. The gotten statement will be correctly garbage collected.\n   *\n   * When a gotten statement is not returned, future calls to\n   * `get` with the same `sql` will prepare a new statement.\n   *\n   * @param sql\n   * @returns\n   */\n  get(sql: string): CachedStatement {\n    sql = normalizeWhitespace(sql);\n    const statements = this.#cache.get(sql);\n    if (statements && statements.length > 0) {\n      const statement = statements.pop()!;\n      this.#size--;\n      if (statements.length === 0) {\n        this.#cache.delete(sql);\n      }\n      return {sql, statement};\n    }\n    const statement = this.#db.prepare(sql);\n    return {sql, statement};\n  }\n\n  /**\n   * Handles `get` and `return` for the caller by invoking them before\n   * and after the callback.\n   */\n  use<T>(sql: string, cb: (statement: CachedStatement) => T) {\n    const statement = this.get(sql);\n    try {\n      return cb(statement);\n    } finally {\n      this.return(statement);\n    }\n  }\n\n  /**\n   * Add a statement back to the cache so someone else can use it later.\n   * @param statement\n   */\n  return(statement: CachedStatement) {\n    const {sql} = statement;\n    if (!this.#cache.has(sql)) {\n      this.#cache.set(sql, []);\n    }\n    const statements = this.#cache.get(sql);\n    if (statements) {\n      statements.push(statement.statement);\n      this.#size++;\n    }\n  }\n}\n\nfunction normalizeWhitespace(sql: string) {\n  return sql.replaceAll(/\\s+/g, ' ');\n}\n"],"names":["statement"],"mappings":";AAiCO,MAAM,eAAe;AAAA,EAC1B,6BAAiC,IAAA;AAAA,EACxB;AAAA,EACT,QAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhB,YAAY,IAAc;AACxB,SAAK,MAAM;AAAA,EACb;AAAA;AAAA,EAGA,IAAI,OAAO;AACT,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,KAAK,GAAW;AACd,WAAO,KAAK,GAAG,wCAAwC;AACvD,WAAO,KAAK,KAAK,OAAO,8CAA8C;AAEtE,QAAI,YAAY;AAChB,eAAW,CAAC,KAAK,UAAU,KAAK,KAAK,OAAO,WAAW;AACrD,UAAI,aAAa,WAAW,QAAQ;AAClC,aAAK,OAAO,OAAO,GAAG;AACtB,qBAAa,WAAW;AACxB,aAAK,SAAS,WAAW;AAAA,MAC3B,OAAO;AACL,mBAAW,OAAO,GAAG,SAAS;AAC9B,aAAK,SAAS;AACd;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,IAAI,KAA8B;AAChC,UAAM,oBAAoB,GAAG;AAC7B,UAAM,aAAa,KAAK,OAAO,IAAI,GAAG;AACtC,QAAI,cAAc,WAAW,SAAS,GAAG;AACvC,YAAMA,aAAY,WAAW,IAAA;AAC7B,WAAK;AACL,UAAI,WAAW,WAAW,GAAG;AAC3B,aAAK,OAAO,OAAO,GAAG;AAAA,MACxB;AACA,aAAO,EAAC,KAAK,WAAAA,WAAAA;AAAAA,IACf;AACA,UAAM,YAAY,KAAK,IAAI,QAAQ,GAAG;AACtC,WAAO,EAAC,KAAK,UAAA;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAO,KAAa,IAAuC;AACzD,UAAM,YAAY,KAAK,IAAI,GAAG;AAC9B,QAAI;AACF,aAAO,GAAG,SAAS;AAAA,IACrB,UAAA;AACE,WAAK,OAAO,SAAS;AAAA,IACvB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAO,WAA4B;AACjC,UAAM,EAAC,QAAO;AACd,QAAI,CAAC,KAAK,OAAO,IAAI,GAAG,GAAG;AACzB,WAAK,OAAO,IAAI,KAAK,CAAA,CAAE;AAAA,IACzB;AACA,UAAM,aAAa,KAAK,OAAO,IAAI,GAAG;AACtC,QAAI,YAAY;AACd,iBAAW,KAAK,UAAU,SAAS;AACnC,WAAK;AAAA,IACP;AAAA,EACF;AACF;AAEA,SAAS,oBAAoB,KAAa;AACxC,SAAO,IAAI,WAAW,QAAQ,GAAG;AACnC;"}

package/out/zqlite/src/query-builder.js

@@ -1,162 +1,191 @@
 import { sql } from "./internal/sql.js";
-export function buildSelectQuery(tableName, columns, constraint, filters, order, reverse, start) {
-    let query = sql `SELECT ${sql.join(Object.keys(columns).map(c => sql.ident(c)), sql `,`)} FROM ${sql.ident(tableName)}`;
-    const constraints = constraintsToSQL(constraint, columns);
-    if (start) {
-        constraints.push(gatherStartConstraints(start, reverse, order, columns));
-    }
-    if (filters) {
-        constraints.push(filtersToSQL(filters));
-    }
-    if (constraints.length > 0) {
-        query = sql `${query} WHERE ${sql.join(constraints, sql ` AND `)}`;
-    }
-    return sql `${query} ${orderByToSQL(order, !!reverse)}`;
+function buildSelectQuery(tableName, columns, constraint, filters, order, reverse, start) {
+  let query = sql`SELECT ${sql.join(
+    Object.keys(columns).map((c) => sql.ident(c)),
+    sql`,`
+  )} FROM ${sql.ident(tableName)}`;
+  const constraints = constraintsToSQL(constraint, columns);
+  if (start) {
+    constraints.push(gatherStartConstraints(start, reverse, order, columns));
+  }
+  if (filters) {
+    constraints.push(filtersToSQL(filters));
+  }
+  if (constraints.length > 0) {
+    query = sql`${query} WHERE ${sql.join(constraints, sql` AND `)}`;
+  }
+  return sql`${query} ${orderByToSQL(order, !!reverse)}`;
 }
-export function constraintsToSQL(constraint, columns) {
-    if (!constraint) {
-        return [];
-    }
-    const constraints = [];
-    for (const [key, value] of Object.entries(constraint)) {
-        constraints.push(sql `${sql.ident(key)} = ${toSQLiteType(value, columns[key].type)}`);
-    }
-    return constraints;
+function constraintsToSQL(constraint, columns) {
+  if (!constraint) {
+    return [];
+  }
+  const constraints = [];
+  for (const [key, value] of Object.entries(constraint)) {
+    constraints.push(
+      sql`${sql.ident(key)} = ${toSQLiteType(value, columns[key].type)}`
+    );
+  }
+  return constraints;
 }
-export function orderByToSQL(order, reverse) {
-    if (reverse) {
-        return sql `ORDER BY ${sql.join(order.map(s => sql `${sql.ident(s[0])} ${sql.__dangerous__rawValue(s[1] === 'asc' ? 'desc' : 'asc')}`), sql `, `)}`;
-    }
-    else {
-        return sql `ORDER BY ${sql.join(order.map(s => sql `${sql.ident(s[0])} ${sql.__dangerous__rawValue(s[1])}`), sql `, `)}`;
-    }
+function orderByToSQL(order, reverse) {
+  if (reverse) {
+    return sql`ORDER BY ${sql.join(
+      order.map(
+        (s) => sql`${sql.ident(s[0])} ${sql.__dangerous__rawValue(
+          s[1] === "asc" ? "desc" : "asc"
+        )}`
+      ),
+      sql`, `
+    )}`;
+  } else {
+    return sql`ORDER BY ${sql.join(
+      order.map(
+        (s) => sql`${sql.ident(s[0])} ${sql.__dangerous__rawValue(s[1])}`
+      ),
+      sql`, `
+    )}`;
+  }
 }
-/**
- * Converts filters (conditions) to SQL WHERE clause.
- * This applies all filters present in the AST for a query to the source.
- */
-export function filtersToSQL(filters) {
-    switch (filters.type) {
-        case 'simple':
-            return simpleConditionToSQL(filters);
-        case 'and':
-            return filters.conditions.length > 0
-                ? sql `(${sql.join(filters.conditions.map(condition => filtersToSQL(condition)), sql ` AND `)})`
-                : sql `TRUE`;
-        case 'or':
-            return filters.conditions.length > 0
-                ? sql `(${sql.join(filters.conditions.map(condition => filtersToSQL(condition)), sql ` OR `)})`
-                : sql `FALSE`;
-    }
+function filtersToSQL(filters) {
+  switch (filters.type) {
+    case "simple":
+      return simpleConditionToSQL(filters);
+    case "and":
+      return filters.conditions.length > 0 ? sql`(${sql.join(
+        filters.conditions.map(
+          (condition) => filtersToSQL(condition)
+        ),
+        sql` AND `
+      )})` : sql`TRUE`;
+    case "or":
+      return filters.conditions.length > 0 ? sql`(${sql.join(
+        filters.conditions.map(
+          (condition) => filtersToSQL(condition)
+        ),
+        sql` OR `
+      )})` : sql`FALSE`;
+  }
 }
 function simpleConditionToSQL(filter) {
-    const { op } = filter;
-    if (op === 'IN' || op === 'NOT IN') {
-        switch (filter.right.type) {
-            case 'literal':
-                return sql `${valuePositionToSQL(filter.left)} ${sql.__dangerous__rawValue(filter.op)} (SELECT value FROM json_each(${JSON.stringify(filter.right.value)}))`;
-            case 'static':
-                throw new Error('Static parameters must be replaced before conversion to SQL');
-        }
+  const { op } = filter;
+  if (op === "IN" || op === "NOT IN") {
+    switch (filter.right.type) {
+      case "literal":
+        return sql`${valuePositionToSQL(
+          filter.left
+        )} ${sql.__dangerous__rawValue(
+          filter.op
+        )} (SELECT value FROM json_each(${JSON.stringify(
+          filter.right.value
+        )}))`;
+      case "static":
+        throw new Error(
+          "Static parameters must be replaced before conversion to SQL"
+        );
     }
-    return sql `${valuePositionToSQL(filter.left)} ${sql.__dangerous__rawValue(
+  }
+  return sql`${valuePositionToSQL(filter.left)} ${sql.__dangerous__rawValue(
     // SQLite's LIKE operator is case-insensitive by default, so we
     // convert ILIKE to LIKE and NOT ILIKE to NOT LIKE.
-    filter.op === 'ILIKE'
-        ? 'LIKE'
-        : filter.op === 'NOT ILIKE'
-            ? 'NOT LIKE'
-            : filter.op)} ${valuePositionToSQL(filter.right)}`;
+    filter.op === "ILIKE" ? "LIKE" : filter.op === "NOT ILIKE" ? "NOT LIKE" : filter.op
+  )} ${valuePositionToSQL(filter.right)}`;
 }
 function valuePositionToSQL(value) {
-    switch (value.type) {
-        case 'column':
-            return sql.ident(value.name);
-        case 'literal':
-            return sql `${toSQLiteType(value.value, getJsType(value.value))}`;
-        case 'static':
-            throw new Error('Static parameters must be replaced before conversion to SQL');
-    }
+  switch (value.type) {
+    case "column":
+      return sql.ident(value.name);
+    case "literal":
+      return sql`${toSQLiteType(value.value, getJsType(value.value))}`;
+    case "static":
+      throw new Error(
+        "Static parameters must be replaced before conversion to SQL"
+      );
+  }
 }
 function getJsType(value) {
-    if (value === null) {
-        return 'null';
-    }
-    return typeof value === 'string'
-        ? 'string'
-        : typeof value === 'number'
-            ? 'number'
-            : typeof value === 'boolean'
-                ? 'boolean'
-                : 'json';
+  if (value === null) {
+    return "null";
+  }
+  return typeof value === "string" ? "string" : typeof value === "number" ? "number" : typeof value === "boolean" ? "boolean" : "json";
 }
-export function toSQLiteType(v, type) {
-    switch (type) {
-        case 'boolean':
-            return v === null ? null : v ? 1 : 0;
-        case 'number':
-        case 'string':
-        case 'null':
-            return v;
-        case 'json':
-            return JSON.stringify(v);
-    }
+function toSQLiteType(v, type) {
+  switch (type) {
+    case "boolean":
+      return v === null ? null : v ? 1 : 0;
+    case "number":
+    case "string":
+    case "null":
+      return v;
+    case "json":
+      return JSON.stringify(v);
+  }
 }
-/**
- * The ordering could be complex such as:
- * `ORDER BY a ASC, b DESC, c ASC`
- *
- * In those cases, we need to encode the constraints as various
- * `OR` clauses.
- *
- * E.g.,
- *
- * to get the row after (a = 1, b = 2, c = 3) would be:
- *
- * `WHERE a > 1 OR (a = 1 AND b < 2) OR (a = 1 AND b = 2 AND c > 3)`
- *
- * - after vs before flips the comparison operators.
- * - inclusive adds a final `OR` clause for the exact match.
- */
 function gatherStartConstraints(start, reverse, order, columnTypes) {
-    const constraints = [];
-    const { row: from, basis } = start;
-    for (let i = 0; i < order.length; i++) {
-        const group = [];
-        const [iField, iDirection] = order[i];
-        for (let j = 0; j <= i; j++) {
-            if (j === i) {
-                const constraintValue = toSQLiteType(from[iField], columnTypes[iField].type);
-                if (iDirection === 'asc') {
-                    if (!reverse) {
-                        group.push(sql `(${constraintValue} IS NULL OR ${sql.ident(iField)} > ${constraintValue})`);
-                    }
-                    else {
-                        reverse;
-                        group.push(sql `(${sql.ident(iField)} IS NULL OR ${sql.ident(iField)} < ${constraintValue})`);
-                    }
-                }
-                else {
-                    iDirection;
-                    if (!reverse) {
-                        group.push(sql `(${sql.ident(iField)} IS NULL OR ${sql.ident(iField)} < ${constraintValue})`);
-                    }
-                    else {
-                        reverse;
-                        group.push(sql `(${constraintValue} IS NULL OR ${sql.ident(iField)} > ${constraintValue})`);
-                    }
-                }
-            }
-            else {
-                const [jField] = order[j];
-                group.push(sql `${sql.ident(jField)} IS ${toSQLiteType(from[jField], columnTypes[jField].type)}`);
-            }
+  const constraints = [];
+  const { row: from, basis } = start;
+  for (let i = 0; i < order.length; i++) {
+    const group = [];
+    const [iField, iDirection] = order[i];
+    for (let j = 0; j <= i; j++) {
+      if (j === i) {
+        const constraintValue = toSQLiteType(
+          from[iField],
+          columnTypes[iField].type
+        );
+        if (iDirection === "asc") {
+          if (!reverse) {
+            group.push(
+              sql`(${constraintValue} IS NULL OR ${sql.ident(iField)} > ${constraintValue})`
+            );
+          } else {
+            group.push(
+              sql`(${sql.ident(iField)} IS NULL OR ${sql.ident(iField)} < ${constraintValue})`
+            );
+          }
+        } else {
+          if (!reverse) {
+            group.push(
+              sql`(${sql.ident(iField)} IS NULL OR ${sql.ident(iField)} < ${constraintValue})`
+            );
+          } else {
+            group.push(
+              sql`(${constraintValue} IS NULL OR ${sql.ident(iField)} > ${constraintValue})`
+            );
+          }
         }
-        constraints.push(sql `(${sql.join(group, sql ` AND `)})`);
-    }
-    if (basis === 'at') {
-        constraints.push(sql `(${sql.join(order.map(s => sql `${sql.ident(s[0])} IS ${toSQLiteType(from[s[0]], columnTypes[s[0]].type)}`), sql ` AND `)})`);
+      } else {
+        const [jField] = order[j];
+        group.push(
+          sql`${sql.ident(jField)} IS ${toSQLiteType(
+            from[jField],
+            columnTypes[jField].type
+          )}`
+        );
+      }
     }
-    return sql `(${sql.join(constraints, sql ` OR `)})`;
+    constraints.push(sql`(${sql.join(group, sql` AND `)})`);
+  }
+  if (basis === "at") {
+    constraints.push(
+      sql`(${sql.join(
+        order.map(
+          (s) => sql`${sql.ident(s[0])} IS ${toSQLiteType(
+            from[s[0]],
+            columnTypes[s[0]].type
+          )}`
+        ),
+        sql` AND `
+      )})`
+    );
+  }
+  return sql`(${sql.join(constraints, sql` OR `)})`;
 }
-//# sourceMappingURL=query-builder.js.map
+export {
+  buildSelectQuery,
+  constraintsToSQL,
+  filtersToSQL,
+  orderByToSQL,
+  toSQLiteType
+};
+//# sourceMappingURL=query-builder.js.map