@treenity/core 1.0.48 → 3.0.0

package/src/tree/repath.test.ts

@@ -0,0 +1,86 @@
+import { createNode } from '#core';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { createMemoryTree } from './index';
+import { createRepathTree } from './repath';
+
+describe('createRepathTree', () => {
+  it('translates paths: local /mnt → remote /', async () => {
+    const inner = createMemoryTree();
+    await inner.set(createNode('/docs/readme', 'doc', { title: 'Hello' }));
+
+    const mounted = createRepathTree(inner, '/mnt', '/docs');
+    const node = await mounted.get('/mnt/readme');
+
+    assert.ok(node);
+    assert.equal(node.$path, '/mnt/readme');
+    assert.equal((node as any).title, 'Hello');
+  });
+
+  it('get returns undefined for missing nodes', async () => {
+    const inner = createMemoryTree();
+    const mounted = createRepathTree(inner, '/mnt', '/');
+
+    assert.equal(await mounted.get('/mnt/nope'), undefined);
+  });
+
+  it('set translates path to remote', async () => {
+    const inner = createMemoryTree();
+    const mounted = createRepathTree(inner, '/mnt', '/data');
+
+    await mounted.set(createNode('/mnt/item', 'doc', { x: 1 }));
+
+    // Verify inner tree has it at remote path
+    const stored = await inner.get('/data/item');
+    assert.ok(stored);
+    assert.equal(stored.$path, '/data/item');
+    assert.equal((stored as any).x, 1);
+  });
+
+  it('getChildren remaps all child paths', async () => {
+    const inner = createMemoryTree();
+    await inner.set(createNode('/a', 'doc'));
+    await inner.set(createNode('/a/one', 'doc'));
+    await inner.set(createNode('/a/two', 'doc'));
+
+    const mounted = createRepathTree(inner, '/x', '/a');
+    const { items } = await mounted.getChildren('/x');
+
+    assert.equal(items.length, 2);
+    const paths = items.map(n => n.$path).sort();
+    assert.deepEqual(paths, ['/x/one', '/x/two']);
+  });
+
+  it('remove translates path', async () => {
+    const inner = createMemoryTree();
+    await inner.set(createNode('/data/tmp', 'doc'));
+
+    const mounted = createRepathTree(inner, '/mnt', '/data');
+    const removed = await mounted.remove('/mnt/tmp');
+
+    assert.ok(removed);
+    assert.equal(await inner.get('/data/tmp'), undefined);
+  });
+
+  it('handles root remoteBase', async () => {
+    const inner = createMemoryTree();
+    await inner.set(createNode('/hello', 'doc'));
+
+    const mounted = createRepathTree(inner, '/remote', '/');
+    const node = await mounted.get('/remote/hello');
+
+    assert.ok(node);
+    assert.equal(node.$path, '/remote/hello');
+  });
+
+  it('handles mount at root', async () => {
+    const inner = createMemoryTree();
+    await inner.set(createNode('/stuff/item', 'doc'));
+
+    const mounted = createRepathTree(inner, '/', '/stuff');
+    const node = await mounted.get('/item');
+
+    assert.ok(node);
+    assert.equal(node.$path, '/item');
+  });
+});

package/src/tree/repath.ts

@@ -0,0 +1,53 @@
+// Path-rewriting Tree combinator — mounts a remote tree at a local prefix.
+// Like Linux mount: remote /strategies/x ↔ local /app/live/strategies/x
+//
+// localBase:  where the tree is mounted in our namespace (e.g. '/app/live')
+// remoteBase: root of the remote tree to use (e.g. '/', or '/data' for a subtree)
+
+import type { NodeData } from '#core';
+import type { Page, Tree } from './index';
+
+export function createRepathTree(inner: Tree, localBase: string, remoteBase: string = '/'): Tree {
+  // Normalize: strip trailing slashes, handle root
+  const lb = localBase === '/' ? '' : localBase;
+  const rb = remoteBase === '/' ? '' : remoteBase;
+
+  function toRemote(localPath: string): string {
+    const rest = localPath.slice(lb.length);
+    return rb + rest || '/';
+  }
+
+  function toLocal(remotePath: string): string {
+    const rest = remotePath.slice(rb.length);
+    return lb + rest || '/';
+  }
+
+  function remapNode(node: NodeData): NodeData {
+    return { ...node, $path: toLocal(node.$path) };
+  }
+
+  function remapPage(page: Page<NodeData>): Page<NodeData> {
+    return { ...page, items: page.items.map(remapNode) };
+  }
+
+  return {
+    get: async (path, ctx) => {
+      const node = await inner.get(toRemote(path), ctx);
+      return node ? remapNode(node) : undefined;
+    },
+
+    getChildren: async (path, opts, ctx) => {
+      const page = await inner.getChildren(toRemote(path), opts, ctx);
+      return remapPage(page);
+    },
+
+    set: (node, ctx) =>
+      inner.set({ ...node, $path: toRemote(node.$path) }, ctx),
+
+    remove: (path, ctx) =>
+      inner.remove(toRemote(path), ctx),
+
+    patch: (path, ops, ctx) =>
+      inner.patch(toRemote(path), ops, ctx),
+  };
+}