@camstack/core 0.1.14 → 0.1.16

package/dist/builtins/sqlite-storage/sqlite-settings.addon.js

@@ -1,421 +1,592 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/builtins/sqlite-storage/sqlite-settings.addon.ts
-var sqlite_settings_addon_exports = {};
-__export(sqlite_settings_addon_exports, {
-  SqliteSettingsAddon: () => SqliteSettingsAddon,
-  default: () => sqlite_settings_addon_default
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
 });
-module.exports = __toCommonJS(sqlite_settings_addon_exports);
-
-// src/builtins/sqlite-storage/sqlite-settings-backend.ts
-var import_better_sqlite3 = __toESM(require("better-sqlite3"));
-var import_node_crypto = require("crypto");
-var SqliteSettingsBackend = class {
-  constructor(dbPath, runtimeDefaults) {
-    this.dbPath = dbPath;
-    this.runtimeDefaults = runtimeDefaults ?? {};
-  }
-  db = null;
-  ensuredTables = /* @__PURE__ */ new Set();
-  structuredTables = /* @__PURE__ */ new Set();
-  runtimeDefaults;
-  async initialize() {
-    const dir = this.dbPath.substring(0, this.dbPath.lastIndexOf("/"));
-    if (dir) {
-      const fs = await import("fs");
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    this.db = new import_better_sqlite3.default(this.dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = ON");
-    const isEmpty = await this.isEmpty("system-settings");
-    if (isEmpty) {
-      await this.seedDefaults();
-    }
-  }
-  async shutdown() {
-    this.db?.close();
-    this.db = null;
-  }
-  // ---------------------------------------------------------------------------
-  // ISettingsBackend implementation
-  // ---------------------------------------------------------------------------
-  async get(collection, key) {
-    this.ensureCollectionTable(collection);
-    const row = this.getDb().prepare(`SELECT data FROM "${collection}" WHERE id = ?`).get(key);
-    if (!row) return void 0;
-    return JSON.parse(row.data);
-  }
-  async set(collection, key, value) {
-    this.ensureCollectionTable(collection);
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`).run(key, JSON.stringify(value));
-  }
-  async query(collection, filter) {
-    this.ensureCollectionTable(collection);
-    let sql = `SELECT id, data FROM "${collection}"`;
-    const params = [];
-    const whereClauses = [];
-    if (filter?.where) {
-      for (const [field, value] of Object.entries(filter.where)) {
-        if (field === "id") {
-          whereClauses.push("id = ?");
-          params.push(value);
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') = ?`);
-          params.push(typeof value === "object" ? JSON.stringify(value) : value);
-        }
-      }
-    }
-    if (filter?.whereIn) {
-      for (const [field, values] of Object.entries(filter.whereIn)) {
-        const placeholders = values.map(() => "?").join(", ");
-        if (field === "id") {
-          whereClauses.push(`id IN (${placeholders})`);
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') IN (${placeholders})`);
-        }
-        params.push(...values);
-      }
-    }
-    if (filter?.whereBetween) {
-      for (const [field, [low, high]] of Object.entries(filter.whereBetween)) {
-        if (field === "id") {
-          whereClauses.push("id BETWEEN ? AND ?");
-        } else {
-          whereClauses.push(`json_extract(data, '$.${field}') BETWEEN ? AND ?`);
-        }
-        params.push(low, high);
-      }
-    }
-    if (whereClauses.length > 0) {
-      sql += ` WHERE ${whereClauses.join(" AND ")}`;
-    }
-    if (filter?.orderBy) {
-      const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
-      if (filter.orderBy.field === "id") {
-        sql += ` ORDER BY id ${dir}`;
-      } else {
-        sql += ` ORDER BY json_extract(data, '$.${filter.orderBy.field}') ${dir}`;
-      }
-    }
-    if (filter?.limit) {
-      sql += ` LIMIT ?`;
-      params.push(filter.limit);
-    }
-    if (filter?.offset) {
-      sql += ` OFFSET ?`;
-      params.push(filter.offset);
-    }
-    const rows = this.getDb().prepare(sql).all(...params);
-    return rows.map((row) => ({
-      id: row.id,
-      data: JSON.parse(row.data)
-    }));
-  }
-  async insert(collection, record) {
-    this.ensureCollectionTable(collection);
-    const id = record.id || (0, import_node_crypto.randomUUID)();
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?)`).run(id, JSON.stringify(record.data));
-  }
-  async update(collection, id, data) {
-    this.ensureCollectionTable(collection);
-    this.getDb().prepare(`UPDATE "${collection}" SET data = ? WHERE id = ?`).run(JSON.stringify(data), id);
-  }
-  async delete(collection, key) {
-    this.ensureCollectionTable(collection);
-    this.getDb().prepare(`DELETE FROM "${collection}" WHERE id = ?`).run(key);
-  }
-  async count(collection, filter) {
-    this.ensureCollectionTable(collection);
-    if (!filter) {
-      const row = this.getDb().prepare(`SELECT COUNT(*) AS cnt FROM "${collection}"`).get();
-      return row?.cnt ?? 0;
-    }
-    const rows = await this.query(collection, { ...filter, limit: void 0, offset: void 0 });
-    return rows.length;
-  }
-  async isEmpty(collection) {
-    this.ensureCollectionTable(collection);
-    const row = this.getDb().prepare(`SELECT COUNT(*) AS cnt FROM "${collection}"`).get();
-    return (row?.cnt ?? 0) === 0;
-  }
-  // ---------------------------------------------------------------------------
-  // Legacy SettingsStore compatibility (used by ConfigManager.setSettingsStore)
-  // ---------------------------------------------------------------------------
-  /** Get a system setting by dot-notation key */
-  getSystem(key) {
-    this.ensureCollectionTable("system-settings");
-    const row = this.getDb().prepare('SELECT data FROM "system-settings" WHERE id = ?').get(key);
-    if (!row) return void 0;
-    return JSON.parse(row.data);
-  }
-  /** Set a system setting */
-  setSystem(key, value) {
-    this.ensureCollectionTable("system-settings");
-    this.getDb().prepare('INSERT INTO "system-settings" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data').run(key, JSON.stringify(value));
-  }
-  /** Get all system settings as flat key-value */
-  getAllSystem() {
-    this.ensureCollectionTable("system-settings");
-    const rows = this.getDb().prepare('SELECT id, data FROM "system-settings"').all();
-    return Object.fromEntries(rows.map((r) => [r.id, JSON.parse(r.data)]));
-  }
-  /** Get all settings for an addon */
-  getAllAddon(addonId) {
-    this.ensureCollectionTable("addon-settings");
-    const rows = this.getDb().prepare(`SELECT id, data FROM "addon-settings" WHERE json_extract(data, '$.addonId') = ?`).all(addonId);
-    if (rows.length === 0) return {};
-    const result = {};
-    for (const row of rows) {
-      const parsed = JSON.parse(row.data);
-      const key = row.id.startsWith(`${addonId}.`) ? row.id.slice(addonId.length + 1) : row.id;
-      result[key] = parsed.value ?? parsed;
-    }
-    return result;
-  }
-  /** Bulk-set all settings for an addon */
-  setAllAddon(addonId, config) {
-    this.ensureCollectionTable("addon-settings");
-    const db = this.getDb();
-    const deleteStmt = db.prepare(`DELETE FROM "addon-settings" WHERE id LIKE ? || '%'`);
-    const insertStmt = db.prepare('INSERT INTO "addon-settings" (id, data) VALUES (?, ?)');
-    db.transaction(() => {
-      deleteStmt.run(`${addonId}.`);
-      for (const [key, value] of Object.entries(config)) {
-        insertStmt.run(`${addonId}.${key}`, JSON.stringify({ addonId, key, value }));
-      }
-    })();
-  }
-  /** Get all settings for a provider */
-  getAllProvider(providerId) {
-    return this.getAllScoped("provider-settings", providerId);
-  }
-  /** Set a provider setting */
-  setProvider(providerId, key, value) {
-    this.setScopedKey("provider-settings", providerId, key, value);
-  }
-  /** Get all settings for a device */
-  getAllDevice(deviceId) {
-    return this.getAllScoped("device-settings", deviceId);
-  }
-  /** Set a device setting */
-  setDevice(deviceId, key, value) {
-    this.setScopedKey("device-settings", deviceId, key, value);
-  }
-  /** Seed system-settings with runtime defaults (first boot) */
-  async seedDefaults() {
-    this.ensureCollectionTable("system-settings");
-    const insert = this.getDb().prepare(
-      'INSERT OR IGNORE INTO "system-settings" (id, data) VALUES (?, ?)'
-    );
-    this.getDb().transaction(() => {
-      for (const [key, value] of Object.entries(this.runtimeDefaults)) {
-        insert.run(key, JSON.stringify(value));
-      }
-    })();
-  }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  getDb() {
-    if (!this.db) throw new Error("SqliteSettingsBackend not initialized \u2014 call initialize() first");
-    return this.db;
-  }
-  ensureCollectionTable(collection) {
-    if (this.ensuredTables.has(collection)) return;
-    this.getDb().exec(
-      `CREATE TABLE IF NOT EXISTS "${collection}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`
-    );
-    this.ensuredTables.add(collection);
-  }
-  getAllScoped(collection, scopeId) {
-    this.ensureCollectionTable(collection);
-    const rows = this.getDb().prepare(`SELECT id, data FROM "${collection}" WHERE id LIKE ? || '.%'`).all(scopeId);
-    const result = {};
-    for (const row of rows) {
-      const key = row.id.slice(scopeId.length + 1);
-      const parsed = JSON.parse(row.data);
-      result[key] = parsed.value ?? parsed;
-    }
-    return result;
-  }
-  setScopedKey(collection, scopeId, key, value) {
-    this.ensureCollectionTable(collection);
-    this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`).run(`${scopeId}.${key}`, JSON.stringify({ scopeId, key, value }));
-  }
-  // ── Structured table operations ────────────────────────────────────
-  async ensureTable(table, schema) {
-    if (!schema) {
-      if (!this.ensuredTables.has(table)) {
-        this.getDb().exec(`CREATE TABLE IF NOT EXISTS "${table}" (id TEXT PRIMARY KEY, data TEXT NOT NULL)`);
-        this.ensuredTables.add(table);
-      }
-      return;
-    }
-    if (this.structuredTables.has(table)) return;
-    const colDefs = schema.columns.map((col) => {
-      const parts = [`"${col.name}" ${col.type}`];
-      if (col.primaryKey) parts.push("PRIMARY KEY");
-      if (col.notNull) parts.push("NOT NULL");
-      if (col.unique) parts.push("UNIQUE");
-      if (col.defaultValue !== void 0) {
-        parts.push(`DEFAULT ${typeof col.defaultValue === "string" ? `'${col.defaultValue}'` : col.defaultValue === null ? "NULL" : String(col.defaultValue)}`);
-      }
-      return parts.join(" ");
-    });
-    this.getDb().exec(`CREATE TABLE IF NOT EXISTS "${table}" (${colDefs.join(", ")})`);
-    if (schema.indexes) {
-      for (const idx of schema.indexes) {
-        const unique = idx.unique ? "UNIQUE " : "";
-        const cols = idx.columns.map((c) => `"${c}"`).join(", ");
-        this.getDb().exec(`CREATE ${unique}INDEX IF NOT EXISTS "${idx.name}" ON "${table}" (${cols})`);
-      }
-    }
-    this.structuredTables.add(table);
-  }
-  async tableInsert(table, row) {
-    const keys = Object.keys(row);
-    const cols = keys.map((k) => `"${k}"`).join(", ");
-    const placeholders = keys.map(() => "?").join(", ");
-    const values = keys.map((k) => {
-      const v = row[k];
-      return typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-    });
-    this.getDb().prepare(`INSERT INTO "${table}" (${cols}) VALUES (${placeholders})`).run(...values);
-  }
-  async tableUpdate(table, filter, updates) {
-    const setClauses = [];
-    const setValues = [];
-    for (const [k, v] of Object.entries(updates)) {
-      setClauses.push(`"${k}" = ?`);
-      setValues.push(typeof v === "object" && v !== null ? JSON.stringify(v) : v);
-    }
-    const { whereSql, whereValues } = this.buildWhere(filter);
-    const result = this.getDb().prepare(`UPDATE "${table}" SET ${setClauses.join(", ")}${whereSql}`).run(...setValues, ...whereValues);
-    return result.changes;
-  }
-  async tableDelete(table, filter) {
-    const { whereSql, whereValues } = this.buildWhere(filter);
-    const result = this.getDb().prepare(`DELETE FROM "${table}"${whereSql}`).run(...whereValues);
-    return result.changes;
-  }
-  async tableQuery(table, options) {
-    let sql = `SELECT * FROM "${table}"`;
-    const values = [];
-    if (options?.where) {
-      const { whereSql, whereValues } = this.buildWhere(options.where);
-      sql += whereSql;
-      values.push(...whereValues);
-    }
-    if (options?.orderBy) {
-      sql += ` ORDER BY "${options.orderBy.field}" ${options.orderBy.direction === "desc" ? "DESC" : "ASC"}`;
-    }
-    if (options?.limit !== void 0) {
-      sql += ` LIMIT ?`;
-      values.push(options.limit);
-    }
-    if (options?.offset !== void 0) {
-      sql += ` OFFSET ?`;
-      values.push(options.offset);
-    }
-    return this.getDb().prepare(sql).all(...values);
-  }
-  async tableGet(table, filter) {
-    const { whereSql, whereValues } = this.buildWhere(filter);
-    const row = this.getDb().prepare(`SELECT * FROM "${table}"${whereSql} LIMIT 1`).get(...whereValues);
-    return row ?? null;
-  }
-  async tableCount(table, filter) {
-    let sql = `SELECT COUNT(*) as count FROM "${table}"`;
-    const values = [];
-    if (filter) {
-      const { whereSql, whereValues } = this.buildWhere(filter);
-      sql += whereSql;
-      values.push(...whereValues);
-    }
-    const row = this.getDb().prepare(sql).get(...values);
-    return row.count;
-  }
-  buildWhere(filter) {
-    const conditions = [];
-    const values = [];
-    for (const [k, v] of Object.entries(filter)) {
-      conditions.push(`"${k}" = ?`);
-      values.push(typeof v === "object" && v !== null ? JSON.stringify(v) : v);
-    }
-    const whereSql = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    return { whereSql, whereValues: values };
-  }
+const require_chunk = require("../../chunk-C13QxCFV.js");
+let node_crypto = require("node:crypto");
+let _camstack_types = require("@camstack/types");
+let better_sqlite3 = require("better-sqlite3");
+better_sqlite3 = require_chunk.__toESM(better_sqlite3);
+//#region src/builtins/sqlite-storage/sqlite-settings-backend.ts
+function parseRowData(raw) {
+	return (0, _camstack_types.asJsonObject)((0, _camstack_types.parseJsonUnknown)(raw)) ?? {};
+}
+/**
+* SQLite implementation of ISettingsBackend.
+*
+* Every collection is structured: declared at boot (canonical KV
+* collections) or via `declareCollection` (typed schemas like
+* `pipeline-analytics:tracks`). The legacy auto-create-on-first-access
+* path was removed — see commit history for the migration. Operations
+* on undeclared collections throw at runtime so callers fail fast.
+*
+* WAL mode for concurrent reads.
+*/
+var SqliteSettingsBackend = class SqliteSettingsBackend {
+	db = null;
+	structuredTables = /* @__PURE__ */ new Set();
+	/** Map from scoped collection name → set of column names (non-id) that
+	*  the structured schema owns. Routes set/get/insert/update/query to
+	*  typed columns. Every collection MUST be declared here before use. */
+	declaredCollections = /* @__PURE__ */ new Map();
+	runtimeDefaults;
+	/**
+	* Canonical key/value collections — declared with a `(id TEXT PK,
+	* data TEXT NOT NULL)` schema at boot so existing JSON-blob rows
+	* keep working through the structured path. Generates SQL identical
+	* to the previous legacy path; only the routing is unified.
+	*/
+	static CANONICAL_KV_COLLECTIONS = [
+		"system-settings",
+		"addon-settings",
+		"addon-device-settings",
+		"addon-devices",
+		"device-runtime-state",
+		"sections",
+		"provider-settings",
+		"device-settings",
+		"alerts"
+	];
+	constructor(dbPath, runtimeDefaults) {
+		this.dbPath = dbPath;
+		this.runtimeDefaults = runtimeDefaults ?? {};
+	}
+	async initialize() {
+		const dir = this.dbPath.substring(0, this.dbPath.lastIndexOf("/"));
+		if (dir) (await import("node:fs")).mkdirSync(dir, { recursive: true });
+		this.db = new better_sqlite3.default(this.dbPath);
+		this.db.pragma("journal_mode = WAL");
+		this.db.pragma("foreign_keys = ON");
+		for (const collection of SqliteSettingsBackend.CANONICAL_KV_COLLECTIONS) {
+			await this.ensureTable(collection, { columns: [{
+				name: "id",
+				type: "TEXT",
+				primaryKey: true,
+				notNull: true
+			}, {
+				name: "data",
+				type: "TEXT",
+				notNull: true
+			}] });
+			this.declaredCollections.set(collection, {
+				primaryKey: "id",
+				columns: new Set(["data"])
+			});
+		}
+		if (await this.isEmpty({ collection: "system-settings" })) await this.seedDefaults();
+	}
+	requireDeclared(scoped) {
+		const decl = this.declaredCollections.get(scoped);
+		if (!decl) throw new Error(`SqliteSettingsBackend: collection "${scoped}" is not declared. Call declareCollection() first or add it to CANONICAL_KV_COLLECTIONS.`);
+		return decl;
+	}
+	async shutdown() {
+		this.db?.close();
+		this.db = null;
+	}
+	async get({ namespace, collection, key }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const cols = [`"${decl.primaryKey}"`, ...[...decl.columns].map((c) => `"${c}"`)].join(", ");
+		const row = this.getDb().prepare(`SELECT ${cols} FROM "${scoped}" WHERE "${decl.primaryKey}" = ?`).get(key);
+		if (!row) return void 0;
+		if (decl.columns.size === 1 && decl.columns.has("data")) {
+			const raw = row["data"];
+			return typeof raw === "string" ? JSON.parse(raw) : raw;
+		}
+		const data = {};
+		for (const c of decl.columns) {
+			const v = row[c];
+			if (typeof v === "string" && (v.startsWith("{") || v.startsWith("["))) try {
+				data[c] = JSON.parse(v);
+			} catch {
+				data[c] = v;
+			}
+			else data[c] = v ?? null;
+		}
+		return data;
+	}
+	async set({ namespace, collection, key, value }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const row = { [decl.primaryKey]: key };
+		if (decl.columns.size === 1 && decl.columns.has("data")) row["data"] = JSON.stringify(value);
+		else {
+			const valueObj = value !== null && typeof value === "object" ? value : {};
+			for (const [k, v] of Object.entries(valueObj)) if (decl.columns.has(k)) row[k] = this.serializeColumnValue(v);
+		}
+		const keys = Object.keys(row);
+		const cols = keys.map((k) => `"${k}"`).join(", ");
+		const placeholders = keys.map(() => "?").join(", ");
+		const updates = keys.filter((k) => k !== decl.primaryKey).map((k) => `"${k}" = excluded."${k}"`).join(", ");
+		const values = keys.map((k) => row[k]);
+		const sql = updates.length > 0 ? `INSERT INTO "${scoped}" (${cols}) VALUES (${placeholders}) ON CONFLICT("${decl.primaryKey}") DO UPDATE SET ${updates}` : `INSERT INTO "${scoped}" (${cols}) VALUES (${placeholders}) ON CONFLICT("${decl.primaryKey}") DO NOTHING`;
+		this.getDb().prepare(sql).run(...values);
+	}
+	async query({ namespace, collection, filter }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		return this.queryDeclared(scoped, decl, filter);
+	}
+	async insert({ namespace, collection, record }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const id = record.id || (0, node_crypto.randomUUID)();
+		const row = { [decl.primaryKey]: id };
+		if (decl.columns.size === 1 && decl.columns.has("data")) row["data"] = JSON.stringify(record.data);
+		else for (const [k, v] of Object.entries(record.data)) if (decl.columns.has(k)) row[k] = this.serializeColumnValue(v);
+		await this.tableInsert(scoped, row);
+	}
+	async update({ namespace, collection, id, data }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const updates = {};
+		if (decl.columns.size === 1 && decl.columns.has("data")) updates["data"] = JSON.stringify(data);
+		else for (const [k, v] of Object.entries(data)) if (decl.columns.has(k)) updates[k] = this.serializeColumnValue(v);
+		if (Object.keys(updates).length > 0) await this.tableUpdate(scoped, { [decl.primaryKey]: id }, updates);
+	}
+	async delete({ namespace, collection, key }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		await this.tableDelete(scoped, { [decl.primaryKey]: key });
+	}
+	async count({ namespace, collection, filter }) {
+		const scoped = this.scopedName(namespace, collection);
+		const decl = this.requireDeclared(scoped);
+		const isKvShape = decl.columns.size === 1 && decl.columns.has("data");
+		const isColumn = (f) => f === decl.primaryKey || decl.columns.has(f);
+		const fieldExpr = (f) => {
+			if (isColumn(f)) return `"${f}"`;
+			if (isKvShape) return `json_extract("data", '$.${f}')`;
+			return "";
+		};
+		let sql = `SELECT COUNT(*) AS cnt FROM "${scoped}"`;
+		const params = [];
+		if (filter?.where) {
+			const clauses = [];
+			for (const [field, value] of Object.entries(filter.where)) {
+				const expr = fieldExpr(field);
+				if (!expr) continue;
+				clauses.push(`${expr} = ?`);
+				params.push(this.serializeColumnValue(value));
+			}
+			if (clauses.length > 0) sql += ` WHERE ${clauses.join(" AND ")}`;
+		}
+		return this.getDb().prepare(sql).get(...params)?.cnt ?? 0;
+	}
+	async isEmpty({ namespace, collection }) {
+		const scoped = this.scopedName(namespace, collection);
+		this.requireDeclared(scoped);
+		return await this.tableCount(scoped) === 0;
+	}
+	async queryDeclared(table, decl, filter) {
+		const isKvShape = decl.columns.size === 1 && decl.columns.has("data");
+		let sql = `SELECT ${[`"${decl.primaryKey}"`, ...[...decl.columns].map((c) => `"${c}"`)].join(", ")} FROM "${table}"`;
+		const params = [];
+		const whereClauses = [];
+		const isColumn = (f) => f === decl.primaryKey || decl.columns.has(f);
+		/**
+		* SQL expression for `field` on this table.
+		*  - real column → `"field"`
+		*  - KV blob field (e.g. `username` inside `data`) → `json_extract`
+		*  - structured table + non-column → empty string (filter dropped,
+		*    matches legacy structured-table behaviour)
+		*/
+		const fieldExpr = (f) => {
+			if (isColumn(f)) return `"${f}"`;
+			if (isKvShape) return `json_extract("data", '$.${f}')`;
+			return "";
+		};
+		if (filter?.where) for (const [field, value] of Object.entries(filter.where)) {
+			const expr = fieldExpr(field);
+			if (!expr) continue;
+			whereClauses.push(`${expr} = ?`);
+			params.push(this.serializeColumnValue(value));
+		}
+		if (filter?.whereIn) for (const [field, values] of Object.entries(filter.whereIn)) {
+			const expr = fieldExpr(field);
+			if (!expr) continue;
+			const placeholders = values.map(() => "?").join(", ");
+			whereClauses.push(`${expr} IN (${placeholders})`);
+			for (const v of values) params.push(this.serializeColumnValue(v));
+		}
+		if (filter?.whereBetween) for (const [field, [low, high]] of Object.entries(filter.whereBetween)) {
+			const expr = fieldExpr(field);
+			if (!expr) continue;
+			whereClauses.push(`${expr} BETWEEN ? AND ?`);
+			params.push(this.serializeColumnValue(low), this.serializeColumnValue(high));
+		}
+		if (whereClauses.length > 0) sql += ` WHERE ${whereClauses.join(" AND ")}`;
+		if (filter?.orderBy) {
+			const expr = fieldExpr(filter.orderBy.field);
+			if (expr) {
+				const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
+				sql += ` ORDER BY ${expr} ${dir}`;
+			}
+		}
+		if (filter?.limit !== void 0) {
+			sql += ` LIMIT ?`;
+			params.push(filter.limit);
+		}
+		if (filter?.offset !== void 0) {
+			sql += ` OFFSET ?`;
+			params.push(filter.offset);
+		}
+		return this.getDb().prepare(sql).all(...params).map((r) => {
+			const id = String(r[decl.primaryKey] ?? "");
+			if (isKvShape) {
+				const v = r["data"];
+				if (typeof v === "string" && (v.startsWith("{") || v.startsWith("["))) try {
+					return {
+						id,
+						data: JSON.parse(v)
+					};
+				} catch {
+					return {
+						id,
+						data: { value: v }
+					};
+				}
+				return {
+					id,
+					data: v == null ? {} : { value: v }
+				};
+			}
+			const data = { [decl.primaryKey]: r[decl.primaryKey] ?? null };
+			for (const c of decl.columns) {
+				const v = r[c];
+				if (typeof v === "string" && (v.startsWith("{") || v.startsWith("["))) try {
+					data[c] = JSON.parse(v);
+				} catch {
+					data[c] = v;
+				}
+				else data[c] = v ?? null;
+			}
+			return {
+				id,
+				data
+			};
+		});
+	}
+	/** Get a system setting by dot-notation key */
+	getSystem(key) {
+		this.requireDeclared("system-settings");
+		const row = this.getDb().prepare("SELECT data FROM \"system-settings\" WHERE id = ?").get(key);
+		if (!row) return void 0;
+		return JSON.parse(row.data);
+	}
+	/** Set a system setting */
+	setSystem(key, value) {
+		this.requireDeclared("system-settings");
+		this.getDb().prepare("INSERT INTO \"system-settings\" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data").run(key, JSON.stringify(value));
+	}
+	/** Get all system settings as flat key-value */
+	getAllSystem() {
+		this.requireDeclared("system-settings");
+		const rows = this.getDb().prepare("SELECT id, data FROM \"system-settings\"").all();
+		return Object.fromEntries(rows.map((r) => [r.id, JSON.parse(r.data)]));
+	}
+	/** Get all settings for an addon */
+	getAllAddon(addonId) {
+		this.requireDeclared("addon-settings");
+		const rows = this.getDb().prepare("SELECT id, data FROM \"addon-settings\" WHERE json_extract(data, '$.addonId') = ?").all(addonId);
+		if (rows.length === 0) return {};
+		const result = {};
+		for (const row of rows) {
+			const parsed = parseRowData(row.data);
+			const key = row.id.startsWith(`${addonId}.`) ? row.id.slice(addonId.length + 1) : row.id;
+			if (parsed !== null && typeof parsed === "object" && "addonId" in parsed && "key" in parsed) {
+				const wrapper = parsed;
+				if ("value" in wrapper) result[key] = wrapper.value;
+			} else result[key] = parsed;
+		}
+		return result;
+	}
+	/** Bulk-set all settings for an addon */
+	setAllAddon(addonId, config) {
+		this.requireDeclared("addon-settings");
+		const db = this.getDb();
+		const deleteStmt = db.prepare("DELETE FROM \"addon-settings\" WHERE id LIKE ? || '%'");
+		const insertStmt = db.prepare("INSERT INTO \"addon-settings\" (id, data) VALUES (?, ?)");
+		db.transaction(() => {
+			deleteStmt.run(`${addonId}.`);
+			for (const [key, value] of Object.entries(config)) {
+				if (value === void 0) continue;
+				insertStmt.run(`${addonId}.${key}`, JSON.stringify({
+					addonId,
+					key,
+					value
+				}));
+			}
+		})();
+	}
+	/** Get all settings for a provider */
+	getAllProvider(providerId) {
+		return this.getAllScoped("provider-settings", providerId);
+	}
+	/** Set a provider setting */
+	setProvider(providerId, key, value) {
+		this.setScopedKey("provider-settings", providerId, key, value);
+	}
+	/** Get all settings for a device */
+	getAllDevice(deviceId) {
+		return this.getAllScoped("device-settings", deviceId);
+	}
+	/** Set a device setting */
+	setDevice(deviceId, key, value) {
+		this.setScopedKey("device-settings", deviceId, key, value);
+	}
+	getAddonDevice(addonId, deviceId) {
+		return this.getAllScoped("addon-device-settings", `${addonId}:${deviceId}`);
+	}
+	setAddonDevice(addonId, deviceId, values) {
+		this.requireDeclared("addon-device-settings");
+		const db = this.getDb();
+		const prefix = `${addonId}:${deviceId}.`;
+		const deleteStmt = db.prepare(`DELETE FROM "addon-device-settings" WHERE id LIKE ? || '%'`);
+		const insertStmt = db.prepare(`INSERT INTO "addon-device-settings" (id, data) VALUES (?, ?)
+       ON CONFLICT(id) DO UPDATE SET data = excluded.data`);
+		db.transaction(() => {
+			deleteStmt.run(prefix);
+			for (const [key, value] of Object.entries(values)) insertStmt.run(`${prefix}${key}`, JSON.stringify({
+				addonId,
+				deviceId,
+				key,
+				value
+			}));
+		})();
+	}
+	clearAddonDevice(addonId, deviceId) {
+		this.requireDeclared("addon-device-settings");
+		const prefix = `${addonId}:${deviceId}.`;
+		this.getDb().prepare(`DELETE FROM "addon-device-settings" WHERE id LIKE ? || '%'`).run(prefix);
+	}
+	/** Seed system-settings with runtime defaults (first boot) */
+	async seedDefaults() {
+		this.requireDeclared("system-settings");
+		const insert = this.getDb().prepare("INSERT OR IGNORE INTO \"system-settings\" (id, data) VALUES (?, ?)");
+		this.getDb().transaction(() => {
+			for (const [key, value] of Object.entries(this.runtimeDefaults)) insert.run(key, JSON.stringify(value));
+		})();
+	}
+	/**
+	* Expose the raw better-sqlite3 Database instance for components that
+	* need direct SQL access (e.g. DeviceStore, ConfigStore).
+	* Returns null if the backend has not been initialized yet.
+	*/
+	getDatabase() {
+		return this.db;
+	}
+	getDb() {
+		if (!this.db) throw new Error("SqliteSettingsBackend not initialized — call initialize() first");
+		return this.db;
+	}
+	getAllScoped(collection, scopeId) {
+		this.requireDeclared(collection);
+		const rows = this.getDb().prepare(`SELECT id, data FROM "${collection}" WHERE id LIKE ? || '.%'`).all(scopeId);
+		const result = {};
+		for (const row of rows) {
+			const key = row.id.slice(scopeId.length + 1);
+			const parsed = parseRowData(row.data);
+			result[key] = parsed.value ?? parsed;
+		}
+		return result;
+	}
+	setScopedKey(collection, scopeId, key, value) {
+		this.requireDeclared(collection);
+		this.getDb().prepare(`INSERT INTO "${collection}" (id, data) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET data = excluded.data`).run(`${scopeId}.${key}`, JSON.stringify({
+			scopeId,
+			key,
+			value
+		}));
+	}
+	scopedName(namespace, collection) {
+		return namespace ? `${namespace}:${collection}` : collection;
+	}
+	async declareCollection(input) {
+		const table = this.scopedName(input.namespace, input.collection);
+		if (this.declaredCollections.has(table)) return;
+		const columns = input.columns.some((c) => c.primaryKey === true) ? input.columns : [{
+			name: "id",
+			type: "TEXT",
+			primaryKey: true,
+			notNull: true
+		}, ...input.columns];
+		const schema = {
+			columns: columns.map((c) => ({
+				name: c.name,
+				type: c.type === "JSON" ? "TEXT" : c.type,
+				...c.primaryKey !== void 0 ? { primaryKey: c.primaryKey } : {},
+				...c.notNull !== void 0 ? { notNull: c.notNull } : {},
+				...c.unique !== void 0 ? { unique: c.unique } : {}
+			})),
+			...input.indexes ? { indexes: input.indexes.map((i) => ({
+				name: i.name,
+				columns: i.columns,
+				...i.unique !== void 0 ? { unique: i.unique } : {}
+			})) } : {}
+		};
+		await this.ensureTable(table, schema);
+		const pkCol = columns.find((c) => c.primaryKey === true);
+		const primaryKey = pkCol ? pkCol.name : "id";
+		const columnNames = new Set(columns.filter((c) => c.name !== primaryKey).map((c) => c.name));
+		this.declaredCollections.set(table, {
+			primaryKey,
+			columns: columnNames
+		});
+	}
+	/** Serialise per-column values for SQL binding: objects → JSON, booleans → 0/1. */
+	serializeColumnValue(v) {
+		if (v === null || v === void 0) return v ?? null;
+		if (typeof v === "boolean") return v ? 1 : 0;
+		if (typeof v === "object") return JSON.stringify(v);
+		return v;
+	}
+	async ensureTable(table, schema) {
+		if (this.structuredTables.has(table)) return;
+		const colDefs = schema.columns.map((col) => {
+			const parts = [`"${col.name}" ${col.type}`];
+			if (col.primaryKey) parts.push("PRIMARY KEY");
+			if (col.notNull) parts.push("NOT NULL");
+			if (col.unique) parts.push("UNIQUE");
+			if (col.defaultValue !== void 0) parts.push(`DEFAULT ${typeof col.defaultValue === "string" ? `'${col.defaultValue}'` : col.defaultValue === null ? "NULL" : String(col.defaultValue)}`);
+			return parts.join(" ");
+		});
+		const existingCols = this.getDb().prepare(`PRAGMA table_info("${table}")`).all();
+		if (existingCols.length > 0) {
+			const existingNames = new Set(existingCols.map((c) => c.name));
+			const declaredNames = new Set(schema.columns.map((c) => c.name));
+			const missingDeclared = schema.columns.some((c) => !existingNames.has(c.name));
+			if (existingCols.length <= 2 && existingNames.has("data") && !declaredNames.has("data") || missingDeclared) try {
+				this.getDb().exec(`DROP TABLE "${table}"`);
+			} catch {}
+		}
+		this.getDb().exec(`CREATE TABLE IF NOT EXISTS "${table}" (${colDefs.join(", ")})`);
+		if (schema.indexes) for (const idx of schema.indexes) {
+			const unique = idx.unique ? "UNIQUE " : "";
+			const cols = idx.columns.map((c) => `"${c}"`).join(", ");
+			this.getDb().exec(`CREATE ${unique}INDEX IF NOT EXISTS "${idx.name}" ON "${table}" (${cols})`);
+		}
+		this.structuredTables.add(table);
+	}
+	async tableInsert(table, row) {
+		const keys = Object.keys(row);
+		const cols = keys.map((k) => `"${k}"`).join(", ");
+		const placeholders = keys.map(() => "?").join(", ");
+		const values = keys.map((k) => {
+			const v = row[k];
+			return typeof v === "object" && v !== null ? JSON.stringify(v) : v;
+		});
+		this.getDb().prepare(`INSERT INTO "${table}" (${cols}) VALUES (${placeholders})`).run(...values);
+	}
+	async tableUpdate(table, filter, updates) {
+		const setClauses = [];
+		const setValues = [];
+		for (const [k, v] of Object.entries(updates)) {
+			setClauses.push(`"${k}" = ?`);
+			setValues.push(typeof v === "object" && v !== null ? JSON.stringify(v) : v);
+		}
+		const { whereSql, whereValues } = this.buildWhere(filter);
+		return this.getDb().prepare(`UPDATE "${table}" SET ${setClauses.join(", ")}${whereSql}`).run(...setValues, ...whereValues).changes;
+	}
+	async tableDelete(table, filter) {
+		const { whereSql, whereValues } = this.buildWhere(filter);
+		return this.getDb().prepare(`DELETE FROM "${table}"${whereSql}`).run(...whereValues).changes;
+	}
+	async tableQuery(table, options) {
+		let sql = `SELECT * FROM "${table}"`;
+		const values = [];
+		if (options?.where) {
+			const { whereSql, whereValues } = this.buildWhere(options.where);
+			sql += whereSql;
+			values.push(...whereValues);
+		}
+		if (options?.orderBy) sql += ` ORDER BY "${options.orderBy.field}" ${options.orderBy.direction === "desc" ? "DESC" : "ASC"}`;
+		if (options?.limit !== void 0) {
+			sql += ` LIMIT ?`;
+			values.push(options.limit);
+		}
+		if (options?.offset !== void 0) {
+			sql += ` OFFSET ?`;
+			values.push(options.offset);
+		}
+		return this.getDb().prepare(sql).all(...values).flatMap((r) => (0, _camstack_types.asJsonObject)(r) ? [(0, _camstack_types.asJsonObject)(r)] : []);
+	}
+	async tableGet(table, filter) {
+		const { whereSql, whereValues } = this.buildWhere(filter);
+		return (0, _camstack_types.asJsonObject)(this.getDb().prepare(`SELECT * FROM "${table}"${whereSql} LIMIT 1`).get(...whereValues));
+	}
+	async tableCount(table, filter) {
+		let sql = `SELECT COUNT(*) as count FROM "${table}"`;
+		const values = [];
+		if (filter) {
+			const { whereSql, whereValues } = this.buildWhere(filter);
+			sql += whereSql;
+			values.push(...whereValues);
+		}
+		const row = (0, _camstack_types.asJsonObject)(this.getDb().prepare(sql).get(...values));
+		return typeof row?.count === "number" ? row.count : 0;
+	}
+	buildWhere(filter) {
+		const conditions = [];
+		const values = [];
+		for (const [k, v] of Object.entries(filter)) {
+			conditions.push(`"${k}" = ?`);
+			values.push(typeof v === "object" && v !== null ? JSON.stringify(v) : v);
+		}
+		return {
+			whereSql: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
+			whereValues: values
+		};
+	}
 };
-
-// src/builtins/sqlite-storage/sqlite-settings.addon.ts
-var SqliteSettingsAddon = class {
-  manifest = {
-    id: "sqlite-settings",
-    name: "SQLite Settings",
-    version: "1.0.0",
-    capabilities: [{ name: "settings-store", mode: "singleton" }]
-  };
-  backend = null;
-  async initialize(context) {
-    const dbPath = context.storageProvider ? context.storageProvider.resolve("addons-data", `${context.id.replace("addon:", "")}/camstack.db`) : context.dataDir ? `${context.dataDir}/camstack.db` : "camstack-data/addons-data/sqlite-settings/camstack.db";
-    const runtimeDefaults = context.addonConfig._runtimeDefaults ?? {};
-    this.backend = new SqliteSettingsBackend(dbPath, runtimeDefaults);
-    await this.backend.initialize();
-    context.logger.info(`SQLite settings initialized at ${dbPath}`);
-  }
-  async shutdown() {
-    await this.backend?.shutdown();
-  }
-  getBackend() {
-    return this.backend;
-  }
-  getCapabilityProvider(name) {
-    if (name === "settings-store" && this.backend) {
-      return this.backend;
-    }
-    return null;
-  }
-  getConfigSchema() {
-    return { sections: [] };
-  }
-  getConfig() {
-    return {};
-  }
-  async onConfigChange(_config) {
-  }
+//#endregion
+//#region src/builtins/sqlite-storage/sqlite-settings.addon.ts
+/**
+* SQLite Settings addon — provides persistent settings storage.
+* Capability: 'settings-store' (singleton)
+*/
+var SqliteSettingsAddon = class extends _camstack_types.BaseAddon {
+	backend = null;
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		const addonId = this.ctx.id.replace("addon:", "");
+		const path = await import("node:path");
+		const dbPath = this.ctx.dataDir ? path.join(this.ctx.dataDir, "camstack.db") : path.join("camstack-data", "addons-data", addonId, "camstack.db");
+		const pathSource = this.ctx.dataDir ? "dataDir" : "fallback (hardcoded)";
+		let dbExists = false;
+		try {
+			const fs = await import("node:fs");
+			dbExists = fs.existsSync(dbPath);
+			if (!dbExists) await fs.promises.mkdir(path.dirname(dbPath), { recursive: true });
+		} catch (err) {
+			this.ctx.logger.warn("Failed to check/create DB directory", { meta: { error: (0, _camstack_types.errMsg)(err) } });
+		}
+		this.ctx.logger.info("DB path resolved", { meta: {
+			pathSource,
+			dbPath
+		} });
+		this.ctx.logger.info("DB file status", { meta: { dbExists } });
+		this.backend = new SqliteSettingsBackend(dbPath, { ..._camstack_types.RUNTIME_DEFAULTS });
+		await this.backend.initialize();
+		this.ctx.logger.info("Initialized successfully");
+		return [{
+			capability: _camstack_types.settingsStoreCapability,
+			provider: this.backend
+		}];
+	}
+	async onShutdown() {
+		await this.backend?.shutdown();
+	}
+	getBackend() {
+		return this.backend;
+	}
 };
-var sqlite_settings_addon_default = SqliteSettingsAddon;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  SqliteSettingsAddon
-});
+//#endregion
+exports.SqliteSettingsAddon = SqliteSettingsAddon;
+exports.default = SqliteSettingsAddon;
+exports.SqliteSettingsBackend = SqliteSettingsBackend;
+
 //# sourceMappingURL=sqlite-settings.addon.js.map