@x12i/catalox 3.0.0 → 3.1.1

package/README.md

@@ -8,6 +8,8 @@ Catalox is a **data-tier** package for managing **app-scoped catalogs** in Fireb
 - **Mapped catalogs** (items normalized from MongoDB or APIs)
 - **References + validation contracts** (standardized cross-catalog shapes)
 - **Seed/import/export + batch upsert** workflows for native catalogs
+- **Optional per-record native history** — NDJSON payloads in GCS plus a Firestore `catalogItemHistory` index; list/show/restore/replay APIs and `catalox history …` ([`docs/record-history.md`](docs/record-history.md))
+- **Optional catalog lifecycle** — hard delete (with manifest), restore from manifest, and hard rename across collections; APIs + `catalox catalog …` ([`docs/catalog-crud.md`](docs/catalog-crud.md))
 - **Optional GCS tools** — NDJSON export/import of Firestore collections to a bucket, **compare** live data vs bucket snapshots, **`backupData` mode `gcs`** (Catalox-shaped NDJSON + manifest under a bucket prefix), and matching CLI commands (`firestore export-gcs`, `import-gcs`, `compare-gcs`, `firestore backup --mode gcs`; see [`docs/firestore-gcs-export.md`](docs/firestore-gcs-export.md), [`docs/backup.md`](docs/backup.md))
 
 Catalox **does not** own UI, workflow orchestration, remote execution, artifact blobs, or secret storage.
@@ -83,6 +85,9 @@ GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
 FIREBASE_SERVICE_ACCOUNT_PATH=/path/to/service-account.json
 FIREBASE_PROJECT_ID=your-project-id
 FIRESTORE_LIVE_TESTS=1
+# Optional: record-history live test + CLI (`createCatalox`); use a dedicated test bucket:
+# CATALOX_RECORD_HISTORY_BUCKET=your-test-bucket
+# CATALOX_RECORD_HISTORY_PREFIX=catalox-record-history/
 # Optional defaults for the packaged `catalox` CLI (Catalox app/store context, not GCP):
 # CATALOX_APP_ID=myAppId
 # CATALOX_STORE_ID=myStoreId
@@ -98,6 +103,9 @@ The `catalox` binary loads `.env` via `dotenv`. Use **`CATALOX_*`** for **Catalo
 - **`CATALOX_STORE_ID`** — Default `storeId` for **`report`** and **`export`** when `--store` is omitted (`--store` overrides).
 - **`CATALOX_USER_ID`** — Optional user id / actor for authz-sensitive CLI paths.
 - **`CATALOX_MONGO_URI`** — If set, enables the Mongo catalog adapter in the CLI (wired via **`createCatalox`** in `src/catalox/create-catalox.ts`, called from `src/cli/index.ts`).
+- **`CATALOX_RECORD_HISTORY_BUCKET`** — If set, **`createCatalox`** wires **`recordHistory`** (GCS payloads + **`catalogItemHistory`** on native writes; also required for **`catalox history …`** to persist new events).
+- **`CATALOX_RECORD_HISTORY_PREFIX`** — Optional GCS prefix for record history (default `catalox-record-history/`).
+- **`CATALOX_RECORD_HISTORY_FAIL_CLOSED`** — When **`1`**, failed history writes fail the parent Firestore mutation.
 
 **Running commands from this repository:** the shell command `catalox` is only on your `PATH` if the package is installed globally (`npm i -g @x12i/catalox`) or linked (`npm link` from this repo). Otherwise, after `npm run build`, use:
 
@@ -120,6 +128,13 @@ npm run cli -- firestore report-native-layout --app "narrix"
 | `firestore export-gcs` / `import-gcs` | NDJSON per collection + optional manifest ([`docs/firestore-gcs-export.md`](docs/firestore-gcs-export.md)). |
 | `firestore compare-gcs` | Diff live Firestore vs bucket NDJSON (single collection or manifest). |
 
+#### `history` / `catalog` CLI (3.1+)
+
+| Command | Purpose |
+|---------|---------|
+| `history list` / `history show` / `history restore` / `history replay` | Per-record native history from **`catalogItemHistory`** + GCS ([`docs/record-history.md`](docs/record-history.md)). |
+| `catalog delete` / `catalog restore` / `catalog rename` | Hard delete with manifest, restore from manifest, or hard rename ([`docs/catalog-crud.md`](docs/catalog-crud.md)). |
+
 ## Firestore data model (logical collections)
 
 For a **full layout** (subcollections, document id conventions, snapshot runs, and query notes), see [`docs/firestore-data-model.md`](docs/firestore-data-model.md). For **native** catalogs specifically (per-catalog `catalogData-*-items`, layout resolution, `listCatalogItems`, filters, troubleshooting), see [`docs/native-catalog-storage-and-api.md`](docs/native-catalog-storage-and-api.md).
@@ -136,6 +151,7 @@ Metadata:
 - `catalogDescriptors/{catalogId}` (**descriptor metadata** for generic consumption)
 - `catalogRendererSnippets/{catalogId}:{role}[:{mode}]` (**stored renderer snippets** for list/grid/item/report/dashboard rendering)
 - `catalogReferences/{referenceId}` (standardized reference records)
+- `catalogItemHistory/{eventId}` (optional **native write history** index; payloads in GCS — [`docs/record-history.md`](docs/record-history.md))
 
 Data:
 
@@ -162,7 +178,11 @@ import { createCatalox } from "@x12i/catalox";
 import { getFirestore } from "firebase-admin/firestore";
 
 const firestore = getFirestore();
-const catalox = createCatalox({ firestore });
+const catalox = createCatalox({
+  firestore,
+  // Optional: per-record native history to GCS + `catalogItemHistory` (or set CATALOX_RECORD_HISTORY_BUCKET for CLI)
+  // recordHistory: { gcsBucket: "my-bucket", gcsPrefix: "catalox-record-history/" },
+});
 
 // Optional: bind app/tenant context once (no globals; same semantics as passing context each call).
 const scoped = catalox.withContext({ appId: "myApp" });
@@ -355,7 +375,7 @@ Catalox includes provisioning helpers to reduce “manual Firestore wiring”.
 ### Create a native catalog (also seeds a minimal descriptor)
 
 ```ts
-const ctx = { appId: "myAppId", isGodMode: true }; // or bind admin access appropriately
+const ctx = { appId: "myAppId", superAdmin: true }; // set only after host auth; often from AppRecord.superAdminApp
 
 await catalox.createCatalog(ctx, {
   catalogId: "signals",
@@ -485,7 +505,7 @@ Validation APIs exist with standardized contracts, but **current behavior is min
 
 ## Publishing
 
-From a clean tree, **`npm publish`** runs **`prepublishOnly`**, which executes **`npm run build`** then **`npm test`** (unit tests). Ensure `dist/` is build output only; the published tarball includes **`dist`**, **`README.md`**, and **`LICENSE`** per `package.json` **`files`**.
+From a clean tree, **`npm publish`** runs **`prepublishOnly`**, which executes **`npm run build`** then **`npm test`** (unit tests). Ensure `dist/` is build output only; the published tarball includes **`dist`**, **`README.md`**, **`LICENSE`**, and **`firestore.indexes.json`** (composite indexes for `catalogItemHistory` queries) per `package.json` **`files`**.
 
 ## Tests
 
@@ -507,16 +527,29 @@ Integration tests are **live-only** (no mocks, no emulators). They require:
 - `FIREBASE_SERVICE_ACCOUNT_PATH=...`
 - `FIREBASE_PROJECT_ID=...`
 
-The **`Firestore live integration`** test (`test/integration/firestore.emulator.test.ts`) uses **`createCatalox`** and asserts v3 contracts: **`listCatalogItems`** returns **`listOutcome: "ok"`**, and **`getCatalogItem`** returns **`{ outcome: "found", item }`** for the seeded row.
+The **`Firestore live integration`** test (`test/integration/firestore.emulator.test.ts`) uses **`createCatalox`** and asserts v3 contracts: **`listCatalogItems`** returns **`listOutcome: "ok"`**, and **`getCatalogItem`** returns **`{ outcome: "found", item }`** for the seeded row. The descriptor patch in that test includes **`queryableFields` with `indexed: true`** for filtered fields so **`deriveIndexed`** persists **`indexed.*`** (see **Canonical `indexed` rule** above).
+
+When **`CATALOX_RECORD_HISTORY_BUCKET`** is set, **`test/integration/record-history.live.test.ts`** runs as well: ephemeral app/catalog, **`upsert` → `update` → `listCatalogItemHistory` → `getCatalogItemHistoryEvent` → `restoreCatalogItemFromHistory`**, then best-effort Firestore + GCS cleanup for the created history objects.
 
 ### Live test safety (read before running)
 
 - **Never run against production credentials/projects.** Use a dedicated Firebase project for tests.
-- **Touched collections**: `apps`, `catalogs`, `catalogBindings`, `catalogDefinitions`, `catalogDescriptors`, `catalogData/{catalogId}`, and `catalogData-{catalogId}-items/...`. The **`catalox firestore restore-backup`** / **`undo-restore-backup`** commands additionally write `backup-restoreSessions` and `{restoreSessionId}__preRestore-*` sidecar collections (see [`docs/restore-firestore-backup.md`](docs/restore-firestore-backup.md)).
+- **Touched collections**: `apps`, `catalogs`, `catalogBindings`, `catalogDefinitions`, `catalogDescriptors`, `catalogData/{catalogId}`, `catalogData-{catalogId}-items/...`, and (when record history is enabled) `catalogItemHistory/...`. The **`catalox firestore restore-backup`** / **`undo-restore-backup`** commands additionally write `backup-restoreSessions` and `{restoreSessionId}__preRestore-*` sidecar collections (see [`docs/restore-firestore-backup.md`](docs/restore-firestore-backup.md)).
 - **Cleanup**: tests do best-effort deletes of the docs they created, but do not guarantee full teardown.
 
 ## Changelog
 
+### 3.1.1
+
+- **Live tests:** Firestore integration test now sets **`queryableFields`** on the patched descriptor so equality filters match stored **`indexed.*`** rows (same rule as production descriptors).
+- **Live tests:** Record-history integration test covers **update**, **get event**, **restore**, and **GCS object** cleanup when a bucket is configured.
+- **Package:** publish **`firestore.indexes.json`** in the npm tarball for operators deploying **`catalogItemHistory`** queries.
+
+### 3.1.0
+
+- **Per-record history:** optional **`recordHistory`** on **`createCatalox`** (or **`CATALOX_RECORD_HISTORY_*`** env for CLI) writes **GCS NDJSON** + Firestore **`catalogItemHistory`** on native upsert/update/delete/batch/move. APIs: **`listCatalogItemHistory`**, **`getCatalogItemHistoryEvent`**, **`restoreCatalogItemFromHistory`**, **`replayCatalogToPointInTime`**. CLI: **`catalox history …`**. See [`docs/record-history.md`](docs/record-history.md), [`firestore.indexes.json`](firestore.indexes.json).
+- **Catalog lifecycle:** **`deleteCatalog`**, **`restoreDeletedCatalog`**, **`renameCatalog`** (hard rename) + CLI **`catalox catalog …`**. See [`docs/catalog-crud.md`](docs/catalog-crud.md).
+
 ### 3.0.0
 
 - **`createCatalox(config)`** — single factory for Firestore-backed stores, authz, optional Mongo/API adapters, optional renderer snippet store (`src/catalox/create-catalox.ts`).

package/dist/src/catalox/authorization.js

@@ -6,7 +6,7 @@ export class AuthorizationService {
         this.bindings = bindings;
     }
     async requireBindingAccess(context, appId, catalogId, required) {
-        if (context.isGodMode) {
+        if (context.superAdmin) {
             // God-mode policy: bypass binding for read/admin checks if needed.
             // We still return a synthetic binding for uniformity.
             return {

package/dist/src/catalox/authorization.js.map

@@ -1 +1 @@
-{"version":3,"file":"authorization.js","sourceRoot":"","sources":["../../../src/catalox/authorization.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAI5D,MAAM,OAAO,oBAAoB;IACF;IAA7B,YAA6B,QAAsB;QAAtB,aAAQ,GAAR,QAAQ,CAAc;IAAG,CAAC;IAEvD,KAAK,CAAC,oBAAoB,CACxB,OAAuB,EACvB,KAAY,EACZ,SAAoB,EACpB,QAAwB;QAExB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,mEAAmE;YACnE,sDAAsD;YACtD,OAAO;gBACL,SAAS,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,EAAE;gBAClD,KAAK;gBACL,SAAS;gBACT,MAAM,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE;gBACzD,MAAM,EAAE,QAAQ;gBAChB,SAAS,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;gBACpC,SAAS,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;aACrC,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACvE,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC5C,MAAM,IAAI,wBAAwB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;QACpG,CAAC;QAED,MAAM,EAAE,GACN,QAAQ,KAAK,MAAM;YACjB,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;YACjC,CAAC,CAAC,QAAQ,KAAK,OAAO;gBACpB,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;gBAClC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEzC,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,MAAM,IAAI,wBAAwB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;QACrE,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;CACF"}
+{"version":3,"file":"authorization.js","sourceRoot":"","sources":["../../../src/catalox/authorization.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAI5D,MAAM,OAAO,oBAAoB;IACF;IAA7B,YAA6B,QAAsB;QAAtB,aAAQ,GAAR,QAAQ,CAAc;IAAG,CAAC;IAEvD,KAAK,CAAC,oBAAoB,CACxB,OAAuB,EACvB,KAAY,EACZ,SAAoB,EACpB,QAAwB;QAExB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;YACvB,mEAAmE;YACnE,sDAAsD;YACtD,OAAO;gBACL,SAAS,EAAE,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,EAAE;gBAClD,KAAK;gBACL,SAAS;gBACT,MAAM,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE;gBACzD,MAAM,EAAE,QAAQ;gBAChB,SAAS,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;gBACpC,SAAS,EAAE,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;aACrC,CAAC;QACJ,CAAC;QAED,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,QAAQ,CAAC,gBAAgB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;QACvE,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YAC5C,MAAM,IAAI,wBAAwB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,+BAA+B,EAAE,CAAC,CAAC;QACpG,CAAC;QAED,MAAM,EAAE,GACN,QAAQ,KAAK,MAAM;YACjB,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC;YACjC,CAAC,CAAC,QAAQ,KAAK,OAAO;gBACpB,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;gBAClC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QAEzC,IAAI,CAAC,EAAE,EAAE,CAAC;YACR,MAAM,IAAI,wBAAwB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;QACrE,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;CACF"}

package/dist/src/catalox/catalog-lifecycle.d.ts

@@ -0,0 +1,29 @@
+import type { CatalogId } from "../contracts/ids.js";
+import type { DeleteCatalogInput, DeleteCatalogResult, RenameCatalogInput, RenameCatalogResult, RestoreDeletedCatalogInput, RestoreDeletedCatalogResult } from "../contracts/catalog-lifecycle.js";
+import type { CataloxContext } from "../contracts/context.js";
+import { AdapterStore } from "../firebase/adapter-store.js";
+import { CatalogDataIndexStore } from "../firebase/catalog-data-index-store.js";
+import { DefinitionStore } from "../firebase/definition-store.js";
+import { DescriptorStore } from "../firebase/descriptor-store.js";
+import { MappingStore } from "../firebase/mapping-store.js";
+import { NativeItemStore } from "../firebase/native-item-store.js";
+import { ReferenceStore } from "../firebase/reference-store.js";
+import { RendererSnippetStore } from "../firebase/renderer-snippet-store.js";
+import { SnapshotStore } from "../firebase/snapshot-store.js";
+import { type BackupDataDeps } from "./backup-data.js";
+import { type RecordHistoryDeps } from "./record-history.js";
+export type CatalogLifecycleDeps = BackupDataDeps & {
+    definitions: DefinitionStore;
+    descriptors: DescriptorStore;
+    mappings: MappingStore;
+    adapters: AdapterStore;
+    references: ReferenceStore;
+    nativeItems: NativeItemStore;
+    snapshots: SnapshotStore;
+    catalogDataIndex: CatalogDataIndexStore;
+    rendererSnippets?: RendererSnippetStore;
+};
+export declare function runDeleteCatalog(deps: CatalogLifecycleDeps, recordHistory: RecordHistoryDeps | undefined, context: CataloxContext, catalogId: CatalogId, input: DeleteCatalogInput): Promise<DeleteCatalogResult>;
+export declare function runRestoreDeletedCatalog(deps: CatalogLifecycleDeps, recordHistory: RecordHistoryDeps, input: RestoreDeletedCatalogInput): Promise<RestoreDeletedCatalogResult>;
+export declare function runRenameCatalog(deps: CatalogLifecycleDeps, recordHistory: RecordHistoryDeps | undefined, context: CataloxContext, fromCatalogId: CatalogId, toCatalogId: CatalogId, input: RenameCatalogInput): Promise<RenameCatalogResult>;
+//# sourceMappingURL=catalog-lifecycle.d.ts.map

package/dist/src/catalox/catalog-lifecycle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-lifecycle.d.ts","sourceRoot":"","sources":["../../../src/catalox/catalog-lifecycle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAEV,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,mBAAmB,EACnB,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,mCAAmC,CAAC;AAQ3C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAQ9D,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAEhF,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,oBAAoB,GAAG,cAAc,GAAG;IAClD,WAAW,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,eAAe,CAAC;IAC7B,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,YAAY,CAAC;IACvB,UAAU,EAAE,cAAc,CAAC;IAC3B,WAAW,EAAE,eAAe,CAAC;IAC7B,SAAS,EAAE,aAAa,CAAC;IACzB,gBAAgB,EAAE,qBAAqB,CAAC;IACxC,gBAAgB,CAAC,EAAE,oBAAoB,CAAC;CACzC,CAAC;AAwDF,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,oBAAoB,EAC1B,aAAa,EAAE,iBAAiB,GAAG,SAAS,EAC5C,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAoL9B;AAED,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,oBAAoB,EAC1B,aAAa,EAAE,iBAAiB,EAChC,KAAK,EAAE,0BAA0B,GAChC,OAAO,CAAC,2BAA2B,CAAC,CAuFtC;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,oBAAoB,EAC1B,aAAa,EAAE,iBAAiB,GAAG,SAAS,EAC5C,OAAO,EAAE,cAAc,EACvB,aAAa,EAAE,SAAS,EACxB,WAAW,EAAE,SAAS,EACtB,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAgM9B"}

package/dist/src/catalox/catalog-lifecycle.js

@@ -0,0 +1,480 @@
+import { AdapterStore } from "../firebase/adapter-store.js";
+import { BindingStore } from "../firebase/binding-store.js";
+import { CatalogDataIndexStore } from "../firebase/catalog-data-index-store.js";
+import { CatalogStore } from "../firebase/catalog-store.js";
+import { DefinitionStore } from "../firebase/definition-store.js";
+import { DescriptorStore } from "../firebase/descriptor-store.js";
+import { MappingStore } from "../firebase/mapping-store.js";
+import { NativeItemStore } from "../firebase/native-item-store.js";
+import { ReferenceStore } from "../firebase/reference-store.js";
+import { RendererSnippetStore } from "../firebase/renderer-snippet-store.js";
+import { SnapshotStore } from "../firebase/snapshot-store.js";
+import { deleteAllDocsInFirestoreCollection, formatBackupTimestamp, runBackupData, } from "./backup-data.js";
+import { buildRecordHistoryGcsClient, emitRecordHistoryEventWithCustomPath, } from "./record-history.js";
+import { nativeItemsCollectionId } from "../firebase/catalog-data-paths.js";
+function gcsUploadJson(gcs, rel, body) {
+    return gcs.uploadObject(rel, JSON.stringify(body, null, 2), { contentType: "application/json", resumable: false });
+}
+function gcsUploadNdjson(gcs, rel, lines) {
+    const body = lines.length ? `${lines.join("\n")}\n` : "";
+    return gcs.uploadObject(rel, body, { contentType: "application/x-ndjson", resumable: false });
+}
+async function deleteCatalogSnapshotsSubtree(fs, catalogId) {
+    const root = fs.collection("catalogSnapshots").doc(String(catalogId));
+    const runsSnap = await root.collection("runs").get();
+    for (const runDoc of runsSnap.docs) {
+        await deleteAllDocsInFirestoreCollection(fs, runDoc.ref.collection("items").path);
+        await runDoc.ref.delete();
+    }
+    await deleteAllDocsInFirestoreCollection(fs, root.collection("items").path);
+    await root.delete();
+}
+async function listAllNativeItems(nativeItems, catalogId) {
+    const out = [];
+    let offset = 0;
+    const page = 400;
+    while (true) {
+        const chunk = await nativeItems.list(catalogId, { limit: page, offset });
+        if (!chunk.length)
+            break;
+        out.push(...chunk);
+        offset += chunk.length;
+        if (chunk.length < page)
+            break;
+    }
+    return out;
+}
+async function readJsonArtifact(gcs, rel) {
+    if (!rel)
+        return null;
+    try {
+        const buf = await gcs.readObjectBuffer(rel);
+        return JSON.parse(buf.toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function readNdjsonLines(gcs, rel) {
+    const buf = await gcs.readObjectBuffer(rel);
+    const text = buf.toString("utf8").trim();
+    if (!text)
+        return [];
+    return text.split("\n").map((l) => l.trim()).filter(Boolean);
+}
+export async function runDeleteCatalog(deps, recordHistory, context, catalogId, input) {
+    const issues = [];
+    const cid = String(catalogId);
+    if (!recordHistory) {
+        return {
+            ok: false,
+            catalogId,
+            issues: [
+                {
+                    code: "record_history_required",
+                    message: "deleteCatalog requires Catalox `recordHistory` (configure `recordHistory` in createCatalox or set CATALOX_RECORD_HISTORY_BUCKET).",
+                },
+            ],
+        };
+    }
+    const cat = await deps.catalogs.get(catalogId);
+    if (!cat) {
+        return { ok: false, catalogId, issues: [{ code: "catalog_not_found", message: `No catalogs/${cid}` }] };
+    }
+    if (input.gcsBackupBucket?.trim()) {
+        const br = await runBackupData(deps, {
+            mode: "gcs",
+            gcsBucket: input.gcsBackupBucket.trim(),
+            ...(input.gcsBackupPrefix != null ? { gcsPrefix: input.gcsBackupPrefix } : {}),
+            catalogIds: [catalogId],
+            appId: context.appId,
+            backupLabel: `pre-delete-${cid}`,
+        });
+        if (!br.ok) {
+            issues.push({ code: "backup_failed", message: br.issues?.[0]?.message ?? "backupData failed" });
+        }
+    }
+    const ts = formatBackupTimestamp();
+    const folder = `catalogs/${cid}/${ts}__catalog-delete`;
+    const gcs = buildRecordHistoryGcsClient(recordHistory);
+    const nativeRows = await listAllNativeItems(deps.nativeItems, catalogId);
+    const descriptor = await deps.descriptors.get(catalogId);
+    const definition = await deps.definitions.get(catalogId);
+    const idx = await deps.catalogDataIndex.get(catalogId);
+    const bindings = await deps.bindings.listByCatalog(catalogId);
+    const refs = await deps.references.listReferencingCatalog(catalogId);
+    const snippets = deps.rendererSnippets ? await deps.rendererSnippets.listByCatalogPrefix(catalogId) : [];
+    const snapItems = await deps.snapshots.listAllCurrentItems(catalogId);
+    const runs = await deps.snapshots.listRuns(catalogId, 500);
+    const runLines = [];
+    const runItemLines = [];
+    for (const r of runs) {
+        runLines.push(JSON.stringify(r));
+        const items = await deps.snapshots.listRunItems(catalogId, r.runId);
+        for (const it of items) {
+            runItemLines.push(JSON.stringify({ runId: r.runId, itemId: it.itemId, record: it }));
+        }
+    }
+    let mappingRec = null;
+    let adapterRec = null;
+    if (definition?.type === "mapped") {
+        const md = definition;
+        if (md.mappingId)
+            mappingRec = (await deps.mappings.get(md.mappingId));
+        if (md.adapterId)
+            adapterRec = (await deps.adapters.get(md.adapterId));
+    }
+    const artifacts = {
+        catalog: `${folder}/catalog.json`,
+        catalogDataIndex: `${folder}/catalogDataIndex.json`,
+        nativeItemsNdjson: `${folder}/native-items.ndjson`,
+        bindingsNdjson: `${folder}/bindings.ndjson`,
+        referencesNdjson: `${folder}/references.ndjson`,
+        rendererSnippetsNdjson: `${folder}/renderer-snippets.ndjson`,
+        snapshotItemsNdjson: `${folder}/snapshot-items.ndjson`,
+        snapshotRunsNdjson: `${folder}/snapshot-runs.ndjson`,
+        snapshotRunItemsNdjson: `${folder}/snapshot-run-items.ndjson`,
+    };
+    if (descriptor) {
+        artifacts.descriptor = `${folder}/descriptor.json`;
+        await gcsUploadJson(gcs, artifacts.descriptor, descriptor);
+    }
+    if (definition) {
+        artifacts.definition = `${folder}/definition.json`;
+        await gcsUploadJson(gcs, artifacts.definition, definition);
+    }
+    if (mappingRec) {
+        artifacts.mapping = `${folder}/mapping.json`;
+        await gcsUploadJson(gcs, artifacts.mapping, mappingRec);
+    }
+    if (adapterRec) {
+        artifacts.adapter = `${folder}/adapter.json`;
+        await gcsUploadJson(gcs, artifacts.adapter, adapterRec);
+    }
+    await gcsUploadJson(gcs, artifacts.catalog, cat);
+    if (idx)
+        await gcsUploadJson(gcs, artifacts.catalogDataIndex, idx);
+    await gcsUploadNdjson(gcs, artifacts.nativeItemsNdjson, nativeRows.map((r) => JSON.stringify(r)));
+    await gcsUploadNdjson(gcs, artifacts.bindingsNdjson, bindings.map((b) => JSON.stringify(b)));
+    await gcsUploadNdjson(gcs, artifacts.referencesNdjson, refs.map((r) => JSON.stringify(r)));
+    await gcsUploadNdjson(gcs, artifacts.rendererSnippetsNdjson, snippets.map((s) => JSON.stringify(s)));
+    await gcsUploadNdjson(gcs, artifacts.snapshotItemsNdjson, snapItems.map((s) => JSON.stringify(s)));
+    await gcsUploadNdjson(gcs, artifacts.snapshotRunsNdjson, runLines);
+    await gcsUploadNdjson(gcs, artifacts.snapshotRunItemsNdjson, runItemLines);
+    const manifest = {
+        schemaVersion: 1,
+        kind: "catalox_catalog_delete",
+        catalogId: cid,
+        deletedAt: new Date().toISOString(),
+        artifacts,
+    };
+    const manifestRel = `${folder}/manifest.json`;
+    await gcsUploadJson(gcs, manifestRel, manifest);
+    await emitRecordHistoryEventWithCustomPath(recordHistory, context, {
+        gcsRelativePath: `${folder}/catalog-delete-event.ndjson`,
+        catalogId,
+        itemId: "__catalog__",
+        op: "catalog_delete_bulk",
+        manifest: { manifestRelativePath: manifestRel, folder },
+    });
+    const fs = deps.firestoreStore.firestore;
+    try {
+        await deleteAllDocsInFirestoreCollection(fs, nativeItemsCollectionId(catalogId));
+        try {
+            await deleteAllDocsInFirestoreCollection(fs, fs.collection("catalogData").doc(cid).collection("items").path);
+        }
+        catch {
+            /* ignore missing legacy */
+        }
+        await deleteCatalogSnapshotsSubtree(fs, catalogId);
+        if (deps.rendererSnippets) {
+            for (const s of snippets) {
+                const docId = `${String(s.catalogId)}:${String(s.role)}${s.mode ? `:${String(s.mode)}` : ""}`;
+                await deps.rendererSnippets.deleteDoc(docId);
+            }
+        }
+        for (const r of refs)
+            await deps.references.delete(r.referenceId);
+        for (const b of bindings)
+            await deps.bindings.delete(b.bindingId);
+        if (descriptor)
+            await fs.collection("catalogDescriptors").doc(cid).delete();
+        if (definition) {
+            await fs.collection("catalogDefinitions").doc(cid).delete();
+            if (definition.type === "mapped") {
+                const md = definition;
+                if (md.mappingId)
+                    await deps.mappings.delete(md.mappingId);
+                if (md.adapterId)
+                    await deps.adapters.delete(md.adapterId);
+            }
+        }
+        await deps.catalogDataIndex.delete(catalogId);
+        await deps.catalogs.delete(catalogId);
+    }
+    catch (e) {
+        issues.push({ code: "firestore_delete_failed", message: e instanceof Error ? e.message : String(e) });
+        return { ok: false, catalogId, manifestRelativePath: manifestRel, issues };
+    }
+    deps.nativeItems.invalidateLayoutCache?.(catalogId);
+    return { ok: true, catalogId, manifestRelativePath: manifestRel, issues };
+}
+export async function runRestoreDeletedCatalog(deps, recordHistory, input) {
+    const issues = [];
+    const gcs = buildRecordHistoryGcsClient(recordHistory);
+    const rel = input.gcsManifestRelativePath.replace(/^\/+/, "");
+    let manifest;
+    try {
+        const raw = await gcs.readObjectBuffer(rel);
+        manifest = JSON.parse(raw.toString("utf8"));
+    }
+    catch (e) {
+        return {
+            ok: false,
+            catalogId: "",
+            issues: [{ code: "manifest_read_failed", message: e instanceof Error ? e.message : String(e) }],
+        };
+    }
+    const catalogId = manifest.catalogId;
+    const cid = String(catalogId);
+    try {
+        const cat = (await readJsonArtifact(gcs, manifest.artifacts.catalog));
+        if (cat)
+            await deps.catalogs.upsert(cat);
+        const desc = (await readJsonArtifact(gcs, manifest.artifacts.descriptor));
+        if (desc)
+            await deps.descriptors.upsert(desc);
+        const def = (await readJsonArtifact(gcs, manifest.artifacts.definition));
+        const map = manifest.artifacts.mapping
+            ? (await readJsonArtifact(gcs, manifest.artifacts.mapping))
+            : null;
+        const ad = manifest.artifacts.adapter
+            ? (await readJsonArtifact(gcs, manifest.artifacts.adapter))
+            : null;
+        if (ad)
+            await deps.adapters.upsert(ad);
+        if (map)
+            await deps.mappings.upsert(map);
+        if (def)
+            await deps.definitions.upsert(def);
+        const cdi = (await readJsonArtifact(gcs, manifest.artifacts.catalogDataIndex));
+        if (cdi)
+            await deps.catalogDataIndex.upsert(cdi);
+        const nativeLines = await readNdjsonLines(gcs, manifest.artifacts.nativeItemsNdjson);
+        for (const line of nativeLines) {
+            const rec = JSON.parse(line);
+            await deps.nativeItems.upsert(catalogId, rec);
+        }
+        const bindLines = await readNdjsonLines(gcs, manifest.artifacts.bindingsNdjson);
+        for (const line of bindLines) {
+            await deps.bindings.upsert(JSON.parse(line));
+        }
+        const refLines = await readNdjsonLines(gcs, manifest.artifacts.referencesNdjson);
+        for (const line of refLines) {
+            await deps.references.upsert(JSON.parse(line));
+        }
+        if (deps.rendererSnippets) {
+            const snipLines = await readNdjsonLines(gcs, manifest.artifacts.rendererSnippetsNdjson);
+            for (const line of snipLines) {
+                await deps.rendererSnippets.upsert(JSON.parse(line));
+            }
+        }
+        const fs = deps.firestoreStore.firestore;
+        await fs.collection("catalogSnapshots").doc(cid).set({ catalogId: cid, restoredAt: new Date().toISOString() }, { merge: true });
+        const runLs = await readNdjsonLines(gcs, manifest.artifacts.snapshotRunsNdjson);
+        for (const line of runLs) {
+            const run = JSON.parse(line);
+            await deps.snapshots.upsertRun(catalogId, run);
+        }
+        const runItemLs = await readNdjsonLines(gcs, manifest.artifacts.snapshotRunItemsNdjson);
+        for (const line of runItemLs) {
+            const { runId, record } = JSON.parse(line);
+            await deps.snapshots.upsertRunItem(catalogId, runId, record);
+        }
+        const snapLs = await readNdjsonLines(gcs, manifest.artifacts.snapshotItemsNdjson);
+        for (const line of snapLs) {
+            const rec = JSON.parse(line);
+            await deps.snapshots.upsert(catalogId, rec);
+        }
+        deps.nativeItems.invalidateLayoutCache?.(catalogId);
+        return { ok: true, catalogId, issues };
+    }
+    catch (e) {
+        issues.push({ code: "restore_failed", message: e instanceof Error ? e.message : String(e) });
+        return { ok: false, catalogId, issues };
+    }
+}
+export async function runRenameCatalog(deps, recordHistory, context, fromCatalogId, toCatalogId, input) {
+    const issues = [];
+    const from = String(fromCatalogId);
+    const to = String(toCatalogId);
+    if (!recordHistory) {
+        return {
+            ok: false,
+            fromCatalogId,
+            toCatalogId,
+            issues: [
+                {
+                    code: "record_history_required",
+                    message: "renameCatalog requires Catalox `recordHistory` (configure `recordHistory` in createCatalox or set CATALOX_RECORD_HISTORY_BUCKET).",
+                },
+            ],
+        };
+    }
+    if (from === to) {
+        return { ok: false, fromCatalogId, toCatalogId, issues: [{ code: "same_id", message: "from and to catalog ids must differ" }] };
+    }
+    const existingTo = await deps.catalogs.get(toCatalogId);
+    if (existingTo) {
+        return {
+            ok: false,
+            fromCatalogId,
+            toCatalogId,
+            issues: [{ code: "target_exists", message: `catalogs/${to} already exists` }],
+        };
+    }
+    const srcCat = await deps.catalogs.get(fromCatalogId);
+    if (!srcCat) {
+        return { ok: false, fromCatalogId, toCatalogId, issues: [{ code: "source_missing", message: `catalogs/${from} not found` }] };
+    }
+    if (input.gcsBackupBucket?.trim()) {
+        await runBackupData(deps, {
+            mode: "gcs",
+            gcsBucket: input.gcsBackupBucket.trim(),
+            ...(input.gcsBackupPrefix != null ? { gcsPrefix: input.gcsBackupPrefix } : {}),
+            catalogIds: [fromCatalogId],
+            appId: context.appId,
+            backupLabel: `pre-rename-${from}-to-${to}`,
+        });
+    }
+    const ts = formatBackupTimestamp();
+    const folder = `catalogs/${from}__to__${to}/${ts}__catalog-rename`;
+    const gcs = buildRecordHistoryGcsClient(recordHistory);
+    const nativeCount = (await listAllNativeItems(deps.nativeItems, fromCatalogId)).length;
+    const manifest = {
+        schemaVersion: 1,
+        kind: "catalox_catalog_rename",
+        fromCatalogId: from,
+        toCatalogId: to,
+        renamedAt: new Date().toISOString(),
+        folder,
+        nativeItemCount: nativeCount,
+    };
+    const manifestRel = `${folder}/manifest.json`;
+    await gcsUploadJson(gcs, manifestRel, manifest);
+    await emitRecordHistoryEventWithCustomPath(recordHistory, context, {
+        gcsRelativePath: `${folder}/catalog-rename-event.ndjson`,
+        catalogId: toCatalogId,
+        itemId: "__catalog__",
+        op: "catalog_rename",
+        manifest,
+    });
+    const fs = deps.firestoreStore.firestore;
+    try {
+        const nextCat = { ...srcCat, catalogId: toCatalogId, updatedAt: new Date().toISOString() };
+        await deps.catalogs.upsert(nextCat);
+        const desc = await deps.descriptors.get(fromCatalogId);
+        if (desc) {
+            const next = {
+                ...desc,
+                catalogId: toCatalogId,
+                descriptor: { ...desc.descriptor, catalogId: toCatalogId },
+                updatedAt: new Date().toISOString(),
+            };
+            await deps.descriptors.upsert(next);
+            await fs.collection("catalogDescriptors").doc(from).delete();
+        }
+        const def = await deps.definitions.get(fromCatalogId);
+        if (def) {
+            let nextDef = {
+                ...def,
+                catalogId: toCatalogId,
+                updatedAt: new Date().toISOString(),
+            };
+            if (def.type === "native") {
+                const n = def;
+                nextDef = {
+                    ...n,
+                    catalogId: toCatalogId,
+                    storage: { ...n.storage, collectionPath: nativeItemsCollectionId(toCatalogId) },
+                    updatedAt: new Date().toISOString(),
+                };
+            }
+            await deps.definitions.upsert(nextDef);
+            await fs.collection("catalogDefinitions").doc(from).delete();
+        }
+        const cdi = await deps.catalogDataIndex.get(fromCatalogId);
+        if (cdi) {
+            await deps.catalogDataIndex.upsert({ ...cdi, catalogId: toCatalogId, updatedAt: new Date().toISOString() });
+            await deps.catalogDataIndex.delete(fromCatalogId);
+        }
+        const rows = await listAllNativeItems(deps.nativeItems, fromCatalogId);
+        for (const r of rows) {
+            const next = { ...r, catalogId: toCatalogId };
+            await deps.nativeItems.upsert(toCatalogId, next);
+        }
+        await deleteAllDocsInFirestoreCollection(fs, nativeItemsCollectionId(fromCatalogId));
+        try {
+            await deleteAllDocsInFirestoreCollection(fs, fs.collection("catalogData").doc(from).collection("items").path);
+        }
+        catch {
+            /* ignore */
+        }
+        const runs = await deps.snapshots.listRuns(fromCatalogId, 500);
+        for (const run of runs) {
+            await deps.snapshots.upsertRun(toCatalogId, { ...run, catalogId: toCatalogId });
+            const items = await deps.snapshots.listRunItems(fromCatalogId, run.runId);
+            for (const it of items) {
+                await deps.snapshots.upsertRunItem(toCatalogId, run.runId, { ...it, catalogId: toCatalogId });
+            }
+        }
+        const snapItems = await deps.snapshots.listAllCurrentItems(fromCatalogId);
+        for (const s of snapItems) {
+            await deps.snapshots.upsert(toCatalogId, { ...s, catalogId: toCatalogId });
+        }
+        await deleteCatalogSnapshotsSubtree(fs, fromCatalogId);
+        if (deps.rendererSnippets) {
+            const snippets = await deps.rendererSnippets.listByCatalogPrefix(fromCatalogId);
+            for (const s of snippets) {
+                const oldId = `${String(s.catalogId)}:${String(s.role)}${s.mode ? `:${String(s.mode)}` : ""}`;
+                const next = { ...s, catalogId: toCatalogId };
+                await deps.rendererSnippets.upsert(next);
+                await deps.rendererSnippets.deleteDoc(oldId);
+            }
+        }
+        const refs = await deps.references.listReferencingCatalog(fromCatalogId);
+        for (const r of refs) {
+            const fc = r.fromCatalogId === from ? to : String(r.fromCatalogId);
+            const tc = r.toCatalogId === from ? to : String(r.toCatalogId);
+            const nextRefId = `${fc}:${r.fromItemId}:${r.relationType}:${tc}:${r.toItemId}`;
+            await deps.references.delete(r.referenceId);
+            await deps.references.upsert({
+                ...r,
+                referenceId: nextRefId,
+                fromCatalogId: fc,
+                toCatalogId: tc,
+                updatedAt: new Date().toISOString(),
+            });
+        }
+        const binds = await deps.bindings.listByCatalog(fromCatalogId);
+        for (const b of binds) {
+            await deps.bindings.delete(b.bindingId);
+            const nb = {
+                ...b,
+                catalogId: toCatalogId,
+                bindingId: `${String(b.appId)}:${to}`,
+                updatedAt: new Date().toISOString(),
+            };
+            await deps.bindings.upsert(nb);
+        }
+        await deps.catalogs.delete(fromCatalogId);
+        deps.nativeItems.invalidateLayoutCache?.(fromCatalogId);
+        deps.nativeItems.invalidateLayoutCache?.(toCatalogId);
+        return { ok: true, fromCatalogId, toCatalogId, manifestRelativePath: manifestRel, issues };
+    }
+    catch (e) {
+        issues.push({ code: "rename_failed", message: e instanceof Error ? e.message : String(e) });
+        return { ok: false, fromCatalogId, toCatalogId, manifestRelativePath: manifestRel, issues };
+    }
+}
+//# sourceMappingURL=catalog-lifecycle.js.map