@rocicorp/zero 0.26.1 → 0.26.2-canary.1

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

@@ -1,45 +1,62 @@
 import { escapeSQLiteIdentifier } from "@databases/escape-identifier";
+//#region ../zqlite/src/internal/sql-inline.ts
+/**
+* Escapes a SQLite string value by doubling single quotes.
+* SQLite uses single quotes for string literals and doubles them for escaping.
+*/
 function escapeSQLiteString(str) {
-  return `'${str.replace(/'/g, "''")}'`;
+	return `'${str.replace(/'/g, "''")}'`;
 }
+/**
+* Formats a value for inline inclusion in SQL (not as a placeholder).
+*
+* WARNING: This should ONLY be used for cost estimation in the query planner,
+* not for user-facing queries. All production queries must use parameterized
+* statements to prevent SQL injection.
+*
+* @param value The value to inline into SQL
+* @returns SQL literal representation of the value
+*/
 function inlineValue(value) {
-  if (value === null) {
-    return "NULL";
-  }
-  if (typeof value === "string") {
-    return escapeSQLiteString(value);
-  }
-  if (typeof value === "number") {
-    return String(value);
-  }
-  if (typeof value === "boolean") {
-    return value ? "1" : "0";
-  }
-  if (Array.isArray(value)) {
-    return escapeSQLiteString(JSON.stringify(value));
-  }
-  return escapeSQLiteString(JSON.stringify(value));
+	if (value === null) return "NULL";
+	if (typeof value === "string") return escapeSQLiteString(value);
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "1" : "0";
+	if (Array.isArray(value)) return escapeSQLiteString(JSON.stringify(value));
+	return escapeSQLiteString(JSON.stringify(value));
 }
-const sqliteInlineFormat = {
-  escapeIdentifier: (str) => escapeSQLiteIdentifier(str),
-  formatValue: (value) => (
-    // undefined is our signal to use a placeholder
-    // IMPORTANT. Changing this will break the planner as it will assume `NULL`
-    // for constraints!
-    value === void 0 ? {
-      placeholder: "?",
-      value
-    } : {
-      placeholder: inlineValue(value),
-      value: void 0
-      // No binding needed since value is inlined
-    }
-  )
+/**
+* Format configuration that inlines values directly into SQL instead of using placeholders.
+*
+* This is used ONLY for cost estimation in the SQLite cost model, where we want SQLite's
+* query planner to see actual values to make better decisions about index usage and query plans.
+*
+* Production code must use the standard parameterized format from sql.ts.
+*/
+var sqliteInlineFormat = {
+	escapeIdentifier: (str) => escapeSQLiteIdentifier(str),
+	formatValue: (value) => value === void 0 ? {
+		placeholder: "?",
+		value
+	} : {
+		placeholder: inlineValue(value),
+		value: void 0
+	}
 };
+/**
+* Compiles a SQL query with values inlined directly into the SQL string.
+*
+* WARNING: This should ONLY be used for cost estimation in the query planner.
+* Never use this for user-facing queries - always use the standard `compile()`
+* function from sql.ts which uses parameterized queries.
+*
+* @param sql The SQL query to compile
+* @returns SQL string with values inlined
+*/
 function compileInline(sql) {
-  return sql.format(sqliteInlineFormat).text;
+	return sql.format(sqliteInlineFormat).text;
 }
-export {
-  compileInline
-};
-//# sourceMappingURL=sql-inline.js.map
+//#endregion
+export { compileInline };
+
+//# sourceMappingURL=sql-inline.js.map

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

@@ -1 +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;"}
+{"version":3,"file":"sql-inline.js","names":[],"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"],"mappings":";;;;;;AAQA,SAAS,mBAAmB,KAAqB;AAC/C,QAAO,IAAI,IAAI,QAAQ,MAAM,KAAK,CAAC;;;;;;;;;;;;AAarC,SAAS,YAAY,OAAwB;AAC3C,KAAI,UAAU,KACZ,QAAO;AAET,KAAI,OAAO,UAAU,SACnB,QAAO,mBAAmB,MAAM;AAElC,KAAI,OAAO,UAAU,SACnB,QAAO,OAAO,MAAM;AAEtB,KAAI,OAAO,UAAU,UAEnB,QAAO,QAAQ,MAAM;AAEvB,KAAI,MAAM,QAAQ,MAAM,CAEtB,QAAO,mBAAmB,KAAK,UAAU,MAAM,CAAC;AAGlD,QAAO,mBAAmB,KAAK,UAAU,MAAM,CAAC;;;;;;;;;;AAWlD,IAAM,qBAAmC;CACvC,mBAAkB,QAAO,uBAAuB,IAAI;CACpD,cAAa,UAIX,UAAU,KAAA,IACN;EACE,aAAa;EACb;EACD,GACD;EACE,aAAa,YAAY,MAAM;EAC/B,OAAO,KAAA;EACR;CACR;;;;;;;;;;;AAYD,SAAgB,cAAc,KAAuB;AACnD,QAAO,IAAI,OAAO,mBAAmB,CAAC"}

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

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

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

@@ -1 +1 @@
-{"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;"}
+{"version":3,"file":"sql.js","names":[],"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"],"mappings":";;;AAIA,IAAM,eAA6B;CACjC,mBAAkB,QAAO,uBAAuB,IAAI;CACpD,cAAa,WAAU;EAAC,aAAa;EAAK;EAAM;CACjD;AAED,SAAgB,QAAQ,KAAuB;AAC7C,QAAO,IAAI,OAAO,aAAa,CAAC;;AAGlC,SAAgB,OAAO,KAAe;AACpC,QAAO,IAAI,OAAO,aAAa;;AAGjC,IAAa,MAAM,QAAQ"}

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

@@ -1,95 +1,120 @@
 import { assert } from "../../../shared/src/asserts.js";
-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;
-      }
-    }
-  }
-  /**
-   * 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 };
-    }
-    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);
-    }
-  }
-  /**
-   * 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++;
-    }
-  }
-}
+//#region ../zqlite/src/internal/statement-cache.ts
+/**
+* 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.
+*/
+var StatementCache = class {
+	#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;
+	}
+	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;
+		}
+	}
+	/**
+	* 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
+		};
+	}
+	/**
+	* 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++;
+		}
+	}
+};
 function normalizeWhitespace(sql) {
-  return sql.replaceAll(/\s+/g, " ");
+	return sql.replaceAll(/\s+/g, " ");
 }
-export {
-  StatementCache
-};
-//# sourceMappingURL=statement-cache.js.map
+//#endregion
+export { StatementCache };
+
+//# sourceMappingURL=statement-cache.js.map

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

@@ -1 +1 @@
-{"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;"}
+{"version":3,"file":"statement-cache.js","names":["#db","#size","#cache"],"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"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAa,iBAAb,MAA4B;CAC1B,yBAA6B,IAAI,KAA0B;CAC3D;CACA,QAAgB;;;;;;CAOhB,YAAY,IAAc;AACxB,QAAA,KAAW;;CAIb,IAAI,OAAO;AACT,SAAO,MAAA;;CAGT,KAAK,GAAW;AACd,SAAO,KAAK,GAAG,yCAAyC;AACxD,SAAO,KAAK,MAAA,MAAY,+CAA+C;EAEvE,IAAI,YAAY;AAChB,OAAK,MAAM,CAAC,KAAK,eAAe,MAAA,MAAY,SAAS,CACnD,KAAI,aAAa,WAAW,QAAQ;AAClC,SAAA,MAAY,OAAO,IAAI;AACvB,gBAAa,WAAW;AACxB,SAAA,QAAc,WAAW;SACpB;AACL,cAAW,OAAO,GAAG,UAAU;AAC/B,SAAA,QAAc;AACd;;;;;;;;;;;;;;;;CAkBN,IAAI,KAA8B;AAChC,QAAM,oBAAoB,IAAI;EAC9B,MAAM,aAAa,MAAA,MAAY,IAAI,IAAI;AACvC,MAAI,cAAc,WAAW,SAAS,GAAG;GACvC,MAAM,YAAY,WAAW,KAAK;AAClC,SAAA;AACA,OAAI,WAAW,WAAW,EACxB,OAAA,MAAY,OAAO,IAAI;AAEzB,UAAO;IAAC;IAAK;IAAU;;EAEzB,MAAM,YAAY,MAAA,GAAS,QAAQ,IAAI;AACvC,SAAO;GAAC;GAAK;GAAU;;;;;;CAOzB,IAAO,KAAa,IAAuC;EACzD,MAAM,YAAY,KAAK,IAAI,IAAI;AAC/B,MAAI;AACF,UAAO,GAAG,UAAU;YACZ;AACR,QAAK,OAAO,UAAU;;;;;;;CAQ1B,OAAO,WAA4B;EACjC,MAAM,EAAC,QAAO;AACd,MAAI,CAAC,MAAA,MAAY,IAAI,IAAI,CACvB,OAAA,MAAY,IAAI,KAAK,EAAE,CAAC;EAE1B,MAAM,aAAa,MAAA,MAAY,IAAI,IAAI;AACvC,MAAI,YAAY;AACd,cAAW,KAAK,UAAU,UAAU;AACpC,SAAA;;;;AAKN,SAAS,oBAAoB,KAAa;AACxC,QAAO,IAAI,WAAW,QAAQ,IAAI"}

package/out/zqlite/src/mod.js

@@ -0,0 +1,5 @@
+import "../../zero-types/src/format.js";
+import "../../zql/src/query/query-impl.js";
+import "./db.js";
+import "./query-delegate.js";
+export {};