Add dataset library, extract-to-dataset, and render-time reference resolution

src/app/services/RelationshipService.test.ts

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, test } from 'vitest';
+import { createDataset } from '@core/dataset';
+import { createSnippet } from '@core/snippet';
+import { useDatasetStore } from '../stores/DatasetStore';
+import { useSnippetStore } from '../stores/SnippetStore';
+import {
+  datasetUsageCount,
+  findSnippetsReferencingDataset,
+  renameDatasetEverywhere,
+} from './RelationshipService';
+
+const T = new Date('2026-06-01T00:00:00Z');
+
+/** Seed a snippet whose published spec references `datasetName`. */
+function seedSnippet(id: string, datasetName: string) {
+  return createSnippet({
+    id,
+    spec: JSON.stringify({ data: { name: datasetName }, mark: 'bar' }),
+    now: T,
+  });
+}
+
+beforeEach(() => {
+  useDatasetStore.getState().reset();
+  useSnippetStore.getState().reset();
+});
+
+describe('reverse lookup', () => {
+  test('finds referencing snippets case-insensitively and counts them', () => {
+    useSnippetStore.getState().hydrate([seedSnippet('a', 'Sales'), seedSnippet('b', 'SALES')], 'a');
+    // datasetRefs are recomputed on publish; publish each active snippet to seed.
+    useSnippetStore.getState().publish(T);
+    useSnippetStore.getState().selectSnippet('b');
+    useSnippetStore.getState().publish(T);
+
+    expect(
+      findSnippetsReferencingDataset('sales')
+        .map((s) => s.id)
+        .sort(),
+    ).toEqual(['a', 'b']);
+    expect(datasetUsageCount('Sales')).toBe(2);
+    expect(datasetUsageCount('Other')).toBe(0);
+  });
+});
+
+describe('renameDatasetEverywhere', () => {
+  test('renames the dataset record and every referencing snippet', () => {
+    useDatasetStore
+      .getState()
+      .add(
+        createDataset({
+          name: 'Sales',
+          data: [{ a: 1 }],
+          format: 'json',
+          source: 'inline',
+          now: T,
+        }),
+      );
+    useSnippetStore.getState().hydrate([seedSnippet('a', 'Sales')], 'a');
+    useSnippetStore.getState().publish(T);
+
+    const updated = renameDatasetEverywhere('Sales', 'Revenue', new Date('2026-07-01T00:00:00Z'));
+
+    expect(updated).toBe(1);
+    expect(useDatasetStore.getState().datasets[0].name).toBe('Revenue');
+    const s = useSnippetStore.getState().snippets[0];
+    expect(s.datasetRefs).toEqual(['Revenue']);
+    expect(s.spec).toContain('"Revenue"');
+  });
+
+  test('is a no-op when old and new names are equal', () => {
+    expect(renameDatasetEverywhere('Sales', 'Sales')).toBe(0);
+  });
+});

src/app/services/RelationshipService.ts

@@ -0,0 +1,54 @@
+/**
+ * Snippet ↔ dataset relationships (docs/architecture/07 §4 + §6).
+ *
+ * The bidirectional link is name-based and has a single source of truth: a
+ * snippet's `datasetRefs` (recomputed from its published spec). The reverse
+ * direction — "which snippets use this dataset" — is therefore DERIVED by a scan,
+ * never stored, so it can't drift. Rename is the one graph operation: it renames
+ * the dataset record and propagates the new name into every referencing snippet's
+ * spec/draftSpec/refs.
+ *
+ * These functions read and mutate Zustand stores, so they live in the app layer
+ * (the pure rewrite/extraction helpers they build on live in `core/spec-refs`).
+ */
+
+import type { Snippet } from '@core/snippet';
+import { useDatasetStore } from '../stores/DatasetStore';
+import { useSnippetStore } from '../stores/SnippetStore';
+
+// TODO: nothing in production calls this service yet — DatasetsModal derives
+// usage/linked-snippets inline (it must read `snippets` reactively, not via the
+// getState snapshot these use), and DatasetStore.save propagates rename itself
+// (it updates other fields besides the name, so it can't delegate cleanly).
+// `renameDatasetEverywhere` also matches by exact name, unlike the rest of the
+// case-insensitive naming policy, and arch/07 documents it returning `{ updated }`
+// not a bare number. Either reconcile the duplication (extract a reactive-friendly
+// pure `snippetsReferencing(snippets, name)` helper both sides share) or fold this
+// service in when M4's "Build Chart from dataset" needs a non-reactive caller.
+
+/** Snippets whose `datasetRefs` include `name` (case-insensitive). */
+export function findSnippetsReferencingDataset(name: string): Snippet[] {
+  const lower = name.toLowerCase();
+  return useSnippetStore
+    .getState()
+    .snippets.filter((s) => s.datasetRefs.some((ref) => ref.toLowerCase() === lower));
+}
+
+/** Count for the dataset usage badge (spec §05 → List item). */
+export function datasetUsageCount(name: string): number {
+  return findSnippetsReferencingDataset(name).length;
+}
+
+/**
+ * Rename a dataset and propagate everywhere (docs/architecture/07 §6): renames
+ * the dataset record, then rewrites every referencing snippet's spec, draftSpec,
+ * and datasetRefs. The caller is responsible for collision policy on `newName`
+ * (the edit form rejects a taken name; programmatic paths pre-resolve a unique
+ * one). Returns the number of snippets updated.
+ */
+export function renameDatasetEverywhere(oldName: string, newName: string, now?: Date): number {
+  if (oldName === newName) return 0;
+  const dataset = useDatasetStore.getState().datasets.find((d) => d.name === oldName);
+  if (dataset) useDatasetStore.getState().update(dataset.id, { name: newName }, now);
+  return useSnippetStore.getState().renameDatasetRefs(oldName, newName, now);
+}