@camstack/system 1.2.30 → 1.2.31

package/dist/builtins/sqlite-storage/integration-registry.d.ts

@@ -1,7 +1,7 @@
-import { Integration, PersistedDevice, CreateIntegrationInput, CreateDeviceInput, IIntegrationRegistry, ISettingsBackend } from '@camstack/types';
+import { Integration, PersistedDevice, CreateIntegrationInput, CreateDeviceInput, IIntegrationRegistry, ISettingsStoreProvider } from '@camstack/types';
 export declare class IntegrationRegistry implements IIntegrationRegistry {
-    private readonly backend;
-    constructor(backend: ISettingsBackend);
+    private readonly store;
+    constructor(backend: ISettingsStoreProvider);
     initialize(): Promise<void>;
     createIntegration(input: CreateIntegrationInput): Promise<Integration>;
     getIntegration(id: string): Promise<Integration | null>;

package/dist/builtins/sqlite-storage/sqlite-settings-backend.d.ts

@@ -1,5 +1,5 @@
 import { default as Database } from 'better-sqlite3';
-import { DataStoreEngineInfo, ISettingsBackend, SettingsRecord, TableSchema, TableQueryOptions, SettingsGetInput, SettingsSetInput, SettingsQueryInput, SettingsInsertInput, SettingsUpdateInput, SettingsDeleteInput, SettingsCountInput, SettingsIsEmptyInput, SettingsHistogramInput, HistogramBucket, CollectionColumn, CollectionIndex } from '@camstack/types';
+import { DataStoreEngineInfo, ISettingsBackend, SettingsRecord, SettingsGetInput, SettingsSetInput, SettingsQueryInput, SettingsInsertInput, SettingsUpdateInput, SettingsDeleteInput, SettingsCountInput, SettingsIsEmptyInput, SettingsHistogramInput, HistogramBucket, CollectionColumn, CollectionIndex } from '@camstack/types';
 import { MutationFilterInput } from './filter-compiler.js';
 /** Input for {@link SqliteSettingsBackend.deleteWhere}. */
 interface SettingsDeleteWhereInput {
@@ -139,13 +139,11 @@ export declare class SqliteSettingsBackend implements ISettingsBackend {
     }): Promise<void>;
     /** Serialise per-column values for SQL binding: objects → JSON, booleans → 0/1. */
     private serializeColumnValue;
-    ensureTable(table: string, schema: TableSchema): Promise<void>;
-    tableInsert(table: string, row: Record<string, unknown>): Promise<void>;
-    tableUpdate(table: string, filter: Record<string, unknown>, updates: Record<string, unknown>): Promise<number>;
-    tableDelete(table: string, filter: Record<string, unknown>): Promise<number>;
-    tableQuery(table: string, options?: TableQueryOptions): Promise<readonly Record<string, unknown>[]>;
-    tableGet(table: string, filter: Record<string, unknown>): Promise<Record<string, unknown> | null>;
-    tableCount(table: string, filter?: Record<string, unknown>): Promise<number>;
+    private ensureTable;
+    private tableInsert;
+    private tableUpdate;
+    private tableDelete;
+    private tableCount;
     private buildWhere;
 }
 export default SqliteSettingsBackend;

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

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-VIwdvws5.js");
+const require_dist = require("../../dist-CDv5YTHQ.js");
 let node_crypto = require("node:crypto");
 let better_sqlite3 = require("better-sqlite3");
 better_sqlite3 = require_chunk.__toESM(better_sqlite3);
@@ -536,7 +536,8 @@ var SqliteSettingsBackend = class SqliteSettingsBackend {
 				type: c.type === "JSON" ? "TEXT" : c.type === "BOOLEAN" ? "INTEGER" : c.type,
 				...c.primaryKey !== void 0 ? { primaryKey: c.primaryKey } : {},
 				...c.notNull !== void 0 ? { notNull: c.notNull } : {},
-				...c.unique !== void 0 ? { unique: c.unique } : {}
+				...c.unique !== void 0 ? { unique: c.unique } : {},
+				...c.defaultValue !== void 0 ? { defaultValue: c.defaultValue } : {}
 			})),
 			...input.indexes ? { indexes: input.indexes.map((i) => ({
 				name: i.name,
@@ -621,29 +622,6 @@ var SqliteSettingsBackend = class SqliteSettingsBackend {
 		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) => require_dist.asJsonObject(r) ? [require_dist.asJsonObject(r)] : []);
-	}
-	async tableGet(table, filter) {
-		const { whereSql, whereValues } = this.buildWhere(filter);
-		return require_dist.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 = [];

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

@@ -1,4 +1,4 @@
-import { Dt as parseJsonUnknown, at as errMsg, c as RUNTIME_DEFAULTS, gt as asJsonObject, ot as BaseAddon, x as dataStoreProviderCapability } from "../../dist-Dr_P0DOB.mjs";
+import { Dt as parseJsonUnknown, at as errMsg, c as RUNTIME_DEFAULTS, gt as asJsonObject, ot as BaseAddon, x as dataStoreProviderCapability } from "../../dist-CNmXITJ-.mjs";
 import { randomUUID } from "node:crypto";
 import Database from "better-sqlite3";
 //#region src/builtins/sqlite-storage/filter-compiler.ts
@@ -530,7 +530,8 @@ var SqliteSettingsBackend = class SqliteSettingsBackend {
 				type: c.type === "JSON" ? "TEXT" : c.type === "BOOLEAN" ? "INTEGER" : c.type,
 				...c.primaryKey !== void 0 ? { primaryKey: c.primaryKey } : {},
 				...c.notNull !== void 0 ? { notNull: c.notNull } : {},
-				...c.unique !== void 0 ? { unique: c.unique } : {}
+				...c.unique !== void 0 ? { unique: c.unique } : {},
+				...c.defaultValue !== void 0 ? { defaultValue: c.defaultValue } : {}
 			})),
 			...input.indexes ? { indexes: input.indexes.map((i) => ({
 				name: i.name,
@@ -615,29 +616,6 @@ var SqliteSettingsBackend = class SqliteSettingsBackend {
 		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) => asJsonObject(r) ? [asJsonObject(r)] : []);
-	}
-	async tableGet(table, filter) {
-		const { whereSql, whereValues } = this.buildWhere(filter);
-		return 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 = [];

package/dist/builtins/storage-orchestrator/location-store.d.ts

@@ -1,4 +1,4 @@
-import { ISettingsBackend, StorageLocation } from '@camstack/types';
+import { ISettingsStoreProvider, StorageLocation } from '@camstack/types';
 /**
  * Abstract storage interface for `StorageLocation` records. Methods are
  * async because production-side implementations hit SQLite — but the
@@ -14,35 +14,28 @@ export interface ILocationStore {
     delete(id: string): Promise<void>;
 }
 /**
- * SQLite-backed implementation of `ILocationStore` — uses the
- * `settings-store` cap's structured-table surface (`ensureTable` /
- * `tableInsert` / `tableUpdate` / `tableDelete` / `tableQuery`). Wired
- * to the live `ISettingsBackend` provider obtained from
- * `kernel.capabilityRegistry.getSingleton('settings-store')`.
- *
- * The cap-router surface (`ctx.api.settingsStore.*`) does NOT expose
- * the `tableXxx` methods — they're only on the raw `ISettingsBackend`.
- * Same constraint that drives `IntegrationRegistry` to take a direct
- * provider reference instead of going through the cap.
+ * `ILocationStore` on the `settings-store` collection surface — the same door
+ * every other consumer uses. It holds the `data-store-provider` engine object
+ * directly (not the `settings-store` singleton) because since D44 the
+ * storage-orchestrator IS that singleton, and asking the registry for it would
+ * route this table back through the orchestrator itself.
  */
 export declare class SqliteLocationStore implements ILocationStore {
-    private readonly backend;
-    private tableEnsured;
-    constructor(backend: ISettingsBackend);
+    private readonly store;
+    private declared;
+    constructor(store: ISettingsStoreProvider);
     /**
-     * Lazy `ensureTable` — keeps the constructor cheap and async-free.
-     * Called from every mutation/read path; the backend's `ensureTable`
-     * is itself idempotent (additive migration), so repeated calls are
-     * effectively no-ops after the first.
+     * Lazy `declareCollection` — keeps the constructor cheap and async-free.
+     * Called from every mutation/read path; `declareCollection` is idempotent
+     * (and additive on shape changes), so repeated calls collapse to a no-op.
      */
-    private ensureTable;
+    private ensureDeclared;
     loadAll(): Promise<readonly StorageLocation[]>;
     /**
-     * Replace-or-insert. Implemented as `delete` + `insert` rather than
-     * the conditional `tableUpdate` path because the orchestrator
-     * serializes every mutation through the in-memory map before
-     * dispatching to the store — there's no contention to lose, and the
-     * delete-then-insert path is unconditionally simpler.
+     * Replace-or-insert. Implemented as delete + insert rather than a
+     * conditional update because the orchestrator serializes every mutation
+     * through the in-memory map before dispatching to the store — there's no
+     * contention to lose, and delete-then-insert is unconditionally simpler.
      */
     upsert(loc: StorageLocation): Promise<void>;
     delete(id: string): Promise<void>;

package/dist/builtins/storage-orchestrator/storage-orchestrator.addon.d.ts

@@ -35,12 +35,6 @@ export declare class StorageOrchestratorAddon extends BaseAddon<StorageOrchestra
      * addon *is* that singleton, so asking the registry for it would hand
      * the orchestrator its own dispatcher and route its location table back
      * through itself.
-     *
-     * The `ensureTable` / `tableInsert` reach-around below is the B2 bypass,
-     * still open: those six methods live on the concrete backend and on no
-     * cap. Promoting them to the door is a separate task; until then this
-     * holds the engine object directly, which only works because the engine
-     * is in-process on this node.
      */
     private resolveLocationStore;
     /**

package/dist/builtins/storage-orchestrator/storage-orchestrator.addon.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-VIwdvws5.js");
+const require_dist = require("../../dist-CDv5YTHQ.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_fs_promises = require("node:fs/promises");
@@ -535,7 +535,7 @@ var StorageOrchestratorService = class {
 };
 //#endregion
 //#region src/builtins/storage-orchestrator/location-store.ts
-var STORAGE_LOCATIONS_TABLE = "storage_locations";
+var STORAGE_LOCATIONS = "storage_locations";
 /**
 * Reserved key under which the cluster `nodeId` (SP1) is persisted INSIDE
 * the `config` JSON blob. Storing it in the blob rather than a dedicated
@@ -548,125 +548,147 @@ var STORAGE_LOCATIONS_TABLE = "storage_locations";
 * API consumers and providers never see it.
 */
 var NODE_ID_CONFIG_KEY = "__nodeId";
-var STORAGE_LOCATIONS_SCHEMA = {
-	columns: [
-		{
-			name: "id",
-			type: "TEXT",
-			primaryKey: true
-		},
-		{
-			name: "type",
-			type: "TEXT",
-			notNull: true
-		},
-		{
-			name: "display_name",
-			type: "TEXT",
-			notNull: true
-		},
-		{
-			name: "provider_id",
-			type: "TEXT",
-			notNull: true
-		},
-		{
-			name: "config",
-			type: "TEXT",
-			notNull: true,
-			defaultValue: "{}"
-		},
-		{
-			name: "is_default",
-			type: "INTEGER",
-			notNull: true,
-			defaultValue: 0
-		},
-		{
-			name: "is_system",
-			type: "INTEGER",
-			notNull: true,
-			defaultValue: 0
-		},
-		{
-			name: "created_at",
-			type: "INTEGER",
-			notNull: true
-		},
-		{
-			name: "updated_at",
-			type: "INTEGER",
-			notNull: true
-		}
-	],
-	indexes: [{
-		name: "idx_storage_locations_type",
-		columns: ["type"]
-	}]
-};
 /**
-* SQLite-backed implementation of `ILocationStore` — uses the
-* `settings-store` cap's structured-table surface (`ensureTable` /
-* `tableInsert` / `tableUpdate` / `tableDelete` / `tableQuery`). Wired
-* to the live `ISettingsBackend` provider obtained from
-* `kernel.capabilityRegistry.getSingleton('settings-store')`.
-*
-* The cap-router surface (`ctx.api.settingsStore.*`) does NOT expose
-* the `tableXxx` methods — they're only on the raw `ISettingsBackend`.
-* Same constraint that drives `IntegrationRegistry` to take a direct
-* provider reference instead of going through the cap.
+* `config` is declared `JSON`, so the store hands the surface an object and
+* gets an object back. There is deliberately NO `node_id` column — `nodeId`
+* rides inside the blob under a reserved key (see {@link NODE_ID_CONFIG_KEY}),
+* because a newly-declared column would put this table through
+* `declareCollection`'s destructive rebuild and wipe operator customizations
+* such as `recordings:default`'s `minFreePercent`.
+*/
+var STORAGE_LOCATIONS_COLUMNS = [
+	{
+		name: "id",
+		type: "TEXT",
+		primaryKey: true
+	},
+	{
+		name: "type",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "display_name",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "provider_id",
+		type: "TEXT",
+		notNull: true
+	},
+	{
+		name: "config",
+		type: "JSON",
+		notNull: true,
+		defaultValue: "{}"
+	},
+	{
+		name: "is_default",
+		type: "INTEGER",
+		notNull: true,
+		defaultValue: 0
+	},
+	{
+		name: "is_system",
+		type: "INTEGER",
+		notNull: true,
+		defaultValue: 0
+	},
+	{
+		name: "created_at",
+		type: "INTEGER",
+		notNull: true
+	},
+	{
+		name: "updated_at",
+		type: "INTEGER",
+		notNull: true
+	}
+];
+var STORAGE_LOCATIONS_INDEXES = [{
+	name: "idx_storage_locations_type",
+	columns: ["type"]
+}];
+/**
+* `ILocationStore` on the `settings-store` collection surface — the same door
+* every other consumer uses. It holds the `data-store-provider` engine object
+* directly (not the `settings-store` singleton) because since D44 the
+* storage-orchestrator IS that singleton, and asking the registry for it would
+* route this table back through the orchestrator itself.
 */
 var SqliteLocationStore = class {
-	backend;
-	tableEnsured = false;
-	constructor(backend) {
-		this.backend = backend;
+	store;
+	declared = false;
+	constructor(store) {
+		this.store = store;
 	}
 	/**
-	* Lazy `ensureTable` — keeps the constructor cheap and async-free.
-	* Called from every mutation/read path; the backend's `ensureTable`
-	* is itself idempotent (additive migration), so repeated calls are
-	* effectively no-ops after the first.
+	* Lazy `declareCollection` — keeps the constructor cheap and async-free.
+	* Called from every mutation/read path; `declareCollection` is idempotent
+	* (and additive on shape changes), so repeated calls collapse to a no-op.
 	*/
-	async ensureTable() {
-		if (this.tableEnsured) return;
-		if (!this.backend.ensureTable) throw new Error("SqliteLocationStore: settings backend does not implement ensureTable — expected the SQLite settings backend, got a backend without structured-table support");
-		await this.backend.ensureTable(STORAGE_LOCATIONS_TABLE, STORAGE_LOCATIONS_SCHEMA);
-		this.tableEnsured = true;
+	async ensureDeclared() {
+		if (this.declared) return;
+		await this.store.declareCollection({
+			collection: STORAGE_LOCATIONS,
+			columns: STORAGE_LOCATIONS_COLUMNS,
+			indexes: STORAGE_LOCATIONS_INDEXES
+		});
+		this.declared = true;
 	}
 	async loadAll() {
-		await this.ensureTable();
-		if (!this.backend.tableQuery) return [];
-		const rows = await this.backend.tableQuery(STORAGE_LOCATIONS_TABLE, { orderBy: {
-			field: "created_at",
-			direction: "asc"
-		} });
+		await this.ensureDeclared();
+		const rows = await this.store.query({
+			collection: STORAGE_LOCATIONS,
+			filter: { orderBy: {
+				field: "created_at",
+				direction: "asc"
+			} }
+		});
 		const out = [];
 		for (const row of rows) {
-			const mapped = mapRowToLocation(row);
+			const mapped = mapRowToLocation(row.data);
 			if (mapped) out.push(mapped);
 		}
 		return out;
 	}
 	/**
-	* Replace-or-insert. Implemented as `delete` + `insert` rather than
-	* the conditional `tableUpdate` path because the orchestrator
-	* serializes every mutation through the in-memory map before
-	* dispatching to the store — there's no contention to lose, and the
-	* delete-then-insert path is unconditionally simpler.
+	* Replace-or-insert. Implemented as delete + insert rather than a
+	* conditional update because the orchestrator serializes every mutation
+	* through the in-memory map before dispatching to the store — there's no
+	* contention to lose, and delete-then-insert is unconditionally simpler.
 	*/
 	async upsert(loc) {
-		await this.ensureTable();
-		if (!this.backend.tableDelete || !this.backend.tableInsert) throw new Error("SqliteLocationStore: backend missing tableDelete/tableInsert");
-		await this.backend.tableDelete(STORAGE_LOCATIONS_TABLE, { id: loc.id });
-		await this.backend.tableInsert(STORAGE_LOCATIONS_TABLE, mapLocationToRow(loc));
+		await this.ensureDeclared();
+		await this.store.deleteWhere({
+			collection: STORAGE_LOCATIONS,
+			filter: { where: { id: loc.id } }
+		});
+		await this.store.insert({
+			collection: STORAGE_LOCATIONS,
+			record: {
+				id: loc.id,
+				data: mapLocationToRow(loc)
+			}
+		});
 	}
 	async delete(id) {
-		await this.ensureTable();
-		if (!this.backend.tableDelete) throw new Error("SqliteLocationStore: backend missing tableDelete");
-		await this.backend.tableDelete(STORAGE_LOCATIONS_TABLE, { id });
+		await this.ensureDeclared();
+		await this.store.deleteWhere({
+			collection: STORAGE_LOCATIONS,
+			filter: { where: { id } }
+		});
 	}
 };
+function isPlainObject(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readConfig(raw) {
+	if (isPlainObject(raw)) return { ...raw };
+	if (typeof raw === "string" && raw.length > 0) return require_dist.parseJsonObject(raw) ?? {};
+	return {};
+}
 function mapLocationToRow(loc) {
 	const storedConfig = loc.nodeId !== void 0 ? {
 		...loc.config,
@@ -677,7 +699,7 @@ function mapLocationToRow(loc) {
 		type: loc.type,
 		display_name: loc.displayName,
 		provider_id: loc.providerId,
-		config: JSON.stringify(storedConfig),
+		config: storedConfig,
 		is_default: loc.isDefault ? 1 : 0,
 		is_system: loc.isSystem ? 1 : 0,
 		created_at: loc.createdAt,
@@ -685,11 +707,9 @@ function mapLocationToRow(loc) {
 	};
 }
 /**
-* Decode a row read from the structured table. Returns `null` when the
-* row's `type` doesn't parse against the Zod enum — the caller skips
-* the row and logs. Defensive against schema drift across upgrades
-* (e.g. an older build wrote a since-removed `recordings-archive`
-* type and the new build no longer recognises it).
+* Decode a row read from the collection. Returns `null` when the row's `type`
+* fails the id-format schema or the row has no id — a corrupt row (hand-edited,
+* partial migration) is skipped rather than taking the boot read down with it.
 */
 function mapRowToLocation(row) {
 	const typeRaw = row["type"];
@@ -698,8 +718,7 @@ function mapRowToLocation(row) {
 	const type = parsedType.data;
 	const id = String(row["id"] ?? "");
 	if (!id) return null;
-	const configRaw = row["config"];
-	const storedConfig = typeof configRaw === "string" && configRaw.length > 0 ? require_dist.parseJsonObject(configRaw) ?? {} : {};
+	const storedConfig = readConfig(row["config"]);
 	const nodeIdRaw = storedConfig[NODE_ID_CONFIG_KEY];
 	const nodeId = typeof nodeIdRaw === "string" && nodeIdRaw.length > 0 ? nodeIdRaw : void 0;
 	const config = { ...storedConfig };
@@ -1210,26 +1229,16 @@ var StorageOrchestratorAddon = class extends require_dist.BaseAddon {
 	* addon *is* that singleton, so asking the registry for it would hand
 	* the orchestrator its own dispatcher and route its location table back
 	* through itself.
-	*
-	* The `ensureTable` / `tableInsert` reach-around below is the B2 bypass,
-	* still open: those six methods live on the concrete backend and on no
-	* cap. Promoting them to the door is a separate task; until then this
-	* holds the engine object directly, which only works because the engine
-	* is in-process on this node.
 	*/
 	resolveLocationStore(quiet = false) {
 		const reg = this.ctx.kernel.capabilityRegistry;
 		if (!reg) return null;
-		const backend = reg.getCollection(DATA_STORE_PROVIDER_CAP_NAME)[0];
-		if (!backend) {
+		const engine = reg.getCollection(DATA_STORE_PROVIDER_CAP_NAME)[0];
+		if (!engine) {
 			if (!quiet) this.ctx.logger.warn("storage-orchestrator: no data-store-provider engine yet — running in-memory until one registers");
 			return null;
 		}
-		if (!backend.ensureTable || !backend.tableInsert) {
-			if (!quiet) this.ctx.logger.warn("storage-orchestrator: settings backend lacks structured-table support — running in-memory only");
-			return null;
-		}
-		return new SqliteLocationStore(backend);
+		return new SqliteLocationStore(engine);
 	}
 	/**
 	* Late-wire the persistence store once a `data-store-provider` engine