@littlebigbrain/client 0.1.0 → 0.3.0

package/dist/client.test.js

@@ -1,591 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { LbbClient, LbbError, parseSparqlResults } from "./client.js";
-function recordingFetch(responses = { status: 200, body: "{}" }) {
-    const calls = [];
-    const queue = Array.isArray(responses) ? [...responses] : [responses];
-    const fallback = Array.isArray(responses) ? responses[responses.length - 1] : responses;
-    const fetch = async (input, init) => {
-        calls.push({ input, init: init ?? {} });
-        const next = queue.shift() ?? fallback ?? {};
-        const status = next.status ?? 200;
-        const headers = new Map(Object.entries(next.headers ?? {}).map(([key, value]) => [key.toLowerCase(), value]));
-        return {
-            ok: status >= 200 && status < 300,
-            status,
-            headers: { get: (name) => headers.get(name.toLowerCase()) ?? null },
-            text: async () => next.body ?? "{}",
-        };
-    };
-    return { fetch, calls };
-}
-test("namespace facts.create injects auth, scope, version, and idempotency", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            graph_created: false,
-            idempotency_key: "ik_test_1",
-            commit: {
-                commit_seq: 1,
-                visibility_token: "snap:1",
-                observation_ids: [],
-                entity_ids: [],
-                edge_event_ids: [],
-                indexed: false,
-                idempotent_replay: false,
-                no_op: true,
-                skipped_edges: [],
-            },
-        }),
-    });
-    const client = new LbbClient({
-        baseUrl: "http://h:7400/",
-        apiKey: "lbb_sk_test_client",
-        fetch,
-    });
-    const result = await client.graph("main", { branch: "b" }).facts.create({ triplets: [] }, { idempotencyKey: "ik_test_1" });
-    assert.equal(result.commit.commit_seq, 1);
-    assert.equal(result.commit.no_op, true);
-    assert.deepEqual(result.commit.skipped_edges, []);
-    const [call] = calls;
-    assert.equal(call.input, "http://h:7400/v1/graph/commit?graph=main&branch=b");
-    assert.equal(call.init.method, "POST");
-    assert.equal(call.init.headers?.authorization, "Bearer lbb_sk_test_client");
-    assert.equal(call.init.headers?.["content-type"], "application/json");
-    assert.equal(call.init.headers?.["lbb-version"], "2026-06-22");
-    assert.equal(call.init.headers?.["idempotency-key"], "ik_test_1");
-    assert.deepEqual(JSON.parse(call.init.body ?? ""), { triplets: [] });
-});
-test("sparqlText sends row paging fields and exposes row_page", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            results: JSON.stringify({ head: { vars: ["s"] }, results: { bindings: [] } }),
-            row_page: {
-                returned: 50,
-                total: 611,
-                offset: 100,
-                limit: 50,
-                has_more: true,
-                next_offset: 150,
-            },
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const result = await client.sparqlText({
-        query: "SELECT ?s WHERE { ?s ?p ?o }",
-        limit: 50,
-        offset: 100,
-    });
-    assert.equal(calls[0].input, "http://h/v1/query/sparql-text?graph=main");
-    assert.deepEqual(JSON.parse(calls[0].init.body ?? ""), {
-        query: "SELECT ?s WHERE { ?s ?p ?o }",
-        limit: 50,
-        offset: 100,
-    });
-    assert.equal(result.row_page.returned, 50);
-    assert.equal(result.row_page.total, 611);
-    assert.equal(result.row_page.next_offset, 150);
-});
-test("graphEdges scopes and pages an entity's edges", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            object: "list",
-            data: [],
-            has_more: true,
-            next_cursor: "300",
-            snapshot: {},
-            total_count: 782,
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const result = await client.graphEdges({
-        type: "PERSON",
-        name: "ada",
-        direction: "out",
-        limit: 150,
-        cursor: 150,
-        asOfCommitSeq: 42,
-    });
-    const input = calls[0].input;
-    assert.match(input, /^http:\/\/h\/v1\/graph\/edges\?/);
-    assert.match(input, /type=PERSON/);
-    assert.match(input, /name=ada/);
-    assert.match(input, /direction=out/);
-    assert.match(input, /cursor=150/);
-    assert.match(input, /as_of_commit_seq=42/);
-    assert.equal(result.total_count, 782);
-    assert.equal(result.next_cursor, "300");
-});
-test("commitDryRun sends dry_run=true and no idempotency key", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({ dry_run: true, op_count: 2, triplets: 1, entity_properties: 0 }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const result = await client.commitDryRun({ triplets: [] });
-    assert.match(calls[0].input, /dry_run=true/);
-    assert.equal(calls[0].init.headers["idempotency-key"], undefined);
-    assert.equal(result.dry_run, true);
-    assert.equal(result.op_count, 2);
-});
-test("entities.list projects fields and bulk-fetches ids in one call", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            object: "list",
-            data: [{ name: "ada", attributes: { title: "VP" } }],
-            has_more: false,
-            next_cursor: null,
-            snapshot: {},
-            total_count: 1,
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const page = await client.entities.list({ fields: ["title", "status"], ids: ["abc", "def"] });
-    assert.match(calls[0].input, /fields=title%2Cstatus/);
-    assert.match(calls[0].input, /ids=abc%2Cdef/);
-    assert.equal(page.total_count, 1);
-});
-test("entities.filterByAttributes builds structured SPARQL property filters", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            vars: ["svc"],
-            solutions: [],
-            groups: [],
-            snapshot: {},
-            row_page: { returned: 0, total: 0, offset: 0, limit: 50, has_more: false },
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    await client.entities.filterByAttributes({
-        patterns: [
-            {
-                subject: { var: "svc" },
-                predicate: "WRITES_TO",
-                object: { var: "db" },
-            },
-        ],
-        where: [
-            { field: "slo", op: "ge", value: 0.99 },
-            { var: "db", field: "tier", value: "prod" },
-        ],
-        select: ["svc"],
-        limit: 25,
-    });
-    assert.equal(calls[0].input, "http://h/v1/query/sparql?graph=main");
-    assert.deepEqual(JSON.parse(calls[0].init.body ?? ""), {
-        patterns: [
-            {
-                subject: { var: "svc" },
-                predicate: "WRITES_TO",
-                object: { var: "db" },
-            },
-        ],
-        filters: [
-            {
-                compare: {
-                    op: "ge",
-                    left: { property: { var: "svc", field: "slo" } },
-                    right: { value: { f64: 0.99 } },
-                },
-            },
-            {
-                compare: {
-                    op: "eq",
-                    left: { property: { var: "db", field: "tier" } },
-                    right: { value: { str: "prod" } },
-                },
-            },
-        ],
-        select: ["svc"],
-        limit: 25,
-    });
-});
-test("ontologyView opts into per-relation counts only when asked", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({ relation_defs: [] }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    await client.ontologyView();
-    await client.ontologyView({ counts: true });
-    assert.equal(calls[0].input, "http://h/v1/ontology?graph=main");
-    assert.match(calls[1].input, /^http:\/\/h\/v1\/ontology\?/);
-    assert.match(calls[1].input, /counts=true/);
-});
-test("sparqlRows parses SELECT bindings into typed terms and flat rows", async () => {
-    const { fetch } = recordingFetch({
-        body: JSON.stringify({
-            results: JSON.stringify({
-                head: { vars: ["s", "o"] },
-                results: {
-                    bindings: [
-                        {
-                            s: { type: "uri", value: "https://littlebigbrain.com/e/a" },
-                            o: { type: "literal", value: "Acme" },
-                        },
-                        // Sparse row: `o` unbound and omitted, per the spec.
-                        { s: { type: "uri", value: "https://littlebigbrain.com/e/b" } },
-                    ],
-                },
-            }),
-            row_page: { returned: 2, total: 2, offset: 0, limit: 50, has_more: false },
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const result = await client.sparqlRows({ query: "SELECT ?s ?o WHERE { ?s ?p ?o }" });
-    assert.deepEqual(result.vars, ["s", "o"]);
-    assert.equal(result.boolean, null);
-    assert.equal(result.bindings.length, 2);
-    assert.equal(result.bindings[0].s.type, "uri");
-    assert.deepEqual(result.rows, [
-        { s: "https://littlebigbrain.com/e/a", o: "Acme" },
-        { s: "https://littlebigbrain.com/e/b" },
-    ]);
-});
-test("parseSparqlResults surfaces the ASK boolean", () => {
-    const parsed = parseSparqlResults({
-        results: JSON.stringify({ head: {}, boolean: true }),
-        row_page: { returned: 0, total: 0, offset: 0, limit: 0, has_more: false },
-    });
-    assert.equal(parsed.boolean, true);
-    assert.deepEqual(parsed.rows, []);
-});
-test("search.hybrid encodes the v1 GET search route", async () => {
-    const { fetch, calls } = recordingFetch();
-    const client = new LbbClient({ baseUrl: "http://h", fetch });
-    await client.search.hybrid("customer identity", {
-        topK: 5,
-        source: "persisted",
-        consistency: "strong",
-        lexical: false,
-        bm25: true,
-        vector: true,
-        targets: ["concepts", "entities"],
-    });
-    const input = calls[0].input;
-    assert.match(input, /^http:\/\/h\/v1\/search\?/);
-    assert.match(input, /query=customer%20identity/);
-    assert.match(input, /top_k=5/);
-    assert.match(input, /source=persisted/);
-    assert.match(input, /consistency=strong/);
-    assert.match(input, /lexical=false/);
-    assert.match(input, /bm25=true/);
-    assert.match(input, /vector=true/);
-    assert.match(input, /targets=concepts%2Centities/);
-});
-test("search.feedback posts labels with idempotency", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            accepted: 1,
-            commit_seq: 2,
-            visibility_token: "acme:main:main:0:2",
-            feedback_graph: { tenant_id: "acme", graph_id: "__lbb_feedback", branch_id: "main" },
-            idempotent_replay: false,
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "crm", branch: "main", fetch });
-    await client.search.feedback({
-        query: "identity records",
-        labels: [
-            {
-                target: {
-                    kind: "entity",
-                    entity: { entity_type: "ACCOUNT", name: "Acme" },
-                },
-                grade: 3,
-            },
-        ],
-    }, { idempotencyKey: "fb_1" });
-    const [call] = calls;
-    assert.equal(call.input, "http://h/v1/search/feedback?graph=crm&branch=main");
-    assert.equal(call.init.method, "POST");
-    assert.equal(call.init.headers?.["idempotency-key"], "fb_1");
-    assert.deepEqual(JSON.parse(call.init.body ?? ""), {
-        query: "identity records",
-        labels: [
-            {
-                target: {
-                    kind: "entity",
-                    entity: { entity_type: "ACCOUNT", name: "Acme" },
-                },
-                grade: 3,
-            },
-        ],
-    });
-});
-test("search.feedbackExport reads scoped feedback rows", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({ rows: [], counts: {}, graph: {}, feedback_graph: {} }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "crm", branch: "main", fetch });
-    await client.search.feedbackExport();
-    assert.equal(calls[0].input, "http://h/v1/search/feedback/export?graph=crm&branch=main");
-    assert.equal(calls[0].init.method, "GET");
-});
-test("entities namespace encodes list filters", async () => {
-    const { fetch, calls } = recordingFetch({ body: JSON.stringify({ entities: [] }) });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", branch: "b", fetch });
-    await client.entities.list({ type: "SERVICE", limit: 10, query: "billing" });
-    const input = calls[0].input;
-    assert.match(input, /^http:\/\/h\/v1\/graph\/entities\?/);
-    assert.match(input, /graph=main/);
-    assert.match(input, /branch=b/);
-    assert.match(input, /type=SERVICE/);
-    assert.match(input, /limit=10/);
-    assert.match(input, /q=billing/);
-});
-test("entities namespace encodes detail lookups", async () => {
-    const entity = { id: "01", type: "SERVICE", name: "billing-api" };
-    const snapshot = { commit_seq: 3, indexed_seq: 0 };
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            snapshot,
-            entity,
-            attributes: { status: "synced" },
-            metadata: {
-                snapshot,
-                entity,
-                last_commit: 3,
-                object_hash: "blake3:test",
-                object_key: "wal/test.graphwal.zst",
-                object_kind: "wal",
-            },
-            current_state: [],
-            outgoing: [],
-            incoming: [],
-            history: [],
-            observations: [],
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", branch: "b", fetch });
-    const detail = await client.entities.detail({ type: "SERVICE", name: "billing-api" });
-    const input = calls[0].input;
-    assert.match(input, /^http:\/\/h\/v1\/graph\/entity\?/);
-    assert.match(input, /graph=main/);
-    assert.match(input, /branch=b/);
-    assert.match(input, /type=SERVICE/);
-    assert.match(input, /name=billing-api/);
-    assert.equal(detail.attributes?.status, "synced");
-});
-test("schema namespace uses v1 schema routes", async () => {
-    const { fetch, calls } = recordingFetch({ body: JSON.stringify({ conforms: true }) });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    await client.schema.view();
-    await client.schema.view({ audit: true });
-    await client.schema.preview({ desired_mode: "warn" });
-    await client.schema.publish({ preview_digest: "sha256:test", desired_mode: "warn" });
-    await client.schema.audit();
-    assert.equal(calls[0].input, "http://h/v1/schema?graph=main");
-    assert.equal(calls[1].input, "http://h/v1/schema?graph=main&audit=true");
-    assert.equal(calls[2].input, "http://h/v1/schema/preview?graph=main");
-    assert.equal(calls[2].init.method, "POST");
-    assert.deepEqual(JSON.parse(calls[2].init.body ?? ""), { desired_mode: "warn" });
-    assert.equal(calls[3].input, "http://h/v1/schema/publish?graph=main");
-    assert.equal(calls[4].input, "http://h/v1/schema/audit?graph=main");
-});
-test("creates graph and forks branch with scoped v1 URLs", async () => {
-    const { fetch, calls } = recordingFetch();
-    const client = new LbbClient({
-        baseUrl: "http://h",
-        graph: "research",
-        branch: "analysis",
-        fetch,
-    });
-    await client.createGraph();
-    await client.createBranch({ from_branch: "main" });
-    assert.equal(calls[0].input, "http://h/v1/graph/create?graph=research&branch=analysis");
-    assert.equal(calls[1].input, "http://h/v1/graph/branch?graph=research&branch=analysis");
-    assert.equal(calls[1].init.method, "POST");
-    assert.deepEqual(JSON.parse(calls[1].init.body ?? ""), { from_branch: "main" });
-});
-test("rawRequest returns request metadata", async () => {
-    const { fetch } = recordingFetch({
-        body: JSON.stringify({ ok: true }),
-        headers: { "x-request-id": "req_123", "lbb-version": "2026-06-22" },
-    });
-    const client = new LbbClient({ baseUrl: "http://h", fetch });
-    const response = await client.rawRequest("GET", "/v1/status");
-    assert.deepEqual(response.data, { ok: true });
-    assert.equal(response.status, 200);
-    assert.equal(response.requestId, "req_123");
-    assert.equal(response.version, "2026-06-22");
-});
-test("retries retryable failures", async () => {
-    const { fetch, calls } = recordingFetch([
-        { status: 503, body: JSON.stringify({ error: { message: "retry", code: "api_error" } }) },
-        { status: 200, body: JSON.stringify({ ok: true }) },
-    ]);
-    const client = new LbbClient({ baseUrl: "http://h", fetch, maxRetries: 1, retryDelayMs: 0 });
-    await client.status();
-    assert.equal(calls.length, 2);
-});
-test("does not retry unsafe writes without an idempotency key", async () => {
-    const { fetch, calls } = recordingFetch([
-        { status: 503, body: JSON.stringify({ error: { message: "retry", code: "api_error" } }) },
-        { status: 200, body: JSON.stringify({ ok: true }) },
-    ]);
-    const client = new LbbClient({ baseUrl: "http://h", fetch, maxRetries: 1, retryDelayMs: 0 });
-    await assert.rejects(() => client.graph("main").create());
-    assert.equal(calls.length, 1);
-});
-test("retries idempotency-keyed writes", async () => {
-    const { fetch, calls } = recordingFetch([
-        { status: 503, body: JSON.stringify({ error: { message: "retry", code: "api_error" } }) },
-        { status: 200, body: JSON.stringify({ ok: true }) },
-    ]);
-    const client = new LbbClient({ baseUrl: "http://h", fetch, maxRetries: 1, retryDelayMs: 0 });
-    await client.graph("main").facts.create({ triplets: [] }, { idempotencyKey: "retry-safe" });
-    assert.equal(calls.length, 2);
-    assert.equal(calls[0].init.headers?.["idempotency-key"], "retry-safe");
-    assert.equal(calls[1].init.headers?.["idempotency-key"], "retry-safe");
-});
-test("throws typed LbbError on structured errors", async () => {
-    const { fetch } = recordingFetch({
-        status: 401,
-        body: JSON.stringify({
-            error: {
-                type: "auth_error",
-                code: "unauthorized",
-                message: "missing bearer",
-                param: null,
-                request_id: "req_body",
-                doc_url: "https://littlebigbrain.com/errors/unauthorized",
-            },
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", fetch });
-    await assert.rejects(() => client.status(), (error) => error instanceof LbbError &&
-        error.status === 401 &&
-        error.code === "unauthorized" &&
-        error.type === "auth_error" &&
-        error.requestId === "req_body" &&
-        error.message === "missing bearer");
-});
-test("database admin helpers stay on admin routes and bearer auth", async () => {
-    const { fetch, calls } = recordingFetch({
-        body: JSON.stringify({
-            ok: true,
-            stack: {
-                slug: "acme",
-                stack_id: "stk",
-                tenant_id: "acme",
-                name: "Acme",
-                default_graph: "main",
-                default_branch: "main",
-                created_at_micros: 1,
-                api_key_hint: "…",
-                api_key_rotated_at_micros: 1,
-            },
-            api_key: "lbb_sk_test_client",
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", apiKey: "admin", fetch });
-    await client.adminCreateStack({ owner_id: "acct_1", name: "Acme", slug: "acme" });
-    await client.adminRotateStackKey("acme");
-    await client.adminStackActivity("acme", "4h");
-    await client.stackActivity("1h");
-    assert.equal(calls[0].input, "http://h/api/admin/stacks");
-    assert.equal(calls[1].input, "http://h/api/admin/stacks/rotate-key?stack=acme");
-    assert.equal(calls[2].input, "http://h/api/admin/stacks/activity?stack=acme&window=4h");
-    assert.equal(calls[3].input, "http://h/v1/stack/activity?window=1h");
-    assert.equal(calls[0].init.headers?.authorization, "Bearer admin");
-    assert.deepEqual(JSON.parse(calls[0].init.body ?? ""), {
-        owner_id: "acct_1",
-        name: "Acme",
-        slug: "acme",
-    });
-});
-test("facts.import serializes lines to NDJSON with batch/strict params", async () => {
-    const { fetch, calls } = recordingFetch({
-        status: 200,
-        body: JSON.stringify({
-            graph_created: false,
-            lines_read: 2,
-            triplets: 1,
-            properties: 1,
-            batches: 1,
-            indexed: false,
-            error_count: 0,
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const result = await client.graph("main").facts.import([
-        {
-            source: { type: "Author", name: "Ada", key: "orcid:1" },
-            relation: "AFFILIATED_WITH",
-            target: { type: "University", name: "Cambridge", key: "ror:1" },
-        },
-        { type: "Author", name: "Ada", key: "orcid:1", properties: { h_index: 52 } },
-    ], { batch: 500, strict: true });
-    assert.equal(result.triplets, 1);
-    const call = calls[0];
-    assert.match(call.input, /\/v1\/graph\/import\?/);
-    assert.match(call.input, /batch=500/);
-    assert.match(call.input, /strict=true/);
-    assert.equal(call.init.headers?.["content-type"], "application/x-ndjson");
-    // Body is newline-delimited JSON, one object per line.
-    const lines = (call.init.body ?? "").split("\n");
-    assert.equal(lines.length, 2);
-    assert.equal(JSON.parse(lines[0]).relation, "AFFILIATED_WITH");
-    assert.equal(JSON.parse(lines[1]).properties.h_index, 52);
-});
-test("facts.importRdf posts N-Triples through the native RDF endpoint", async () => {
-    const { fetch, calls } = recordingFetch({
-        status: 200,
-        body: JSON.stringify({
-            graph_created: false,
-            lines_read: 1,
-            triples_read: 1,
-            resource_triples: 1,
-            literal_triples: 0,
-            duplicate_resource_triples: 0,
-            duplicate_literal_triples: 0,
-            imported_triplets: 1,
-            batches: 1,
-            indexed: false,
-            predicate_count: 1,
-            predicates: [],
-            error_count: 0,
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const body = "<http://ex/s> <http://ex/p> <http://ex/o> .\n";
-    const result = await client.graph("main").facts.importRdf(body, {
-        batch: 500,
-        strict: true,
-        resourceType: "RdfResource",
-        edgeIdempotency: "append",
-    });
-    assert.equal(result.imported_triplets, 1);
-    const call = calls[0];
-    assert.match(call.input, /\/v1\/graph\/import\/rdf\?/);
-    assert.match(call.input, /batch=500/);
-    assert.match(call.input, /strict=true/);
-    assert.match(call.input, /format=ntriples/);
-    assert.match(call.input, /resource_type=RdfResource/);
-    assert.match(call.input, /edge_idempotency=append/);
-    assert.equal(call.init.headers?.["content-type"], "application/n-triples");
-    assert.equal(call.init.body, body);
-});
-test("graph.retract posts edge/entity retractions", async () => {
-    const { fetch, calls } = recordingFetch({
-        status: 200,
-        body: JSON.stringify({
-            commit_seq: 4,
-            visibility_token: "tok",
-            retracted_edges: 1,
-            retracted_entities: 0,
-        }),
-    });
-    const client = new LbbClient({ baseUrl: "http://h", graph: "main", fetch });
-    const result = await client.graph("main").retract({
-        edges: [
-            {
-                source: { type: "Author", name: "Ada" },
-                relation: "AFFILIATED_WITH",
-                target: { type: "University", name: "Cambridge" },
-            },
-        ],
-    });
-    assert.equal(result.retracted_edges, 1);
-    assert.match(calls[0].input, /\/v1\/graph\/retract\?graph=main/);
-    assert.equal(calls[0].init.method, "POST");
-    assert.ok(calls[0].init.headers?.["idempotency-key"], "retract gets an idempotency key");
-});

package/dist/contract-routes.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/contract-routes.test.js

@@ -1,74 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-// Contract-drift guard for the hand-written TS client surface (S8). The
-// generated types (schema.ts) are gated by the `contracts` CI job, but the
-// hand-written `this.request("METHOD", "/path")` calls embed route strings
-// nothing checks. This asserts every literal route the client issues is either
-// a real operation in contracts/openapi.json or an explicitly allow-listed
-// control-plane route.
-//
-// `npm test` runs from the package dir, so cwd is packages/lbb-client.
-const REPO_ROOT = resolve(process.cwd(), "../..");
-const OPENAPI = resolve(REPO_ROOT, "contracts/openapi.json");
-const CLIENT = resolve(process.cwd(), "src/client.ts");
-// Control-plane routes the TS client legitimately calls that are intentionally
-// NOT in the public data-plane OpenAPI contract (SaaS admin/session
-// orchestration). This allow-list is the visible debt register: adding a route
-// here is a conscious decision to leave it uncontracted.
-const UNCONTRACTED = new Set([
-    "DELETE /api/admin/stacks",
-    "GET /api/admin/stacks",
-    "GET /api/admin/stacks/activity",
-    "GET /v1/stack/activity",
-    "POST /api/admin/sessions",
-    "POST /api/admin/stacks",
-    "POST /api/admin/stacks/rotate-key",
-]);
-const HTTP_METHODS = new Set(["get", "post", "put", "patch", "delete"]);
-function specOperations() {
-    const spec = JSON.parse(readFileSync(OPENAPI, "utf8"));
-    const ops = new Set();
-    for (const [path, methods] of Object.entries(spec.paths)) {
-        for (const method of Object.keys(methods)) {
-            if (HTTP_METHODS.has(method.toLowerCase())) {
-                ops.add(`${method.toUpperCase()} ${path}`);
-            }
-        }
-    }
-    return ops;
-}
-function clientRoutes() {
-    // Matches `this.request("POST", "/v1/graph/commit"`; only static string-literal
-    // paths are captured (template-literal path-param routes are covered by the
-    // methods that build them and are invisible here).
-    const source = readFileSync(CLIENT, "utf8");
-    const re = /request\(\s*"([A-Z]+)",\s*"([^"]+)"/g;
-    const routes = new Set();
-    let match;
-    while ((match = re.exec(source)) !== null) {
-        routes.add(`${match[1]} ${match[2]}`);
-    }
-    return routes;
-}
-test("every TS client route is contracted or explicitly allow-listed", () => {
-    const spec = specOperations();
-    const routes = clientRoutes();
-    assert.ok(routes.size > 0, "no request routes parsed from client.ts");
-    const missing = [...routes]
-        .filter((route) => !spec.has(route) && !UNCONTRACTED.has(route))
-        .sort();
-    assert.deepEqual(missing, [], `client calls route(s) absent from contracts/openapi.json and not allow-listed ` +
-        `(typo or removed route?): ${missing.join(", ")}`);
-});
-test("the uncontracted allow-list has no stale entries", () => {
-    // Prune an allow-listed route the client no longer calls, or that has since
-    // been added to the contract — keep the debt register honest.
-    const spec = specOperations();
-    const routes = clientRoutes();
-    const stale = [...UNCONTRACTED]
-        .filter((route) => !routes.has(route) || spec.has(route))
-        .sort();
-    assert.deepEqual(stale, [], `stale allow-list entries (client no longer calls, or now contracted): ${stale.join(", ")}`);
-});