@elytracms/studio 0.0.1

package/dist/lib/persistence/convex-adapter.js

@@ -0,0 +1,681 @@
+import { parseProjectGraph, serializeProjectGraph, PROJECT_GRAPH_SCHEMA_VERSION, } from '@elytracms/project-graph';
+import { documentKey, documentSchema } from '@elytracms/cms-core';
+import { RecordNotFoundError, PersistenceValidationError, compareReferenceEntries, validateForPersistence, } from '@elytracms/persistence';
+import { queryRef, mutationRef } from './convex-client';
+import { ConvexBlobStorage } from './convex-blob-storage';
+const realClock = () => new Date().toISOString();
+function newId(prefix) {
+    const rand = typeof globalThis.crypto?.randomUUID === 'function'
+        ? globalThis.crypto.randomUUID()
+        : Math.abs(Date.parse(new Date().toISOString())).toString(36);
+    return `${prefix}_${rand}`;
+}
+function toGraphRecord(doc) {
+    return {
+        id: String(doc._id),
+        projectId: doc.projectId,
+        revision: doc.revision,
+        serializedGraph: doc.serializedGraph,
+        schemaVersion: doc.schemaVersion,
+        createdAt: doc.createdAt,
+        ...(doc.label ? { label: doc.label } : {}),
+        ...(doc.message ? { message: doc.message } : {}),
+    };
+}
+function loadGraph(record) {
+    const parsed = parseProjectGraph(record.serializedGraph);
+    if (!parsed.ok) {
+        throw new PersistenceValidationError('Stored graph failed to parse.', [
+            { code: 'corrupt-graph', message: 'Stored graph is not parseable.', domain: 'graph' },
+        ]);
+    }
+    return { graph: parsed.graph, revision: record };
+}
+class ConvexGraphRepository {
+    client;
+    clock;
+    constructor(client, clock = realClock) {
+        this.client = client;
+        this.clock = clock;
+    }
+    async saveGraph(projectId, graph, options = {}) {
+        let serializedGraph;
+        try {
+            serializedGraph = serializeProjectGraph(graph);
+        }
+        catch (error) {
+            throw new PersistenceValidationError('Graph is not well-formed.', [
+                { code: 'invalid-graph', message: String(error), domain: 'graph' },
+            ]);
+        }
+        const doc = (await this.client.mutation(mutationRef('graphs:saveRevision'), {
+            serializedGraph,
+            schemaVersion: graph.schemaVersion ?? PROJECT_GRAPH_SCHEMA_VERSION,
+            createdAt: this.clock(),
+            ...(options.label ? { label: options.label } : {}),
+            ...(options.message ? { message: options.message } : {}),
+        }));
+        return toGraphRecord(doc);
+    }
+    async getLatest(projectId) {
+        const doc = (await this.client.query(queryRef('graphs:latest'), {}));
+        if (!doc)
+            throw new RecordNotFoundError('graph', projectId);
+        return loadGraph(toGraphRecord(doc));
+    }
+    async getRevision(projectId, revision) {
+        const doc = (await this.client.query(queryRef('graphs:revision'), {
+            revision,
+        }));
+        if (!doc)
+            throw new RecordNotFoundError('graph-revision', `${projectId}#${revision}`);
+        return loadGraph(toGraphRecord(doc));
+    }
+    async listRevisions(projectId) {
+        const docs = (await this.client.query(queryRef('graphs:listRevisions'), {}));
+        return docs.map(toGraphRecord);
+    }
+    async hasGraph(projectId) {
+        const doc = (await this.client.query(queryRef('graphs:latest'), {}));
+        return doc !== null;
+    }
+}
+// --- CMS, Assets, Publishing ----------------------------------------------
+/**
+ * Deterministic, config-owned schema timestamps (EC-183). CMS collections live
+ * in `elytra.config.ts`, not the backend, so the synthesized `CmsSchemaRecord`
+ * carries a stable placeholder rather than DB-row timestamps.
+ */
+const CONFIG_SCHEMA_TIMESTAMP = '2026-01-01T00:00:00.000Z';
+function docRecordFromDoc(doc) {
+    return {
+        projectId: doc.projectId,
+        document: doc.document,
+        ...(doc.publishedVersion !== undefined ? { publishedVersion: doc.publishedVersion } : {}),
+        createdAt: doc.createdAt,
+        updatedAt: doc.updatedAt,
+    };
+}
+/** The backend row carries no `projectId` (single-tenant); stamp it from the call. */
+function versionRecordFromDoc(doc, projectId) {
+    return {
+        projectId,
+        collection: doc.collection,
+        docId: doc.docId,
+        version: doc.version,
+        snapshot: doc.snapshot,
+        createdAt: doc.createdAt,
+        ...(doc.label ? { label: doc.label } : {}),
+    };
+}
+class ConvexCmsRepository {
+    client;
+    collections;
+    clock;
+    /**
+     * @param collections the active project's config-owned CMS collections
+     *   (EC-183, AD-11), injected from `elytra.config.ts`. The Convex backend has
+     *   no `cmsSchemas` table — `findSchema`/`getSchema` serve these instead.
+     */
+    constructor(client, collections = [], clock = realClock) {
+        this.client = client;
+        this.collections = collections;
+        this.clock = clock;
+    }
+    async saveSchema(_projectId, _collections) {
+        // Read-only (EC-183, AD-11): the CMS collection schema is owned by
+        // `elytra.config.ts`; the backend stores documents only. A write here is a
+        // visible, structured error rather than a silent no-op (the studio's CMS
+        // schema surfaces are read-only; legitimate writers were removed in EC-183).
+        throw new PersistenceValidationError('CMS collection schema is owned by elytra.config.ts and cannot be written to the backend.', [
+            {
+                code: 'schema-config-owned',
+                message: 'Edit elytra.config.ts to change collections; the backend stores documents only.',
+                path: [],
+                domain: 'cms',
+            },
+        ]);
+    }
+    /** Config-owned schema (EC-183): the active project's collections from config. */
+    configSchema(projectId) {
+        return {
+            projectId,
+            collections: [...this.collections],
+            createdAt: CONFIG_SCHEMA_TIMESTAMP,
+            updatedAt: CONFIG_SCHEMA_TIMESTAMP,
+        };
+    }
+    async getSchema(projectId) {
+        return this.configSchema(projectId);
+    }
+    async findSchema(projectId) {
+        return this.configSchema(projectId);
+    }
+    async upsertDocument(projectId, document) {
+        // The backend is a pure document store (EC-183, AD-11): collection-membership
+        // validation lives in `@elytracms/cms-core` `validateDocument`, which the studio
+        // runs pre-dispatch (cell edits, imports). We still parse the canonical
+        // document shape so malformed blobs never reach storage.
+        const parsedDoc = documentSchema.parse(document);
+        const now = this.clock();
+        const doc = (await this.client.mutation(mutationRef('cms:upsertDocument'), {
+            collection: parsedDoc.collection,
+            docId: parsedDoc.id,
+            document: parsedDoc,
+            createdAt: now,
+            updatedAt: now,
+        }));
+        return docRecordFromDoc(doc);
+    }
+    async getDocument(projectId, ref) {
+        const found = await this.findDocument(projectId, ref);
+        if (!found)
+            throw new RecordNotFoundError('cms-document', `${projectId}/${ref.collection}:${ref.id}`);
+        return found;
+    }
+    async findDocument(projectId, ref) {
+        const doc = (await this.client.query(queryRef('cms:getDocument'), {
+            collection: ref.collection,
+            docId: ref.id,
+        }));
+        return doc ? docRecordFromDoc(doc) : undefined;
+    }
+    async listDocuments(projectId, collection) {
+        const docs = (await this.client.query(queryRef('cms:listDocuments'), {
+            ...(collection ? { collection } : {}),
+        }));
+        // EC-153 parity: deterministic document-key ordering (Convex index order
+        // within a project is insertion order, so we sort client-side).
+        return docs
+            .map(docRecordFromDoc)
+            .sort((a, b) => (documentKey(a.document) < documentKey(b.document) ? -1 : 1));
+    }
+    async deleteDocument(projectId, ref) {
+        // EC-153 parity: deleting a missing document is not-found, never a no-op.
+        await this.getDocument(projectId, ref);
+        await this.client.mutation(mutationRef('cms:deleteDocument'), {
+            collection: ref.collection,
+            docId: ref.id,
+        });
+    }
+    async saveDocumentVersion(projectId, snapshot, options = {}) {
+        const parsed = documentSchema.parse(snapshot);
+        const doc = (await this.client.mutation(mutationRef('cms:saveDocumentVersion'), {
+            collection: parsed.collection,
+            docId: parsed.id,
+            snapshot: parsed,
+            createdAt: this.clock(),
+            ...(options.label ? { label: options.label } : {}),
+        }));
+        return versionRecordFromDoc(doc, projectId);
+    }
+    async listDocumentVersions(projectId, ref) {
+        const docs = (await this.client.query(queryRef('cms:listDocumentVersions'), {
+            collection: ref.collection,
+            docId: ref.id,
+        }));
+        return docs.map((doc) => versionRecordFromDoc(doc, projectId));
+    }
+    async listAllDocumentVersions(projectId) {
+        const docs = (await this.client.query(queryRef('cms:listAllDocumentVersions'), {}));
+        return docs.map((doc) => versionRecordFromDoc(doc, projectId));
+    }
+    async getDocumentVersion(projectId, ref, version) {
+        const doc = (await this.client.query(queryRef('cms:getDocumentVersion'), {
+            collection: ref.collection,
+            docId: ref.id,
+            version,
+        }));
+        if (!doc) {
+            throw new RecordNotFoundError('cms-document-version', `${projectId}/${ref.collection}:${ref.id}#${version}`);
+        }
+        return versionRecordFromDoc(doc, projectId);
+    }
+    async publishDocumentVersion(projectId, ref, version) {
+        // Taxonomy enforced adapter-side (the handler is lenient): the document and
+        // the pinned version must both exist (each throws RecordNotFoundError).
+        await this.getDocument(projectId, ref);
+        await this.getDocumentVersion(projectId, ref, version);
+        const doc = (await this.client.mutation(mutationRef('cms:publishDocumentVersion'), {
+            collection: ref.collection,
+            docId: ref.id,
+            version,
+            updatedAt: this.clock(),
+        }));
+        return docRecordFromDoc(doc);
+    }
+    async unpublishDocument(projectId, ref) {
+        const existing = await this.getDocument(projectId, ref);
+        if (existing.publishedVersion === undefined) {
+            throw new PersistenceValidationError('Document is not currently published.', [
+                {
+                    code: 'invalid-transition',
+                    message: 'Cannot unpublish: the document has no published version.',
+                    domain: 'cms',
+                },
+            ]);
+        }
+        const doc = (await this.client.mutation(mutationRef('cms:unpublishDocument'), {
+            collection: ref.collection,
+            docId: ref.id,
+            updatedAt: this.clock(),
+        }));
+        return docRecordFromDoc(doc);
+    }
+}
+/** Map a Convex asset doc onto the contract record (assetId → id, drop _id/_creationTime). */
+function assetRecordFromDoc(doc) {
+    return {
+        id: doc.assetId,
+        projectId: doc.projectId,
+        filename: doc.filename,
+        contentType: doc.contentType,
+        byteSize: doc.byteSize,
+        ...(doc.width !== undefined ? { width: doc.width } : {}),
+        ...(doc.height !== undefined ? { height: doc.height } : {}),
+        ...(doc.alt !== undefined ? { alt: doc.alt } : {}),
+        ...(doc.title !== undefined ? { title: doc.title } : {}),
+        ...(doc.url !== undefined ? { url: doc.url } : {}),
+        ...(doc.focalPoint !== undefined ? { focalPoint: doc.focalPoint } : {}),
+        storageKey: doc.storageKey,
+        createdAt: doc.createdAt,
+        updatedAt: doc.updatedAt,
+    };
+}
+class ConvexAssetRepository {
+    client;
+    clock;
+    constructor(client, clock = realClock) {
+        this.client = client;
+        this.clock = clock;
+    }
+    async upsertAsset(projectId, input) {
+        const now = this.clock();
+        const id = input.id ?? newId('asset');
+        const doc = (await this.client.mutation(mutationRef('assets:upsert'), {
+            assetId: id,
+            filename: input.filename,
+            contentType: input.contentType,
+            byteSize: input.byteSize,
+            ...(input.width !== undefined ? { width: input.width } : {}),
+            ...(input.height !== undefined ? { height: input.height } : {}),
+            ...(input.alt !== undefined ? { alt: input.alt } : {}),
+            // EC-153 parity: `title` (EC-152 metadata) must persist, not silently drop.
+            ...(input.title !== undefined ? { title: input.title } : {}),
+            ...(input.url !== undefined ? { url: input.url } : {}),
+            ...(input.focalPoint !== undefined ? { focalPoint: input.focalPoint } : {}),
+            storageKey: input.storageKey ?? `${projectId}/${id}`,
+            createdAt: now,
+            updatedAt: now,
+        }));
+        return assetRecordFromDoc(doc);
+    }
+    async getAsset(projectId, id) {
+        const found = await this.findAsset(projectId, id);
+        if (!found)
+            throw new RecordNotFoundError('asset', `${projectId}/${id}`);
+        return found;
+    }
+    async findAsset(projectId, id) {
+        const doc = (await this.client.query(queryRef('assets:get'), {
+            assetId: id,
+        }));
+        return doc ? assetRecordFromDoc(doc) : undefined;
+    }
+    async listAssets(projectId) {
+        const docs = (await this.client.query(queryRef('assets:list'), {}));
+        return docs.map(assetRecordFromDoc);
+    }
+    async removeAsset(projectId, id) {
+        // EC-153 parity: removing an unknown asset is not-found, never a no-op.
+        await this.getAsset(projectId, id);
+        await this.client.mutation(mutationRef('assets:remove'), { assetId: id });
+    }
+    async resolveMany(projectId, ids) {
+        const all = await this.listAssets(projectId);
+        const out = new Map();
+        for (const asset of all)
+            if (ids.includes(asset.id))
+                out.set(asset.id, asset);
+        return out;
+    }
+}
+/**
+ * Map a Convex publishing doc onto the contract record (drop _id/_creationTime).
+ * Single-tenant (EC-179): the stored row carries no `projectId`, so the bound
+ * slug is stamped from the adapter for the provider-neutral record shape.
+ */
+function publishingRecordFromDoc(doc, projectId) {
+    return {
+        projectId,
+        status: doc.status,
+        ...(doc.publishedRevisionId ? { publishedRevisionId: doc.publishedRevisionId } : {}),
+        ...(doc.publishedRevision !== undefined ? { publishedRevision: doc.publishedRevision } : {}),
+        ...(doc.publishedAt ? { publishedAt: doc.publishedAt } : {}),
+        createdAt: doc.createdAt,
+        updatedAt: doc.updatedAt,
+    };
+}
+class ConvexPublishingRepository {
+    client;
+    clock;
+    constructor(client, clock = realClock) {
+        this.client = client;
+        this.clock = clock;
+    }
+    async getState(projectId) {
+        const found = await this.findState(projectId);
+        if (!found)
+            throw new RecordNotFoundError('publishing-state', projectId);
+        return found;
+    }
+    async findState(projectId) {
+        const doc = (await this.client.query(queryRef('publishing:getState'), {}));
+        return doc ? publishingRecordFromDoc(doc, projectId) : undefined;
+    }
+    async publish(projectId, input) {
+        if (!input.revisionId) {
+            throw new PersistenceValidationError('Cannot publish without a graph revision.', [
+                { code: 'missing-revision', message: 'A revision id is required.', domain: 'publishing' },
+            ]);
+        }
+        // EC-153 parity: validate the revision number like the in-memory adapter.
+        if (!Number.isInteger(input.revision) || input.revision < 1) {
+            throw new PersistenceValidationError('Cannot publish an invalid revision number.', [
+                {
+                    code: 'invalid-revision',
+                    message: `Revision must be a positive integer (got ${input.revision}).`,
+                    domain: 'publishing',
+                },
+            ]);
+        }
+        const doc = (await this.client.mutation(mutationRef('publishing:publish'), {
+            revisionId: input.revisionId,
+            revision: input.revision,
+            publishedAt: this.clock(),
+        }));
+        // EC-153 parity: return the stored record (createdAt survives republish).
+        return publishingRecordFromDoc(doc, projectId);
+    }
+    async unpublish(projectId) {
+        let doc;
+        try {
+            doc = (await this.client.mutation(mutationRef('publishing:unpublish'), {
+                updatedAt: this.clock(),
+            }));
+        }
+        catch (error) {
+            // Only the backend's invalid-transition guard maps onto validation;
+            // anything else (auth, transport) keeps its own category.
+            const message = error instanceof Error ? error.message : String(error);
+            if (/invalid-transition/.test(message)) {
+                throw new PersistenceValidationError('Deployment is not currently published.', [
+                    { code: 'invalid-transition', message, domain: 'publishing' },
+                ]);
+            }
+            throw error;
+        }
+        return publishingRecordFromDoc(doc, projectId);
+    }
+}
+function referenceRecordFromDoc(doc) {
+    return {
+        projectId: doc.projectId,
+        variant: doc.variant,
+        source: { type: doc.sourceType, id: doc.sourceId },
+        path: doc.path,
+        target: { type: doc.targetType, id: doc.targetId },
+        kind: doc.kind,
+    };
+}
+/** Deterministic ordering is a repository contract; Convex docs sort client-side. */
+function sortedReferenceRecords(docs) {
+    return docs.map(referenceRecordFromDoc).sort(compareReferenceEntries);
+}
+class ConvexReferenceIndexRepository {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async replaceForSource(projectId, variant, source, references) {
+        await this.client.mutation(mutationRef('references:replaceForSource'), {
+            variant,
+            sourceType: source.type,
+            sourceId: source.id,
+            references: references.map((r) => ({
+                path: r.path,
+                targetType: r.target.type,
+                targetId: r.target.id,
+                kind: r.kind,
+            })),
+        });
+        return this.outbound(projectId, source, { variant });
+    }
+    async replaceForSourceTypes(projectId, variant, sourceTypes, entries) {
+        await this.client.mutation(mutationRef('references:replaceForSourceTypes'), {
+            variant,
+            sourceTypes: [...sourceTypes],
+            entries: entries.map((e) => ({
+                sourceType: e.source.type,
+                sourceId: e.source.id,
+                path: e.path,
+                targetType: e.target.type,
+                targetId: e.target.id,
+                kind: e.kind,
+            })),
+        });
+        const all = await this.listEntries(projectId, variant);
+        const types = new Set(sourceTypes);
+        return all.filter((record) => types.has(record.source.type));
+    }
+    async removeForSource(projectId, source, variant) {
+        await this.client.mutation(mutationRef('references:removeForSource'), {
+            sourceType: source.type,
+            sourceId: source.id,
+            ...(variant ? { variant } : {}),
+        });
+    }
+    async outbound(projectId, source, options = {}) {
+        const docs = (await this.client.query(queryRef('references:outbound'), {
+            sourceType: source.type,
+            sourceId: source.id,
+            ...(options.variant ? { variant: options.variant } : {}),
+        }));
+        return sortedReferenceRecords(docs);
+    }
+    async inbound(projectId, target, options = {}) {
+        const docs = (await this.client.query(queryRef('references:inbound'), {
+            targetType: target.type,
+            targetId: target.id,
+            ...(options.variant ? { variant: options.variant } : {}),
+        }));
+        return sortedReferenceRecords(docs);
+    }
+    async listEntries(projectId, variant) {
+        const docs = (await this.client.query(queryRef('references:list'), {
+            ...(variant ? { variant } : {}),
+        }));
+        return sortedReferenceRecords(docs);
+    }
+    async clearProject(projectId) {
+        await this.client.mutation(mutationRef('references:clearProject'), {});
+    }
+}
+/**
+ * Single-tenant (EC-179): membership is deployment-scoped, so the backend rows
+ * carry no `projectId`. The contract record still does — this adapter is bound
+ * to its deployment's project, so it stamps that slug onto every record.
+ */
+function memberRecordFromDoc(doc, projectId) {
+    return {
+        projectId,
+        userId: doc.userId,
+        role: doc.role,
+        createdAt: doc.createdAt,
+        updatedAt: doc.updatedAt,
+    };
+}
+class ConvexMembersRepository {
+    client;
+    boundProjectId;
+    clock;
+    constructor(client, 
+    /** The slug of this deployment's one project — stamped onto records. */
+    boundProjectId, clock = realClock) {
+        this.client = client;
+        this.boundProjectId = boundProjectId;
+        this.clock = clock;
+    }
+    async setMember(projectId, userId, role) {
+        const now = this.clock();
+        const doc = (await this.client.mutation(mutationRef('members:set'), {
+            userId,
+            role,
+            createdAt: now,
+            updatedAt: now,
+        }));
+        return memberRecordFromDoc(doc, projectId);
+    }
+    async findMember(projectId, userId) {
+        const doc = (await this.client.query(queryRef('members:get'), {
+            userId,
+        }));
+        return doc ? memberRecordFromDoc(doc, projectId) : undefined;
+    }
+    async listMembers(projectId) {
+        const docs = (await this.client.query(queryRef('members:list'), {}));
+        return docs.map((d) => memberRecordFromDoc(d, projectId));
+    }
+    async listMembershipsForUser(userId) {
+        // `members:mine` is caller-scoped server-side and returns the caller's single
+        // deployment membership (or null). The studio only ever asks about the
+        // session user; records are stamped with this deployment's bound project.
+        const doc = (await this.client.query(queryRef('members:mine'), {}));
+        return doc && doc.userId === userId ? [memberRecordFromDoc(doc, this.boundProjectId)] : [];
+    }
+    async removeMember(projectId, userId) {
+        try {
+            await this.client.mutation(mutationRef('members:remove'), { userId });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (/not-found/i.test(message)) {
+                throw new RecordNotFoundError('project-member', `${projectId}/${userId}`);
+            }
+            throw error;
+        }
+    }
+}
+function cliTokenRecordFromDoc(doc) {
+    return {
+        id: doc.tokenId,
+        label: doc.label,
+        tokenHash: doc.tokenHash,
+        createdAt: doc.createdAt,
+        ...(doc.revokedAt ? { revokedAt: doc.revokedAt } : {}),
+    };
+}
+class ConvexCliTokenRepository {
+    client;
+    clock;
+    constructor(client, clock = realClock) {
+        this.client = client;
+        this.clock = clock;
+    }
+    async createToken(input) {
+        const doc = (await this.client.mutation(mutationRef('cliTokens:create'), {
+            tokenId: newId('tok'),
+            label: input.label,
+            tokenHash: input.tokenHash,
+            createdAt: this.clock(),
+        }));
+        return cliTokenRecordFromDoc(doc);
+    }
+    async listTokens() {
+        const docs = (await this.client.query(queryRef('cliTokens:list'), {}));
+        return docs.map(cliTokenRecordFromDoc);
+    }
+    async revokeToken(tokenId) {
+        try {
+            const doc = (await this.client.mutation(mutationRef('cliTokens:revoke'), {
+                tokenId,
+                revokedAt: this.clock(),
+            }));
+            return cliTokenRecordFromDoc(doc);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (/not-found/i.test(message)) {
+                throw new RecordNotFoundError('cli-token', tokenId);
+            }
+            throw error;
+        }
+    }
+    async findByHash(tokenHash) {
+        const doc = (await this.client.query(queryRef('cliTokens:byHash'), {
+            tokenHash,
+        }));
+        return doc ? cliTokenRecordFromDoc(doc) : undefined;
+    }
+}
+/**
+ * Convex-backed {@link PersistenceAdapter} (brief §10, EC-039). Every repository
+ * is implemented against the Convex functions in `apps/builder/convex/*`, mapping
+ * results and failures onto the provider-neutral contracts + error taxonomies.
+ */
+export class ConvexPersistenceAdapter {
+    client;
+    graphs;
+    cms;
+    assets;
+    publishing;
+    /** Reference index — outbound/inbound entries per variant (EC-155, AD-6). */
+    references;
+    /** Per-project membership roles (EC-150). */
+    members;
+    /** Revocable CLI sync tokens, stored hashed (EC-150). */
+    cliTokens;
+    /** Convex file storage behind the EC-133 blob boundary (EC-151). */
+    blobs;
+    /**
+     * @param client      the Convex client bound to this deployment (one project).
+     * @param projectId   the slug of this deployment's one project (EC-179). Used to
+     *   stamp deployment-scoped member records onto the still-project-keyed contract.
+     * @param collections the active project's config-owned CMS collections (EC-183,
+     *   AD-11), from `elytra.config.ts`. The backend has no `cmsSchemas` table, so
+     *   the CMS repository serves the schema from these.
+     */
+    constructor(client, projectId, collections = []) {
+        this.client = client;
+        this.graphs = new ConvexGraphRepository(client);
+        this.cms = new ConvexCmsRepository(client, collections);
+        this.assets = new ConvexAssetRepository(client);
+        this.publishing = new ConvexPublishingRepository(client);
+        this.references = new ConvexReferenceIndexRepository(client);
+        this.members = new ConvexMembersRepository(client, projectId);
+        this.cliTokens = new ConvexCliTokenRepository(client);
+        this.blobs = new ConvexBlobStorage(client);
+    }
+    async status() {
+        try {
+            // Lightweight connectivity probe (EC-182: no `projects` table). `members:mine`
+            // takes no args and answers for any authenticated caller.
+            await this.client.query(queryRef('members:mine'), {});
+            return { backend: 'convex', available: true };
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            // EC-153: an `unauthorized` rejection *is* a healthy backend — the
+            // deployment answered and enforced auth. Only transport/server failures
+            // count as unavailable; the BackendGate surfaces those visibly instead
+            // of ever falling back to in-memory storage.
+            if (/unauthorized/i.test(detail))
+                return { backend: 'convex', available: true };
+            return { backend: 'convex', available: false, detail };
+        }
+    }
+    validate(input) {
+        return validateForPersistence(input);
+    }
+}
+//# sourceMappingURL=convex-adapter.js.map