@camstack/system 1.2.29 → 1.2.31

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-CPmFYLqq.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 };
@@ -770,6 +789,8 @@ function createDataStoreDispatch(getEngines) {
 		insert: async (input) => (await engine()).insert(input),
 		update: async (input) => (await engine()).update(input),
 		delete: async (input) => (await engine()).delete(input),
+		deleteWhere: async (input) => (await engine()).deleteWhere(input),
+		updateWhere: async (input) => (await engine()).updateWhere(input),
 		count: async (input) => (await engine()).count(input),
 		histogram: async (input) => (await engine()).histogram(input),
 		isEmpty: async (input) => (await engine()).isEmpty(input),
@@ -1208,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