@usebridger/storage-sqlite 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/index.d.mts

@@ -0,0 +1,16 @@
+import { StoragePort } from "@usebridger/core/adapter";
+//#region src/index.d.ts
+export interface SqliteOptions {
+  /**
+   * Arquivo do banco (criado, com as pastas, se não existir) ou `':memory:'` para um banco
+   * descartado no `close()`.
+   */
+  readonly path: string;
+}
+/**
+ * Abre o banco, liga o WAL e aplica as migrations do adapter. Lança se o arquivo não abre ou se
+ * foi gravado por uma versão mais nova do adapter.
+ */
+export declare function sqlite(options: SqliteOptions): StoragePort;
+//#endregion
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;iBAQiB;;;;;WAKN;;;;;;wBAOK,OAAO,SAAS,gBAAgB"}

package/dist/index.mjs

@@ -0,0 +1,373 @@
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { randomUUID } from "node:crypto";
+import { StorageClosedError, normalizeDocument, normalizeIndexes, normalizeQuery, normalizeWhere } from "@usebridger/core/adapter";
+//#region src/schema.ts
+const MIGRATIONS = [`
+  CREATE TABLE kv (
+    namespace TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    PRIMARY KEY (namespace, key)
+  ) WITHOUT ROWID;
+
+  CREATE TABLE documents (
+    seq INTEGER PRIMARY KEY,
+    namespace TEXT NOT NULL,
+    collection TEXT NOT NULL,
+    id TEXT NOT NULL,
+    doc TEXT NOT NULL,
+    UNIQUE (namespace, collection, id)
+  );
+
+  CREATE TABLE auth_creds (
+    session TEXT PRIMARY KEY,
+    creds TEXT NOT NULL
+  ) WITHOUT ROWID;
+
+  CREATE TABLE auth_keys (
+    session TEXT NOT NULL,
+    type TEXT NOT NULL,
+    id TEXT NOT NULL,
+    value TEXT NOT NULL,
+    PRIMARY KEY (session, type, id)
+  ) WITHOUT ROWID;
+  `, `
+  CREATE TABLE leases (
+    name TEXT PRIMARY KEY,
+    owner TEXT NOT NULL,
+    expires_at INTEGER NOT NULL
+  ) WITHOUT ROWID;
+  `];
+/** Versão do schema que este adapter conhece (a do `PRAGMA user_version` depois do boot). */
+const SCHEMA_VERSION = MIGRATIONS.length;
+/** Roda `body` numa transação: tudo ou nada, mesmo se ele lançar. */
+function transaction(db, body) {
+	db.exec("BEGIN IMMEDIATE");
+	try {
+		const result = body();
+		db.exec("COMMIT");
+		return result;
+	} catch (error) {
+		db.exec("ROLLBACK");
+		throw error;
+	}
+}
+function migrate(db) {
+	const { user_version: current } = db.prepare("PRAGMA user_version").get();
+	if (current > SCHEMA_VERSION) throw new Error(`storage-sqlite: o banco está no schema ${current}, mais novo que o deste adapter (${SCHEMA_VERSION}). Atualize o @usebridger/storage-sqlite.`);
+	for (let version = current; version < SCHEMA_VERSION; version++) transaction(db, () => {
+		db.exec(MIGRATIONS[version]);
+		db.exec(`PRAGMA user_version = ${version + 1}`);
+	});
+}
+function isFilePath(path) {
+	return path !== "" && path !== ":memory:" && !path.startsWith("file:");
+}
+/** Abre (ou cria) o banco, liga o WAL e aplica as migrations pendentes. */
+function openDatabase(path) {
+	if (isFilePath(path)) mkdirSync(dirname(path), { recursive: true });
+	const db = new DatabaseSync(path);
+	try {
+		db.exec("PRAGMA journal_mode = WAL");
+		db.exec("PRAGMA synchronous = NORMAL");
+		db.exec("PRAGMA busy_timeout = 5000");
+		migrate(db);
+		return db;
+	} catch (error) {
+		db.close();
+		throw error;
+	}
+}
+//#endregion
+//#region src/sql.ts
+/** Expressão de um campo do documento. O índice declarado usa exatamente esta expressão. */
+function fieldValueSql(field) {
+	return `json_extract(doc, '$.${field}')`;
+}
+function fieldSql(field) {
+	if (field === "id") return {
+		value: "id",
+		type: "'text'"
+	};
+	return {
+		value: fieldValueSql(field),
+		type: `json_type(doc, '$.${field}')`
+	};
+}
+const NUMBER = (type) => `(${type} IS 'integer' OR ${type} IS 'real')`;
+function equals({ value, type }, operand) {
+	if (operand === null) return {
+		sql: `${value} IS NULL`,
+		params: []
+	};
+	if (typeof operand === "boolean") return {
+		sql: `${type} IS '${operand}'`,
+		params: []
+	};
+	if (typeof operand === "number") return {
+		sql: `(${NUMBER(type)} AND ${value} IS ?)`,
+		params: [operand]
+	};
+	return {
+		sql: `(${type} IS 'text' AND ${value} IS ?)`,
+		params: [operand]
+	};
+}
+const COMPARISON = {
+	gt: ">",
+	gte: ">=",
+	lt: "<",
+	lte: "<="
+};
+function condition(entry) {
+	const field = fieldSql(entry.field);
+	switch (entry.op) {
+		case "eq": return equals(field, entry.value);
+		case "ne": {
+			const eq = equals(field, entry.value);
+			return {
+				sql: `NOT ${eq.sql}`,
+				params: eq.params
+			};
+		}
+		case "in": {
+			if (entry.value.length === 0) return {
+				sql: "0",
+				params: []
+			};
+			const items = entry.value.map((operand) => equals(field, operand));
+			return {
+				sql: `(${items.map((item) => item.sql).join(" OR ")})`,
+				params: items.flatMap((item) => item.params)
+			};
+		}
+		default: return {
+			sql: `(${typeof entry.value === "number" ? NUMBER(field.type) : `${field.type} IS 'text'`} AND ${field.value} ${COMPARISON[entry.op]} ?)`,
+			params: [entry.value]
+		};
+	}
+}
+/** Condições combinadas com E; lista vazia casa com tudo. */
+function whereSql(conditions) {
+	if (conditions.length === 0) return {
+		sql: "1",
+		params: []
+	};
+	const parts = conditions.map(condition);
+	return {
+		sql: parts.map((part) => part.sql).join(" AND "),
+		params: parts.flatMap((part) => part.params)
+	};
+}
+/**
+* Ordenação do contrato: primeiro a classe de tipo (null/ausente < booleano < número < texto <
+* array/objeto), depois o valor (arrays e objetos empatam), e o empate cai no `seq` — sempre
+* crescente, também em `desc`.
+*/
+function orderBySql(sorts) {
+	return [...sorts.flatMap(({ field, direction }) => {
+		const { value, type } = fieldSql(field);
+		const dir = direction === "asc" ? "ASC" : "DESC";
+		const rank = `CASE WHEN ${value} IS NULL THEN 0 WHEN ${type} IN ('true', 'false') THEN 1 WHEN ${type} IN ('integer', 'real') THEN 2 WHEN ${type} IS 'text' THEN 3 ELSE 4 END`;
+		const comparable = `CASE WHEN ${type} IN ('array', 'object') THEN NULL ELSE ${value} END`;
+		return [`${rank} ${dir}`, `${comparable} ${dir}`];
+	}), "seq ASC"].join(", ");
+}
+//#endregion
+//#region src/storage.ts
+function serialize(value) {
+	const text = JSON.stringify(value);
+	if (text === void 0) throw new TypeError("Valor não serializável em JSON.");
+	return text;
+}
+function parse(text) {
+	return JSON.parse(text);
+}
+/** StoragePort sobre `db`, que já deve estar aberto e migrado. Fecha o banco no `close()`. */
+function createSqliteStorage(db) {
+	let closed = false;
+	const statements = /* @__PURE__ */ new Map();
+	const indexes = /* @__PURE__ */ new Set();
+	function ensureOpen() {
+		if (closed) throw new StorageClosedError();
+	}
+	function statement(sql) {
+		let prepared = statements.get(sql);
+		if (prepared === void 0) {
+			prepared = db.prepare(sql);
+			statements.set(sql, prepared);
+		}
+		return prepared;
+	}
+	function ensureIndex(field) {
+		if (indexes.has(field)) return;
+		const name = `documents_field_${Buffer.from(field).toString("hex")}`;
+		db.exec(`CREATE INDEX IF NOT EXISTS ${name} ON documents (namespace, collection, ${fieldValueSql(field)})`);
+		indexes.add(field);
+	}
+	function createKv(namespace) {
+		return {
+			async get(key) {
+				ensureOpen();
+				const row = statement("SELECT value FROM kv WHERE namespace = ? AND key = ?").get(namespace, key);
+				return row === void 0 ? void 0 : parse(row.value);
+			},
+			async set(key, value) {
+				ensureOpen();
+				statement("INSERT INTO kv (namespace, key, value) VALUES (?, ?, ?) ON CONFLICT (namespace, key) DO UPDATE SET value = excluded.value").run(namespace, key, serialize(value));
+			},
+			async delete(key) {
+				ensureOpen();
+				const { changes } = statement("DELETE FROM kv WHERE namespace = ? AND key = ?").run(namespace, key);
+				return Number(changes) > 0;
+			}
+		};
+	}
+	function createCollection(namespace, name, fields) {
+		function prepare() {
+			ensureOpen();
+			for (const field of fields) ensureIndex(field);
+		}
+		function targetSql(target) {
+			if (typeof target === "string") return {
+				sql: "id = ?",
+				params: [target]
+			};
+			return whereSql(normalizeWhere(target));
+		}
+		return {
+			async insert(document) {
+				prepare();
+				const text = serialize(normalizeDocument(document));
+				const id = randomUUID();
+				statement("INSERT INTO documents (namespace, collection, id, doc) VALUES (?, ?, ?, ?)").run(namespace, name, id, text);
+				return id;
+			},
+			async get(id) {
+				prepare();
+				const row = statement("SELECT doc FROM documents WHERE namespace = ? AND collection = ? AND id = ?").get(namespace, name, id);
+				return row === void 0 ? void 0 : {
+					...parse(row.doc),
+					id
+				};
+			},
+			async find(query) {
+				prepare();
+				const { where, orderBy, limit, offset } = normalizeQuery(query);
+				const filter = whereSql(where);
+				return db.prepare(`SELECT id, doc FROM documents WHERE namespace = ? AND collection = ? AND ${filter.sql} ORDER BY ${orderBySql(orderBy)} LIMIT ? OFFSET ?`).all(namespace, name, ...filter.params, limit ?? -1, offset).map((row) => ({
+					...parse(row.doc),
+					id: row.id
+				}));
+			},
+			async update(target, patch) {
+				prepare();
+				const changes = normalizeDocument(patch);
+				const filter = targetSql(target);
+				return transaction(db, () => {
+					const rows = db.prepare("SELECT seq, doc FROM documents WHERE namespace = ? AND collection = ? AND " + filter.sql).all(namespace, name, ...filter.params);
+					const write = statement("UPDATE documents SET doc = ? WHERE seq = ?");
+					for (const row of rows) write.run(serialize({
+						...parse(row.doc),
+						...changes
+					}), row.seq);
+					return rows.length;
+				});
+			},
+			async delete(target) {
+				prepare();
+				const filter = targetSql(target);
+				const { changes } = db.prepare(`DELETE FROM documents WHERE namespace = ? AND collection = ? AND ${filter.sql}`).run(namespace, name, ...filter.params);
+				return Number(changes);
+			}
+		};
+	}
+	function createPluginStorage(namespace) {
+		return {
+			kv: createKv(namespace),
+			collection(name, options) {
+				return createCollection(namespace, name, normalizeIndexes(options));
+			}
+		};
+	}
+	function createAuthState(session) {
+		return {
+			async getCreds() {
+				ensureOpen();
+				const row = statement("SELECT creds FROM auth_creds WHERE session = ?").get(session);
+				return row === void 0 ? void 0 : parse(row.creds);
+			},
+			async setCreds(creds) {
+				ensureOpen();
+				statement("INSERT INTO auth_creds (session, creds) VALUES (?, ?) ON CONFLICT (session) DO UPDATE SET creds = excluded.creds").run(session, serialize(creds));
+			},
+			async getKeys(type, ids) {
+				ensureOpen();
+				const rows = statement("SELECT id, value FROM auth_keys WHERE session = ? AND type = ? AND id IN (SELECT value FROM json_each(?))").all(session, type, JSON.stringify(ids));
+				const result = {};
+				for (const row of rows) result[row.id] = parse(row.value);
+				return result;
+			},
+			async setKeys(data) {
+				ensureOpen();
+				const entries = Object.entries(data).flatMap(([type, values]) => Object.entries(values).map(([id, value]) => [
+					type,
+					id,
+					value === null ? null : serialize(value)
+				]));
+				const write = statement("INSERT INTO auth_keys (session, type, id, value) VALUES (?, ?, ?, ?) ON CONFLICT (session, type, id) DO UPDATE SET value = excluded.value");
+				const remove = statement("DELETE FROM auth_keys WHERE session = ? AND type = ? AND id = ?");
+				transaction(db, () => {
+					for (const [type, id, text] of entries) if (text === null) remove.run(session, type, id);
+					else write.run(session, type, id, text);
+				});
+			},
+			async clear() {
+				ensureOpen();
+				transaction(db, () => {
+					statement("DELETE FROM auth_creds WHERE session = ?").run(session);
+					statement("DELETE FROM auth_keys WHERE session = ?").run(session);
+				});
+			}
+		};
+	}
+	return {
+		forNamespace(namespace) {
+			return createPluginStorage(namespace);
+		},
+		authState(session) {
+			return createAuthState(session);
+		},
+		async acquireLease(name, owner, ttlMs) {
+			ensureOpen();
+			const now = Date.now();
+			const { changes } = statement("INSERT INTO leases (name, owner, expires_at) VALUES (?, ?, ?) ON CONFLICT (name) DO UPDATE SET owner = excluded.owner, expires_at = excluded.expires_at WHERE leases.owner = excluded.owner OR leases.expires_at <= ?").run(name, owner, now + ttlMs, now);
+			return Number(changes) > 0;
+		},
+		async releaseLease(name, owner) {
+			ensureOpen();
+			statement("DELETE FROM leases WHERE name = ? AND owner = ?").run(name, owner);
+		},
+		async close() {
+			if (closed) return;
+			closed = true;
+			statements.clear();
+			db.close();
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+/**
+* Abre o banco, liga o WAL e aplica as migrations do adapter. Lança se o arquivo não abre ou se
+* foi gravado por uma versão mais nova do adapter.
+*/
+function sqlite(options) {
+	return createSqliteStorage(openDatabase(options.path));
+}
+//#endregion
+export { sqlite };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/schema.ts","../src/sql.ts","../src/storage.ts","../src/index.ts"],"sourcesContent":["// Abertura do banco e migrations internas do adapter. O schema é do adapter, não dos plugins\n// (ADR 0015): plugin nenhum cria tabela, então a versão do schema é uma só, guardada no\n// `PRAGMA user_version`, e cada migration roda uma vez, numa transação, no boot.\n\nimport { mkdirSync } from 'node:fs';\nimport { dirname } from 'node:path';\nimport { DatabaseSync } from 'node:sqlite';\n\n// Namespace, coleção e chave em colunas separadas: concatenar (\"ns:chave\") colidiria. O `seq`\n// é a ordem de inserção do contrato (desempate da ordenação); como é a rowid, um update não o\n// muda. Só se acrescenta migration ao fim da lista, nunca se edita uma que já saiu.\nconst MIGRATIONS: readonly string[] = [\n  `\n  CREATE TABLE kv (\n    namespace TEXT NOT NULL,\n    key TEXT NOT NULL,\n    value TEXT NOT NULL,\n    PRIMARY KEY (namespace, key)\n  ) WITHOUT ROWID;\n\n  CREATE TABLE documents (\n    seq INTEGER PRIMARY KEY,\n    namespace TEXT NOT NULL,\n    collection TEXT NOT NULL,\n    id TEXT NOT NULL,\n    doc TEXT NOT NULL,\n    UNIQUE (namespace, collection, id)\n  );\n\n  CREATE TABLE auth_creds (\n    session TEXT PRIMARY KEY,\n    creds TEXT NOT NULL\n  ) WITHOUT ROWID;\n\n  CREATE TABLE auth_keys (\n    session TEXT NOT NULL,\n    type TEXT NOT NULL,\n    id TEXT NOT NULL,\n    value TEXT NOT NULL,\n    PRIMARY KEY (session, type, id)\n  ) WITHOUT ROWID;\n  `,\n  // Travas com validade (ADR 0074). `expires_at` em ms desde a época, pelo relógio do processo:\n  // quem divide um arquivo SQLite está na mesma máquina.\n  `\n  CREATE TABLE leases (\n    name TEXT PRIMARY KEY,\n    owner TEXT NOT NULL,\n    expires_at INTEGER NOT NULL\n  ) WITHOUT ROWID;\n  `,\n];\n\n/** Versão do schema que este adapter conhece (a do `PRAGMA user_version` depois do boot). */\nexport const SCHEMA_VERSION: number = MIGRATIONS.length;\n\n/** Roda `body` numa transação: tudo ou nada, mesmo se ele lançar. */\nexport function transaction<T>(db: DatabaseSync, body: () => T): T {\n  db.exec('BEGIN IMMEDIATE');\n  try {\n    const result = body();\n    db.exec('COMMIT');\n    return result;\n  } catch (error) {\n    db.exec('ROLLBACK');\n    throw error;\n  }\n}\n\nfunction migrate(db: DatabaseSync): void {\n  const { user_version: current } = db.prepare('PRAGMA user_version').get() as {\n    user_version: number;\n  };\n  // Banco gravado por uma versão mais nova do adapter: seguir poderia corromper o que ela\n  // gravou. Melhor parar no boot com a causa do que falhar depois numa consulta.\n  if (current > SCHEMA_VERSION) {\n    throw new Error(\n      `storage-sqlite: o banco está no schema ${current}, mais novo que o deste adapter ` +\n        `(${SCHEMA_VERSION}). Atualize o @usebridger/storage-sqlite.`,\n    );\n  }\n  for (let version = current; version < SCHEMA_VERSION; version++) {\n    transaction(db, () => {\n      db.exec(MIGRATIONS[version] as string);\n      db.exec(`PRAGMA user_version = ${version + 1}`);\n    });\n  }\n}\n\nfunction isFilePath(path: string): boolean {\n  return path !== '' && path !== ':memory:' && !path.startsWith('file:');\n}\n\n/** Abre (ou cria) o banco, liga o WAL e aplica as migrations pendentes. */\nexport function openDatabase(path: string): DatabaseSync {\n  // \"Clona e roda\": `data/bot.sqlite` funciona sem criar a pasta antes.\n  if (isFilePath(path)) mkdirSync(dirname(path), { recursive: true });\n  const db = new DatabaseSync(path);\n  try {\n    // WAL: leituras não esperam a escrita, e o `synchronous = NORMAL` continua seguro contra\n    // queda do processo (só uma queda do SO pode perder a última transação). O `busy_timeout`\n    // cobre outro processo (um script de manutenção) segurando o banco por um instante.\n    db.exec('PRAGMA journal_mode = WAL');\n    db.exec('PRAGMA synchronous = NORMAL');\n    db.exec('PRAGMA busy_timeout = 5000');\n    migrate(db);\n    return db;\n  } catch (error) {\n    db.close();\n    throw error;\n  }\n}\n","// Tradução da consulta canônica do core (`normalizeQuery`/`normalizeWhere`) para SQL sobre a\n// coluna `doc` (JSON em texto). O nome de campo já chega validado como identificador simples,\n// então vai interpolado no caminho JSON; valores sempre entram como parâmetro.\n//\n// Cada campo é um par: `value` (o que `json_extract` devolve) e `type` (o `json_type`). O tipo é\n// necessário porque `json_extract` devolve `true` como 1 e arrays/objetos como texto: sem ele,\n// `{ v: 1 }` casaria `true` e `{ v: '[1]' }` casaria um array. Toda comparação usa `IS`, que\n// nunca dá NULL: assim o `ne` pode ser o `NOT` exato do `eq`, inclusive para campo ausente.\n\nimport type { Scalar } from '@usebridger/core';\nimport type { NormalizedCondition, NormalizedSort } from '@usebridger/core/adapter';\n\nexport type SqlParam = string | number;\n\nexport interface SqlFragment {\n  readonly sql: string;\n  readonly params: readonly SqlParam[];\n}\n\ninterface FieldSql {\n  readonly value: string;\n  readonly type: string;\n}\n\n/** Expressão de um campo do documento. O índice declarado usa exatamente esta expressão. */\nexport function fieldValueSql(field: string): string {\n  return `json_extract(doc, '$.${field}')`;\n}\n\nfunction fieldSql(field: string): FieldSql {\n  // O `id` é coluna, sempre texto.\n  if (field === 'id') return { value: 'id', type: \"'text'\" };\n  return { value: fieldValueSql(field), type: `json_type(doc, '$.${field}')` };\n}\n\nconst NUMBER = (type: string): string => `(${type} IS 'integer' OR ${type} IS 'real')`;\n\nfunction equals({ value, type }: FieldSql, operand: Scalar): SqlFragment {\n  // JSON null e campo ausente: `json_extract` devolve NULL nos dois casos (array/objeto não).\n  if (operand === null) return { sql: `${value} IS NULL`, params: [] };\n  if (typeof operand === 'boolean') return { sql: `${type} IS '${operand}'`, params: [] };\n  if (typeof operand === 'number') {\n    return { sql: `(${NUMBER(type)} AND ${value} IS ?)`, params: [operand] };\n  }\n  return { sql: `(${type} IS 'text' AND ${value} IS ?)`, params: [operand] };\n}\n\nconst COMPARISON = { gt: '>', gte: '>=', lt: '<', lte: '<=' } as const;\n\nfunction condition(entry: NormalizedCondition): SqlFragment {\n  const field = fieldSql(entry.field);\n  switch (entry.op) {\n    case 'eq':\n      return equals(field, entry.value);\n    case 'ne': {\n      const eq = equals(field, entry.value);\n      return { sql: `NOT ${eq.sql}`, params: eq.params };\n    }\n    case 'in': {\n      if (entry.value.length === 0) return { sql: '0', params: [] };\n      const items = entry.value.map((operand) => equals(field, operand));\n      return {\n        sql: `(${items.map((item) => item.sql).join(' OR ')})`,\n        params: items.flatMap((item) => item.params),\n      };\n    }\n    default: {\n      // Só casa com o mesmo tipo do operando. Texto compara pela collation BINARY, que no banco\n      // UTF-8 é a ordem de code point do contrato.\n      const sameType =\n        typeof entry.value === 'number' ? NUMBER(field.type) : `${field.type} IS 'text'`;\n      return {\n        sql: `(${sameType} AND ${field.value} ${COMPARISON[entry.op]} ?)`,\n        params: [entry.value],\n      };\n    }\n  }\n}\n\n/** Condições combinadas com E; lista vazia casa com tudo. */\nexport function whereSql(conditions: readonly NormalizedCondition[]): SqlFragment {\n  if (conditions.length === 0) return { sql: '1', params: [] };\n  const parts = conditions.map(condition);\n  return {\n    sql: parts.map((part) => part.sql).join(' AND '),\n    params: parts.flatMap((part) => part.params),\n  };\n}\n\n/**\n * Ordenação do contrato: primeiro a classe de tipo (null/ausente < booleano < número < texto <\n * array/objeto), depois o valor (arrays e objetos empatam), e o empate cai no `seq` — sempre\n * crescente, também em `desc`.\n */\nexport function orderBySql(sorts: readonly NormalizedSort[]): string {\n  const terms = sorts.flatMap(({ field, direction }) => {\n    const { value, type } = fieldSql(field);\n    const dir = direction === 'asc' ? 'ASC' : 'DESC';\n    const rank =\n      `CASE WHEN ${value} IS NULL THEN 0 WHEN ${type} IN ('true', 'false') THEN 1 ` +\n      `WHEN ${type} IN ('integer', 'real') THEN 2 WHEN ${type} IS 'text' THEN 3 ELSE 4 END`;\n    const comparable = `CASE WHEN ${type} IN ('array', 'object') THEN NULL ELSE ${value} END`;\n    return [`${rank} ${dir}`, `${comparable} ${dir}`];\n  });\n  return [...terms, 'seq ASC'].join(', ');\n}\n","// StoragePort sobre um banco SQLite (`node:sqlite`, ADR 0051). A validação da entrada vem do\n// core (`normalize*`), então os erros saem iguais aos do adapter em memória; aqui fica só a\n// tradução para SQL. O driver é síncrono: cada método roda a consulta inteira dentro do\n// `async`, e qualquer erro (inclusive o `StorageClosedError`) chega como rejeição.\n\nimport { randomUUID } from 'node:crypto';\nimport type { DatabaseSync, StatementSync } from 'node:sqlite';\nimport type {\n  Collection,\n  CollectionOptions,\n  FindQuery,\n  JsonObject,\n  JsonValue,\n  KeyValueStore,\n  Patch,\n  PluginStorage,\n  Target,\n  WithId,\n} from '@usebridger/core';\nimport {\n  type AuthKeyData,\n  type AuthStateStore,\n  normalizeDocument,\n  normalizeIndexes,\n  normalizeQuery,\n  normalizeWhere,\n  StorageClosedError,\n  type StoragePort,\n} from '@usebridger/core/adapter';\nimport { transaction } from './schema.ts';\nimport { fieldValueSql, orderBySql, type SqlFragment, whereSql } from './sql.ts';\n\ntype Document = { readonly [key: string]: JsonValue };\n\nfunction serialize(value: unknown): string {\n  const text = JSON.stringify(value);\n  if (text === undefined) throw new TypeError('Valor não serializável em JSON.');\n  return text;\n}\n\nfunction parse<T>(text: string): T {\n  return JSON.parse(text) as T;\n}\n\n/** StoragePort sobre `db`, que já deve estar aberto e migrado. Fecha o banco no `close()`. */\nexport function createSqliteStorage(db: DatabaseSync): StoragePort {\n  let closed = false;\n  // Consultas fixas preparadas uma vez. As de `find`/`update`/`delete` por filtro mudam de\n  // forma a cada chamada e são preparadas na hora: cachear por texto cresceria sem limite.\n  const statements = new Map<string, StatementSync>();\n  // Índices já criados neste processo, para não repetir o DDL a cada operação.\n  const indexes = new Set<string>();\n\n  function ensureOpen(): void {\n    if (closed) throw new StorageClosedError();\n  }\n\n  function statement(sql: string): StatementSync {\n    let prepared = statements.get(sql);\n    if (prepared === undefined) {\n      prepared = db.prepare(sql);\n      statements.set(sql, prepared);\n    }\n    return prepared;\n  }\n\n  function ensureIndex(field: string): void {\n    if (indexes.has(field)) return;\n    // Um índice por campo, para todas as coleções: (namespace, collection, valor) serve à\n    // consulta de qualquer coleção que filtre ou ordene por ele. O nome vai em hexadecimal\n    // porque identificador SQL não diferencia maiúsculas (`fireAt` e `fireat` colidiriam).\n    const name = `documents_field_${Buffer.from(field).toString('hex')}`;\n    db.exec(\n      `CREATE INDEX IF NOT EXISTS ${name} ON documents (namespace, collection, ${fieldValueSql(field)})`,\n    );\n    indexes.add(field);\n  }\n\n  function createKv(namespace: string): KeyValueStore {\n    return {\n      async get<T extends JsonValue = JsonValue>(key: string): Promise<T | undefined> {\n        ensureOpen();\n        const row = statement('SELECT value FROM kv WHERE namespace = ? AND key = ?').get(\n          namespace,\n          key,\n        ) as { value: string } | undefined;\n        return row === undefined ? undefined : parse<T>(row.value);\n      },\n      async set(key: string, value: JsonValue): Promise<void> {\n        ensureOpen();\n        statement(\n          'INSERT INTO kv (namespace, key, value) VALUES (?, ?, ?) ' +\n            'ON CONFLICT (namespace, key) DO UPDATE SET value = excluded.value',\n        ).run(namespace, key, serialize(value));\n      },\n      async delete(key: string): Promise<boolean> {\n        ensureOpen();\n        const { changes } = statement('DELETE FROM kv WHERE namespace = ? AND key = ?').run(\n          namespace,\n          key,\n        );\n        return Number(changes) > 0;\n      },\n    };\n  }\n\n  function createCollection<T extends Document>(\n    namespace: string,\n    name: string,\n    fields: readonly string[],\n  ): Collection<T> {\n    function prepare(): void {\n      ensureOpen();\n      for (const field of fields) ensureIndex(field);\n    }\n\n    function targetSql(target: Target<T>): SqlFragment {\n      if (typeof target === 'string') return { sql: 'id = ?', params: [target] };\n      return whereSql(normalizeWhere(target));\n    }\n\n    return {\n      async insert(document: T): Promise<string> {\n        prepare();\n        const text = serialize(normalizeDocument(document));\n        const id = randomUUID();\n        statement('INSERT INTO documents (namespace, collection, id, doc) VALUES (?, ?, ?, ?)').run(\n          namespace,\n          name,\n          id,\n          text,\n        );\n        return id;\n      },\n      async get(id: string): Promise<WithId<T> | undefined> {\n        prepare();\n        const row = statement(\n          'SELECT doc FROM documents WHERE namespace = ? AND collection = ? AND id = ?',\n        ).get(namespace, name, id) as { doc: string } | undefined;\n        return row === undefined ? undefined : { ...parse<T>(row.doc), id };\n      },\n      async find(query?: FindQuery<T>): Promise<WithId<T>[]> {\n        prepare();\n        const { where, orderBy, limit, offset } = normalizeQuery(query);\n        const filter = whereSql(where);\n        // `LIMIT -1` é \"sem limite\" no SQLite; OFFSET exige um LIMIT antes.\n        const rows = db\n          .prepare(\n            'SELECT id, doc FROM documents WHERE namespace = ? AND collection = ? AND ' +\n              `${filter.sql} ORDER BY ${orderBySql(orderBy)} LIMIT ? OFFSET ?`,\n          )\n          .all(namespace, name, ...filter.params, limit ?? -1, offset) as {\n          id: string;\n          doc: string;\n        }[];\n        return rows.map((row) => ({ ...parse<T>(row.doc), id: row.id }));\n      },\n      async update(target: Target<T>, patch: Patch<T>): Promise<number> {\n        prepare();\n        const changes = normalizeDocument(patch);\n        const filter = targetSql(target);\n        // Merge raso em JS: o `json_patch` do SQLite mescla objetos aninhados e trata `null`\n        // como remoção (RFC 7396), o contrário do patch raso do contrato.\n        return transaction(db, () => {\n          const rows = db\n            .prepare(\n              'SELECT seq, doc FROM documents WHERE namespace = ? AND collection = ? AND ' +\n                filter.sql,\n            )\n            .all(namespace, name, ...filter.params) as { seq: number; doc: string }[];\n          const write = statement('UPDATE documents SET doc = ? WHERE seq = ?');\n          for (const row of rows) {\n            write.run(serialize({ ...parse<JsonObject>(row.doc), ...changes }), row.seq);\n          }\n          return rows.length;\n        });\n      },\n      async delete(target: Target<T>): Promise<number> {\n        prepare();\n        const filter = targetSql(target);\n        const { changes } = db\n          .prepare(`DELETE FROM documents WHERE namespace = ? AND collection = ? AND ${filter.sql}`)\n          .run(namespace, name, ...filter.params);\n        return Number(changes);\n      },\n    };\n  }\n\n  function createPluginStorage(namespace: string): PluginStorage {\n    return {\n      kv: createKv(namespace),\n      collection<T extends Document>(name: string, options?: CollectionOptions): Collection<T> {\n        // Valida na hora (o contrato lança aqui), mas só cria o índice na primeira operação:\n        // `collection()` é síncrono e não deve fazer I/O nem falhar por causa do banco.\n        return createCollection<T>(namespace, name, normalizeIndexes(options));\n      },\n    };\n  }\n\n  function createAuthState(session: string): AuthStateStore {\n    return {\n      async getCreds(): Promise<JsonValue | undefined> {\n        ensureOpen();\n        const row = statement('SELECT creds FROM auth_creds WHERE session = ?').get(session) as\n          | { creds: string }\n          | undefined;\n        return row === undefined ? undefined : parse(row.creds);\n      },\n      async setCreds(creds: JsonValue): Promise<void> {\n        ensureOpen();\n        statement(\n          'INSERT INTO auth_creds (session, creds) VALUES (?, ?) ' +\n            'ON CONFLICT (session) DO UPDATE SET creds = excluded.creds',\n        ).run(session, serialize(creds));\n      },\n      async getKeys(type: string, ids: readonly string[]): Promise<Record<string, JsonValue>> {\n        ensureOpen();\n        // A lista vai como um array JSON: o Baileys pede centenas de ids de uma vez, e um\n        // `IN (?, ?, ...)` por tamanho esbarraria no limite de parâmetros do SQLite.\n        const rows = statement(\n          'SELECT id, value FROM auth_keys WHERE session = ? AND type = ? ' +\n            'AND id IN (SELECT value FROM json_each(?))',\n        ).all(session, type, JSON.stringify(ids)) as { id: string; value: string }[];\n        const result: Record<string, JsonValue> = {};\n        for (const row of rows) result[row.id] = parse(row.value);\n        return result;\n      },\n      async setKeys(data: AuthKeyData): Promise<void> {\n        ensureOpen();\n        // Serializa o lote antes de abrir a transação: um valor inválido não chega a gravar nada.\n        const entries = Object.entries(data).flatMap(([type, values]) =>\n          Object.entries(values).map(\n            ([id, value]) => [type, id, value === null ? null : serialize(value)] as const,\n          ),\n        );\n        const write = statement(\n          'INSERT INTO auth_keys (session, type, id, value) VALUES (?, ?, ?, ?) ' +\n            'ON CONFLICT (session, type, id) DO UPDATE SET value = excluded.value',\n        );\n        const remove = statement('DELETE FROM auth_keys WHERE session = ? AND type = ? AND id = ?');\n        transaction(db, () => {\n          for (const [type, id, text] of entries) {\n            if (text === null) remove.run(session, type, id);\n            else write.run(session, type, id, text);\n          }\n        });\n      },\n      async clear(): Promise<void> {\n        ensureOpen();\n        transaction(db, () => {\n          statement('DELETE FROM auth_creds WHERE session = ?').run(session);\n          statement('DELETE FROM auth_keys WHERE session = ?').run(session);\n        });\n      },\n    };\n  }\n\n  return {\n    forNamespace(namespace: string): PluginStorage {\n      return createPluginStorage(namespace);\n    },\n    authState(session: string): AuthStateStore {\n      return createAuthState(session);\n    },\n    async acquireLease(name: string, owner: string, ttlMs: number): Promise<boolean> {\n      ensureOpen();\n      const now = Date.now();\n      // Um comando só, então atômico entre conexões: o upsert não toca a linha (0 mudanças) se\n      // ela é de outro dono e ainda vale.\n      const { changes } = statement(\n        'INSERT INTO leases (name, owner, expires_at) VALUES (?, ?, ?) ' +\n          'ON CONFLICT (name) DO UPDATE SET owner = excluded.owner, expires_at = excluded.expires_at ' +\n          'WHERE leases.owner = excluded.owner OR leases.expires_at <= ?',\n      ).run(name, owner, now + ttlMs, now);\n      return Number(changes) > 0;\n    },\n    async releaseLease(name: string, owner: string): Promise<void> {\n      ensureOpen();\n      statement('DELETE FROM leases WHERE name = ? AND owner = ?').run(name, owner);\n    },\n    async close(): Promise<void> {\n      if (closed) return;\n      closed = true;\n      statements.clear();\n      db.close();\n    },\n  };\n}\n","// Entry `@usebridger/storage-sqlite`: o adapter de storage padrão, que o app passa em\n// `createBot({ storage })`. Usa o `node:sqlite` do próprio Node (ADR 0051): nada de addon nativo\n// para compilar no `pnpm install`.\n\nimport type { StoragePort } from '@usebridger/core/adapter';\nimport { openDatabase } from './schema.ts';\nimport { createSqliteStorage } from './storage.ts';\n\nexport interface SqliteOptions {\n  /**\n   * Arquivo do banco (criado, com as pastas, se não existir) ou `':memory:'` para um banco\n   * descartado no `close()`.\n   */\n  readonly path: string;\n}\n\n/**\n * Abre o banco, liga o WAL e aplica as migrations do adapter. Lança se o arquivo não abre ou se\n * foi gravado por uma versão mais nova do adapter.\n */\nexport function sqlite(options: SqliteOptions): StoragePort {\n  return createSqliteStorage(openDatabase(options.path));\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@usebridger/storage-sqlite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Storage do Bridger em SQLite (node:sqlite), sem dependência nativa.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/murillous/usebridger.git",
+    "directory": "packages/storage-sqlite"
+  },
+  "homepage": "https://github.com/murillous/usebridger/tree/develop/packages/storage-sqlite/docs#readme",
+  "bugs": "https://github.com/murillous/usebridger/issues",
+  "type": "module",
+  "imports": {
+    "#*": "./src/*"
+  },
+  "exports": {
+    ".": {
+      "@usebridger/source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@usebridger/core": "^0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.