ENG-2019: Extract shared cross-space node discovery into packages/database

.github/workflows/ci.yaml

@@ -37,6 +37,9 @@ jobs:
       - name: Run Tests
         run: npx turbo run test --filter=roam --ui stream
 
+      - name: Run Package Unit Tests
+        run: npx turbo run test:unit --ui stream
+
   lint-changed-files:
     if: github.event_name == 'pull_request'
     runs-on: ubuntu-latest

apps/obsidian/src/components/ImportNodesModal.tsx

@@ -67,7 +67,6 @@ const ImportNodesContent = ({ plugin, onClose }: ImportNodesModalProps) => {
 
       const publishedNodes = await getPublishedNodesForGroups({
         client,
-        groupIds,
         currentSpaceId: context.spaceId,
       });
 

apps/obsidian/src/utils/importNodes.ts

@@ -2,6 +2,7 @@ import type { Json } from "@repo/database/dbTypes";
 import matter from "gray-matter";
 import { App, Notice, TFile } from "obsidian";
 import type { DGSupabaseClient } from "@repo/database/lib/client";
+import { listGroupSharedNodes } from "@repo/database/lib/sharedNodes";
 import type DiscourseGraphPlugin from "~/index";
 import { getLoggedInClient, getSupabaseContext } from "./supabaseContext";
 import type { DiscourseNode, ImportableNode } from "~/types";
@@ -33,91 +34,40 @@ type PublishedNode = {
 
 export const getPublishedNodesForGroups = async ({
   client,
-  groupIds,
   currentSpaceId,
 }: {
   client: DGSupabaseClient;
-  groupIds: string[];
   currentSpaceId: number;
 }): Promise<Array<PublishedNode>> => {
-  if (groupIds.length === 0) {
-    return [];
-  }
-
-  // Query my_contents (RLS applied); exclude current space. Get both variants so we can use
-  // the latest last_modified per node and prefer "direct" for text (title).
-  const { data, error } = await client
-    .from("my_contents")
-    .select(
-      "source_local_id, space_id, text, created, last_modified, variant, metadata, author_id",
-    )
-    .neq("space_id", currentSpaceId);
-
-  if (error) {
+  const sharedNodes = await listGroupSharedNodes({
+    client,
+    currentSpaceId,
+  }).catch((error: { message?: string }) => {
     console.error("Error fetching published nodes:", error);
     throw new Error(`Failed to fetch published nodes: ${error.message}`);
-  }
-
-  if (!data || data.length === 0) {
-    return [];
-  }
-
-  type Row = {
-    source_local_id: string | null;
-    space_id: number | null;
-    text: string | null;
-    created: string | null;
-    last_modified: string | null;
-    variant: string | null;
-    author_id: number | null;
-    metadata: Json;
-  };
-
-  const key = (r: Row) => `${r.space_id ?? ""}\t${r.source_local_id ?? ""}`;
-  const groups = new Map<string, Row[]>();
-  for (const row of data as Row[]) {
-    if (row.source_local_id == null || row.space_id == null) continue;
-    const k = key(row);
-    if (!groups.has(k)) groups.set(k, []);
-    groups.get(k)!.push(row);
-  }
-
-  const nodes: Array<PublishedNode> = [];
+  });
 
-  for (const rows of groups.values()) {
-    const withDate = rows.filter(
-      (r) => r.last_modified != null && r.text != null,
-    );
-    if (withDate.length === 0) continue;
-    const latest = withDate.reduce((a, b) =>
-      (a.last_modified ?? "") >= (b.last_modified ?? "") ? a : b,
-    );
-    const direct = rows.find((r) => r.variant === "direct");
-    const text = direct?.text ?? latest.text ?? "";
-    const createdAt = latest.created
-      ? new Date(latest.created + "Z").valueOf()
-      : 0;
-    const modifiedAt = latest.last_modified
-      ? new Date(latest.last_modified + "Z").valueOf()
-      : 0;
+  return sharedNodes.map((sharedNode) => {
+    const metadata = sharedNode.directMetadata;
     const filePath: string | undefined =
-      direct &&
-      typeof direct.metadata === "object" &&
-      typeof (direct.metadata as Record<string, any>).filePath === "string"
-        ? (direct.metadata as Record<string, any>).filePath
+      metadata !== null &&
+      typeof metadata === "object" &&
+      !Array.isArray(metadata) &&
+      typeof metadata.filePath === "string"
+        ? metadata.filePath
         : undefined;
-    nodes.push({
-      source_local_id: latest.source_local_id!,
-      space_id: latest.space_id!,
-      text,
-      createdAt,
-      modifiedAt,
+    return {
+      source_local_id: sharedNode.sourceLocalId,
+      space_id: sharedNode.spaceId,
+      text: sharedNode.title,
+      createdAt: sharedNode.created
+        ? new Date(sharedNode.created).valueOf()
+        : 0,
+      modifiedAt: new Date(sharedNode.lastModified).valueOf(),
       filePath,
-      authorId: latest.author_id ?? undefined,
-    });
-  }
-
-  return nodes;
+      authorId: sharedNode.authorId,
+    };
+  });
 };
 
 export const getLocalNodeInstanceIds = (

apps/roam/src/utils/__tests__/discoverSharedNodes.test.ts

@@ -1,179 +1,48 @@
 import { describe, expect, it } from "vitest";
-import { buildDiscoveredSharedNodes } from "~/utils/discoverSharedNodes";
-
-type BuildArgs = Parameters<typeof buildDiscoveredSharedNodes>[0];
-
-const resources: BuildArgs["resources"] = [
-  { space_id: 20, source_local_id: "node-1" },
-  { space_id: 20, source_local_id: "schema-1" },
-];
-const spaces: BuildArgs["spaces"] = [
-  {
-    id: 20,
-    name: "Research vault",
-    platform: "Obsidian",
-    url: "obsidian:vault-a",
-  },
-];
-const concepts: BuildArgs["concepts"] = [
-  {
-    is_schema: false,
-    last_modified: "2026-06-14T12:00:00",
-    schema_id: 200,
-    source_local_id: "node-1",
-    space_id: 20,
-  },
-];
-const contents: BuildArgs["contents"] = [
-  {
-    content_type: "text/plain",
-    last_modified: "2026-06-14T13:00:00",
-    source_local_id: "node-1",
-    space_id: 20,
-    text: "EVD - REM sleep and recall",
-    variant: "direct",
-  },
-  {
-    content_type: "text/markdown",
-    last_modified: "2026-06-14T15:00:00",
-    source_local_id: "node-1",
-    space_id: 20,
-    text: "# EVD - REM sleep and recall",
-    variant: "full",
-  },
-];
-const sourceNodeRid = "orn:obsidian.note:vault-a/node-1";
-
-const build = ({
-  conceptsOverride = concepts,
-  contentsOverride = contents,
-  currentSpaceId = 10,
-  importedSourceRids = new Set<string>(),
-  resourcesOverride = resources,
-  spacesOverride = spaces,
-}: {
-  conceptsOverride?: typeof concepts;
-  contentsOverride?: typeof contents;
-  currentSpaceId?: number;
-  importedSourceRids?: ReadonlySet<string>;
-  resourcesOverride?: typeof resources;
-  spacesOverride?: typeof spaces;
-} = {}) =>
-  buildDiscoveredSharedNodes({
-    concepts: conceptsOverride,
-    contents: contentsOverride,
-    currentSpaceId,
-    importedSourceRids,
-    resources: resourcesOverride,
-    spaces: spacesOverride,
-  });
-
-describe("buildDiscoveredSharedNodes", () => {
-  it("builds a group-shared contract node with stable source identity", () => {
-    expect(build({ importedSourceRids: new Set([sourceNodeRid]) })).toEqual([
+import { toDiscoveredSharedNodes } from "~/utils/discoverSharedNodes";
+import type { SharedNode } from "@repo/database/lib/sharedNodes";
+
+const sharedNode: SharedNode = {
+  rid: "orn:obsidian.note:vault-a/node-1",
+  sourceLocalId: "node-1",
+  spaceId: 20,
+  spaceName: "Research vault",
+  spaceUri: "obsidian:vault-a",
+  platform: "Obsidian",
+  title: "EVD - REM sleep and recall",
+  created: "2026-06-14T12:30:00.000Z",
+  lastModified: "2026-06-14T15:00:00.000Z",
+  authorId: 7,
+  directMetadata: null,
+};
+
+describe("toDiscoveredSharedNodes", () => {
+  it("maps a shared node to the exact discovered shared node shape", () => {
+    expect(
+      toDiscoveredSharedNodes({
+        sharedNodes: [sharedNode],
+        importedSourceRids: new Set([sharedNode.rid]),
+      }),
+    ).toEqual([
       {
         alreadyImported: true,
         modifiedAt: "2026-06-14T15:00:00.000Z",
         sourceApp: "Obsidian",
         sourceNodeId: "node-1",
-        sourceNodeRid,
+        sourceNodeRid: "orn:obsidian.note:vault-a/node-1",
         sourceSpaceId: "obsidian:vault-a",
         sourceSpaceName: "Research vault",
         title: "EVD - REM sleep and recall",
       },
     ]);
   });
 
-  it("does not discover shared resources from the current space", () => {
-    expect(build({ currentSpaceId: 20 })).toEqual([]);
-  });
-
-  it("requires the exact shared resource identity", () => {
-    expect(
-      build({
-        resourcesOverride: [{ space_id: 21, source_local_id: "node-1" }],
-      }),
-    ).toEqual([]);
-  });
-
-  it.each([
-    {
-      name: "schema concept",
-      conceptsOverride: [{ ...concepts[0], is_schema: true }],
-      contentsOverride: contents,
-    },
-    {
-      name: "missing node type",
-      conceptsOverride: [{ ...concepts[0], schema_id: null }],
-      contentsOverride: contents,
-    },
-    {
-      name: "missing direct content",
-      conceptsOverride: concepts,
-      contentsOverride: [contents[1]],
-    },
-    {
-      name: "missing full content",
-      conceptsOverride: concepts,
-      contentsOverride: [contents[0]],
-    },
-    {
-      name: "untyped full content",
-      conceptsOverride: concepts,
-      contentsOverride: [contents[0], { ...contents[1], content_type: null }],
-    },
-  ])("filters a node with $name", ({ conceptsOverride, contentsOverride }) => {
-    expect(build({ conceptsOverride, contentsOverride })).toEqual([]);
-  });
-
   it("matches imports by RID rather than source-local ID alone", () => {
     expect(
-      build({
+      toDiscoveredSharedNodes({
+        sharedNodes: [sharedNode],
         importedSourceRids: new Set(["orn:obsidian.note:another-vault/node-1"]),
       })[0]?.alreadyImported,
     ).toBe(false);
   });
-
-  it.each([
-    "orn:obsidian.note:vault-a/node-1",
-    "https://example.com/shared/node-1",
-  ])("preserves a RID-shaped source-local ID: %s", (rid) => {
-    expect(
-      build({
-        conceptsOverride: [{ ...concepts[0], source_local_id: rid }],
-        contentsOverride: contents.map((content) => ({
-          ...content,
-          source_local_id: rid,
-        })),
-        resourcesOverride: [{ space_id: 20, source_local_id: rid }],
-      })[0]?.sourceNodeRid,
-    ).toBe(rid);
-  });
-
-  it("sorts newest nodes first", () => {
-    const olderConcept = {
-      ...concepts[0],
-      last_modified: "2026-06-10T12:00:00",
-      source_local_id: "node-2",
-    };
-    const olderContents = contents.map((content) => ({
-      ...content,
-      last_modified: "2026-06-10T12:00:00",
-      source_local_id: "node-2",
-      text:
-        content.variant === "direct"
-          ? "Older shared node"
-          : "# Older shared node",
-    }));
-    expect(
-      build({
-        conceptsOverride: [olderConcept, concepts[0]],
-        contentsOverride: [...olderContents, ...contents],
-        resourcesOverride: [
-          ...resources,
-          { space_id: 20, source_local_id: "node-2" },
-        ],
-      }).map((node) => node.sourceNodeId),
-    ).toEqual(["node-1", "node-2"]);
-  });
 });