@camstack/core 0.1.15 → 0.1.16

package/dist/chunk-FZN56HGQ.mjs

@@ -1,626 +0,0 @@
-// src/builtins/sqlite-storage/sqlite-settings.addon.ts
-import { BaseAddon, RUNTIME_DEFAULTS, errMsg, settingsStoreCapability } from "@camstack/types";
-
-// src/builtins/sqlite-storage/sqlite-settings-backend.ts
-import Database from "better-sqlite3";
-import { randomUUID } from "crypto";
-import { asJsonObject, parseJsonUnknown } from "@camstack/types";
-function parseRowData(raw) {
-  return asJsonObject(parseJsonUnknown(raw)) ?? {};
-}
-var SqliteSettingsBackend = class _SqliteSettingsBackend {
-  // Domain schemas (auth, analytics events, …) live in the addons that
-  // own them — same pattern as `pipeline-analytics` (`event-store.ts`,
-  // `track-store.ts`, `media-store.ts`) and `local-auth` (`auth-schema.ts`).
-  // The backend exposes `declareCollection` and stays out of domain
-  // knowledge.
-  constructor(dbPath, runtimeDefaults) {
-    this.dbPath = dbPath;
-    this.runtimeDefaults = runtimeDefaults ?? {};
-  }
-  dbPath;
-  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"
-  ];
-  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 Database(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: /* @__PURE__ */ new Set(["data"])
-      });
-    }
-    const isEmpty = await this.isEmpty({ collection: "system-settings" });
-    if (isEmpty) {
-      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;
-  }
-  // ---------------------------------------------------------------------------
-  // ISettingsBackend implementation
-  // ---------------------------------------------------------------------------
-  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 || 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 ")}`;
-    }
-    const row = this.getDb().prepare(sql).get(...params);
-    return row?.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");
-    const cols = [`"${decl.primaryKey}"`, ...[...decl.columns].map((c) => `"${c}"`)].join(", ");
-    let sql = `SELECT ${cols} FROM "${table}"`;
-    const params = [];
-    const whereClauses = [];
-    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 "";
-    };
-    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);
-    }
-    const rows = this.getDb().prepare(sql).all(...params);
-    return rows.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 };
-    });
-  }
-  // ---------------------------------------------------------------------------
-  // Legacy SettingsStore compatibility (used by ConfigManager.setSettingsStore)
-  // ---------------------------------------------------------------------------
-  /** 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;
-      const isWrapper = parsed !== null && typeof parsed === "object" && "addonId" in parsed && "key" in parsed;
-      if (isWrapper) {
-        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);
-  }
-  // ── Addon-device settings (per-device overrides of an addon's config) ──
-  //
-  // Storage key format: "<addonId>:<deviceId>.<field>" inside the
-  // "addon-device-settings" collection. Uses the same JSON-blob layout
-  // as the other scoped collections so no schema change is required.
-  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));
-      }
-    })();
-  }
-  // ---------------------------------------------------------------------------
-  // Private helpers
-  // ---------------------------------------------------------------------------
-  /**
-   * 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 \u2014 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 }));
-  }
-  // ── Declared collections (typed SQL tables behind the generic cap) ──
-  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 hasId = input.columns.some((c) => c.primaryKey === true);
-    const columns = hasId ? input.columns : [{ name: "id", type: "TEXT", primaryKey: true, notNull: true }, ...input.columns];
-    const schema = {
-      columns: columns.map((c) => ({
-        name: c.name,
-        // SQLite treats JSON as TEXT; we serialize object values on write
-        // and parse on read.
-        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;
-  }
-  // ── Structured table operations ────────────────────────────────────
-  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));
-      const isLegacyKv = existingCols.length <= 2 && existingNames.has("data") && !declaredNames.has("data");
-      if (isLegacyKv || 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);
-    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);
-    }
-    const rows = this.getDb().prepare(sql).all(...values);
-    return rows.flatMap((r) => asJsonObject(r) ? [asJsonObject(r)] : []);
-  }
-  async tableGet(table, filter) {
-    const { whereSql, whereValues } = this.buildWhere(filter);
-    const row = this.getDb().prepare(`SELECT * FROM "${table}"${whereSql} LIMIT 1`).get(...whereValues);
-    return asJsonObject(row);
-  }
-  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 = 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);
-    }
-    const whereSql = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    return { whereSql, whereValues: values };
-  }
-};
-
-// src/builtins/sqlite-storage/sqlite-settings.addon.ts
-var SqliteSettingsAddon = class extends BaseAddon {
-  backend = null;
-  constructor() {
-    super({});
-  }
-  async onInitialize() {
-    const addonId = this.ctx.id.replace("addon:", "");
-    let pathSource = "fallback (hardcoded)";
-    const dbPath = await this.ctx.api.storage.resolve.query({ location: "addons-data", relativePath: `${addonId}/camstack.db` }).then((p) => {
-      pathSource = "storage capability (addons-data)";
-      return p;
-    }).catch(() => {
-      if (this.ctx.dataDir) {
-        pathSource = "dataDir";
-        return `${this.ctx.dataDir}/camstack.db`;
-      }
-      return "camstack-data/addons-data/sqlite-settings/camstack.db";
-    });
-    let dbExists = false;
-    try {
-      const fs = await import("fs");
-      dbExists = fs.existsSync(dbPath);
-    } catch (err) {
-      this.ctx.logger.warn("Failed to check DB file existence", { meta: { error: 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, { ...RUNTIME_DEFAULTS });
-    await this.backend.initialize();
-    this.ctx.logger.info("Initialized successfully");
-    return [{ capability: settingsStoreCapability, provider: this.backend }];
-  }
-  async onShutdown() {
-    await this.backend?.shutdown();
-  }
-  getBackend() {
-    return this.backend;
-  }
-};
-var sqlite_settings_addon_default = SqliteSettingsAddon;
-
-export {
-  SqliteSettingsBackend,
-  SqliteSettingsAddon,
-  sqlite_settings_addon_default
-};
-//# sourceMappingURL=chunk-FZN56HGQ.mjs.map