@treenity/core 1.0.47 → 3.0.0

package/src/tree/mongo.ts

@@ -0,0 +1,125 @@
+// Treenity Mongo Tree — Layer 1
+// Drop-in replacement for MemoryStore.
+
+import { type NodeData, toStorageKeys, fromStorageKeys } from '#core';
+import { type Collection, type Db, MongoClient } from 'mongodb';
+import { type Tree } from './index';
+import { defaultPatch } from './patch';
+
+const toStorage = (node: NodeData) => toStorageKeys(node);
+const fromStorage = (doc: Record<string, unknown>) => fromStorageKeys(doc) as NodeData;
+
+// Shared MongoClient pool — one client per URI, reused across mounts
+const clientPool = new Map<string, { client: MongoClient; refCount: number; ready: Promise<MongoClient> }>();
+
+function getSharedClient(uri: string): { client: MongoClient; ready: Promise<MongoClient>; release: () => Promise<void> } {
+  let entry = clientPool.get(uri);
+  if (!entry) {
+    const client = new MongoClient(uri);
+    const ready = client.connect();
+    entry = { client, refCount: 0, ready };
+    clientPool.set(uri, entry);
+  }
+  entry.refCount++;
+  const release = async () => {
+    const e = clientPool.get(uri);
+    if (!e) return;
+    e.refCount--;
+    if (e.refCount <= 0) {
+      clientPool.delete(uri);
+      await e.client.close();
+    }
+  };
+  return { client: entry.client, ready: entry.ready, release };
+}
+
+export async function createMongoTree(
+  uri: string,
+  dbName = 'treenity',
+  collectionName = 'nodes',
+): Promise<Tree & { close(): Promise<void> }> {
+  const { client, ready, release } = getSharedClient(uri);
+  await ready;
+  const db: Db = client.db(dbName);
+  const col: Collection = db.collection(collectionName);
+
+  await col.createIndex({ _path: 1 }, { unique: true });
+
+  function buildPattern(parent: string, depth: number): RegExp {
+    const esc = escapeRegex(parent);
+    const seg = '[^/]+';
+    if (depth === 1) return parent === '/' ? /^\/[^/]+$/ : new RegExp(`^${esc}/${seg}$`);
+    if (depth === Infinity) return parent === '/' ? /^\/.*$/ : new RegExp(`^${esc}/.+`);
+    return parent === '/'
+      ? new RegExp(`^(/${seg}){1,${depth}}$`)
+      : new RegExp(`^${esc}(/${seg}){1,${depth}}$`);
+  }
+
+  async function paginatedFind(
+    filter: Record<string, unknown>,
+    opts?: { limit?: number; offset?: number },
+  ) {
+    const total = await col.countDocuments(filter);
+    const cursor = col.find(filter).sort({ _path: 1 });
+    if (opts?.offset) cursor.skip(opts.offset);
+    if (opts?.limit) cursor.limit(opts.limit);
+    const docs = await cursor.toArray();
+    return { items: docs.map((doc) => fromStorage(doc as Record<string, unknown>)), total };
+  }
+
+  const tree: Tree & { close(): Promise<void> } = {
+    async get(path, ctx) {
+      const doc = await col.findOne({ _path: path });
+      if (!doc) return undefined;
+      return fromStorage(doc as Record<string, unknown>);
+    },
+
+    async getChildren(parent, opts, ctx) {
+      const depth = opts?.depth ?? 1;
+      const pathQuery = { _path: buildPattern(parent, depth) };
+      const filter = opts?.query ? { $and: [pathQuery, opts.query] } : pathQuery;
+      return paginatedFind(filter, opts);
+    },
+
+    async set(node, ctx) {
+      const doc = toStorage(node);
+      const prevRev = doc._rev as number | undefined;
+      doc._rev = (prevRev ?? 0) + 1;
+      
+      if (prevRev === undefined) {
+         try {
+           await col.insertOne(doc);
+         } catch(e: any) {
+           if (e.code === 11000) throw new Error(`OptimisticConcurrencyError: node ${node.$path} already exists`);
+           throw e;
+         }
+      } else {
+         const result = await col.replaceOne({ _path: doc._path, _rev: prevRev }, doc);
+         if (result.matchedCount === 0) {
+           throw new Error(`OptimisticConcurrencyError: node ${node.$path} modified by another transaction`);
+         }
+      }
+      node.$rev = doc._rev as number;
+    },
+
+    async remove(path) {
+      const result = await col.deleteOne({ _path: path });
+      return result.deletedCount > 0;
+    },
+
+    // TODO: native Mongo $set — for now, fallback via get+apply+set
+    async patch(path, ops, ctx) {
+      return defaultPatch(tree.get, tree.set, path, ops, ctx);
+    },
+
+    async close() {
+      await release();
+    },
+  };
+
+  return tree;
+}
+
+function escapeRegex(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/src/tree/patch.test.ts

@@ -0,0 +1,192 @@
+import { createNode } from '#core';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { createMemoryTree } from './index';
+import { applyOps, fromRfc6902, PatchTestError, toRfc6902, type PatchOp } from './patch';
+
+describe('applyOps', () => {
+  it('replace shallow field', () => {
+    const obj = { title: 'old', count: 1 };
+    applyOps(obj, [['r', 'title', 'new']]);
+    assert.equal(obj.title, 'new');
+    assert.equal(obj.count, 1);
+  });
+
+  it('replace nested field via dot path', () => {
+    const obj = { mesh: { width: 5, height: 10 } } as any;
+    applyOps(obj, [['r', 'mesh.width', 20]]);
+    assert.equal(obj.mesh.width, 20);
+    assert.equal(obj.mesh.height, 10);
+  });
+
+  it('test passes on match', () => {
+    const obj = { $rev: 3 };
+    assert.doesNotThrow(() => applyOps(obj, [['t', '$rev', 3]]));
+  });
+
+  it('test throws PatchTestError on mismatch', () => {
+    const obj = { $rev: 3 };
+    assert.throws(
+      () => applyOps(obj, [['t', '$rev', 5]]),
+      (e: any) => e instanceof PatchTestError && e.code === 'TEST_FAILED',
+    );
+  });
+
+  it('test + replace: atomic — test fails, replace not applied', () => {
+    const obj = { $rev: 3, title: 'old' } as any;
+    assert.throws(
+      () => applyOps(obj, [['t', '$rev', 999], ['r', 'title', 'new']]),
+      (e: any) => e instanceof PatchTestError,
+    );
+    assert.equal(obj.title, 'old');
+  });
+
+  it('add to array via .- suffix', () => {
+    const obj = { tags: ['a', 'b'] } as any;
+    applyOps(obj, [['a', 'tags.-', 'c']]);
+    assert.deepEqual(obj.tags, ['a', 'b', 'c']);
+  });
+
+  it('add creates new field', () => {
+    const obj = {} as any;
+    applyOps(obj, [['a', 'newField', 42]]);
+    assert.equal(obj.newField, 42);
+  });
+
+  it('delete removes field', () => {
+    const obj = { title: 'x', obsolete: true } as any;
+    applyOps(obj, [['d', 'obsolete']]);
+    assert.equal(obj.title, 'x');
+    assert.equal('obsolete' in obj, false);
+  });
+
+  it('delete nested field', () => {
+    const obj = { meta: { a: 1, b: 2 } } as any;
+    applyOps(obj, [['d', 'meta.b']]);
+    assert.equal(obj.meta.a, 1);
+    assert.equal('b' in obj.meta, false);
+  });
+
+  it('creates intermediate objects on set', () => {
+    const obj = {} as any;
+    applyOps(obj, [['r', 'deep.nested.field', 'ok']]);
+    assert.equal(obj.deep.nested.field, 'ok');
+  });
+});
+
+describe('RFC 6902 conversion', () => {
+  it('toRfc6902 round-trips', () => {
+    const ops: PatchOp[] = [
+      ['t', '$rev', 5],
+      ['r', 'mesh.width', 20],
+      ['a', 'tags.-', 'x'],
+      ['d', 'obsolete'],
+    ];
+    const rfc = toRfc6902(ops);
+    assert.deepEqual(rfc, [
+      { op: 'test', path: '/$rev', value: 5 },
+      { op: 'replace', path: '/mesh/width', value: 20 },
+      { op: 'add', path: '/tags/-', value: 'x' },
+      { op: 'remove', path: '/obsolete' },
+    ]);
+
+    const back = fromRfc6902(rfc);
+    assert.deepEqual(back, ops);
+  });
+});
+
+describe('Tree.patch', () => {
+  it('patches a node in memory tree', async () => {
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'old', count: 1 }));
+
+    await store.patch('/n', [['r', 'title', 'new'], ['r', 'count', 2]]);
+
+    const result = (await store.get('/n'))!;
+    assert.equal(result.title, 'new');
+    assert.equal(result.count, 2);
+  });
+
+  it('bumps $rev on patch', async () => {
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'x' }));
+    const rev1 = (await store.get('/n'))!.$rev!;
+
+    await store.patch('/n', [['r', 'title', 'y']]);
+    const rev2 = (await store.get('/n'))!.$rev!;
+    assert.equal(rev2, rev1 + 1);
+  });
+
+  it('OCC via test op', async () => {
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'x' }));
+    const rev = (await store.get('/n'))!.$rev!;
+
+    // Correct rev — should succeed
+    await store.patch('/n', [['t', '$rev', rev], ['r', 'title', 'y']]);
+    assert.equal((await store.get('/n'))!.title, 'y');
+
+    // Stale rev — should fail
+    await assert.rejects(
+      () => store.patch('/n', [['t', '$rev', rev], ['r', 'title', 'z']]),
+      (e: any) => e instanceof PatchTestError,
+    );
+    // Value unchanged after failed patch
+    assert.equal((await store.get('/n'))!.title, 'y');
+  });
+
+  it('throws on missing node', async () => {
+    const store = createMemoryTree();
+    await assert.rejects(
+      () => store.patch('/nonexistent', [['r', 'x', 1]]),
+      /Node not found/,
+    );
+  });
+
+  it('preserves $type and $path', async () => {
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'x' }));
+
+    await store.patch('/n', [['r', 'title', 'y']]);
+
+    const result = (await store.get('/n'))!;
+    assert.equal(result.$type, 't.mytype');
+    assert.equal(result.$path, '/n');
+  });
+
+  it('nested field patch', async () => {
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', {
+      mesh: { $type: 't3d.mesh', width: 5, height: 10 },
+    }));
+
+    await store.patch('/n', [['r', 'mesh.width', 20]]);
+
+    const result = (await store.get('/n'))!;
+    const mesh = result.mesh as any;
+    assert.equal(mesh.width, 20);
+    assert.equal(mesh.height, 10);
+    assert.equal(mesh.$type, 't3d.mesh');
+  });
+
+  it('add to array', async () => {
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { tags: ['a', 'b'] }));
+
+    await store.patch('/n', [['a', 'tags.-', 'c']]);
+
+    const result = (await store.get('/n'))!;
+    assert.deepEqual(result.tags, ['a', 'b', 'c']);
+  });
+
+  it('delete field', async () => {
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'x', obsolete: true }));
+
+    await store.patch('/n', [['d', 'obsolete']]);
+
+    const result = (await store.get('/n'))!;
+    assert.equal(result.title, 'x');
+    assert.equal('obsolete' in result, false);
+  });
+});

package/src/tree/patch.ts

@@ -0,0 +1,133 @@
+// Treenity Patch — Layer 1
+// Compact [op, path, value?] tuples with dot-notation paths.
+// Maps 1:1 to RFC 6902 JSON Patch.
+
+import type { NodeData } from '#core';
+
+// ── Types ──
+
+export type PatchOp =
+  | readonly ['t', string, unknown]     // test
+  | readonly ['r', string, unknown]     // replace
+  | readonly ['a', string, unknown]     // add (field or array push via path.-)
+  | readonly ['d', string]              // delete
+
+export type Rfc6902Op =
+  | { op: 'test'; path: string; value: unknown }
+  | { op: 'replace'; path: string; value: unknown }
+  | { op: 'add'; path: string; value: unknown }
+  | { op: 'remove'; path: string }
+
+export class PatchTestError extends Error {
+  code = 'TEST_FAILED' as const;
+  constructor(public field: string, public expected: unknown, public actual: unknown) {
+    super(`Patch test failed: ${field}`);
+  }
+}
+
+// ── Apply ops to object in-place ──
+
+export function applyOps(target: Record<string, unknown>, ops: readonly PatchOp[]): void {
+  for (const op of ops) {
+    switch (op[0]) {
+      case 't': {
+        const actual = getByPath(target, op[1]);
+        if (actual !== op[2]) throw new PatchTestError(op[1], op[2], actual);
+        break;
+      }
+      case 'r':
+        setByPath(target, op[1], op[2]);
+        break;
+      case 'a':
+        if (op[1].endsWith('.-')) {
+          const arrPath = op[1].slice(0, -2);
+          const arr = getByPath(target, arrPath);
+          if (!Array.isArray(arr)) throw new Error(`add: ${arrPath} is not an array`);
+          arr.push(op[2]);
+        } else {
+          setByPath(target, op[1], op[2]);
+        }
+        break;
+      case 'd':
+        deleteByPath(target, op[1]);
+        break;
+    }
+  }
+}
+
+// ── Path helpers (dot notation) ──
+
+function getByPath(obj: any, path: string): unknown {
+  const parts = path.split('.');
+  let cur = obj;
+  for (const p of parts) {
+    if (cur == null || typeof cur !== 'object') return undefined;
+    cur = cur[p];
+  }
+  return cur;
+}
+
+function setByPath(obj: any, path: string, value: unknown): void {
+  const parts = path.split('.');
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (cur[parts[i]] == null || typeof cur[parts[i]] !== 'object') cur[parts[i]] = {};
+    cur = cur[parts[i]];
+  }
+  cur[parts[parts.length - 1]] = value;
+}
+
+function deleteByPath(obj: any, path: string): void {
+  const parts = path.split('.');
+  let cur = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (cur[parts[i]] == null) return;
+    cur = cur[parts[i]];
+  }
+  delete cur[parts[parts.length - 1]];
+}
+
+// ── RFC 6902 conversion ──
+
+function dotToSlash(p: string): string { return '/' + p.replace(/\./g, '/'); }
+function slashToDot(p: string): string { return p.slice(1).replace(/\//g, '.'); }
+
+export function toRfc6902(ops: readonly PatchOp[]): Rfc6902Op[] {
+  return ops.map(op => {
+    const path = dotToSlash(op[1]);
+    switch (op[0]) {
+      case 't': return { op: 'test', path, value: op[2] };
+      case 'r': return { op: 'replace', path, value: op[2] };
+      case 'a': return { op: 'add', path, value: op[2] };
+      case 'd': return { op: 'remove', path };
+    }
+  });
+}
+
+export function fromRfc6902(ops: readonly Rfc6902Op[]): PatchOp[] {
+  return ops.map(op => {
+    const path = slashToDot(op.path);
+    switch (op.op) {
+      case 'test': return ['t', path, op.value] as const;
+      case 'replace': return ['r', path, op.value] as const;
+      case 'add': return ['a', path, op.value] as const;
+      case 'remove': return ['d', path] as const;
+    }
+  });
+}
+
+// ── Default patch: get → apply → set (fallback for adapters without native patch) ──
+
+export async function defaultPatch(
+  get: (path: string, ctx?: unknown) => Promise<NodeData | undefined>,
+  set: (node: NodeData, ctx?: unknown) => Promise<void>,
+  path: string,
+  ops: readonly PatchOp[],
+  ctx?: unknown,
+): Promise<void> {
+  const node = await get(path, ctx);
+  if (!node) throw new Error(`Node not found: ${path}`);
+  const copy = structuredClone(node);
+  applyOps(copy, ops);
+  await set(copy, ctx);
+}

package/src/tree/query.test.ts

@@ -0,0 +1,110 @@
+import { createNode, type NodeData } from '#core';
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { createMemoryTree } from './index';
+import { createQueryTree, matchesFilter } from './query';
+
+describe('matchesFilter', () => {
+  it('matches dot-path values', () => {
+    const node = { $path: '/a', $type: 'x', status: { $type: 'status', value: 'active' } } as NodeData;
+    assert.equal(matchesFilter(node, { 'status.value': 'active' }), true);
+    assert.equal(matchesFilter(node, { 'status.value': 'done' }), false);
+  });
+
+  it('matches top-level $type fields', () => {
+    const node = { $path: '/a', $type: 'order' } as NodeData;
+    assert.equal(matchesFilter(node, { $type: 'order' }), true);
+    assert.equal(matchesFilter(node, { $type: 'item' }), false);
+  });
+
+  it('supports mongo operators ($gt, $in)', () => {
+    const node = { $path: '/a', $type: 'x', count: 10 } as NodeData;
+    assert.equal(matchesFilter(node, { count: { $gt: 5 } }), true);
+    assert.equal(matchesFilter(node, { count: { $in: [10, 20] } }), true);
+    assert.equal(matchesFilter(node, { count: { $lt: 5 } }), false);
+  });
+
+  it('returns false for missing paths', () => {
+    const node = { $path: '/a', $type: 'x' } as NodeData;
+    assert.equal(matchesFilter(node, { 'status.value': 'active' }), false);
+  });
+
+  it('empty match matches everything', () => {
+    const node = { $path: '/a', $type: 'x' } as NodeData;
+    assert.equal(matchesFilter(node, {}), true);
+  });
+
+  it('deep dot-path matching', () => {
+    const node = { $path: '/a', $type: 'x', meta: { $type: 'meta', nested: { flag: true } } } as NodeData;
+    assert.equal(matchesFilter(node, { 'meta.nested.flag': true }), true);
+    assert.equal(matchesFilter(node, { 'meta.nested.flag': false }), false);
+  });
+});
+
+describe('QueryStore', () => {
+  it('getChildren filters by match criteria', async () => {
+    const parent = createMemoryTree();
+    await parent.set({ $path: '/orders/a', $type: 'order', status: { $type: 'status', value: 'incoming' } } as NodeData);
+    await parent.set({ $path: '/orders/b', $type: 'order', status: { $type: 'status', value: 'kitchen' } } as NodeData);
+    await parent.set({ $path: '/orders/c', $type: 'order', status: { $type: 'status', value: 'incoming' } } as NodeData);
+
+    const qs = createQueryTree({ source: '/orders', match: { 'status.value': 'incoming' } }, parent);
+    const result = await qs.getChildren('/orders/incoming');
+
+    assert.equal(result.items.length, 2);
+    assert.deepEqual(result.items.map(n => n.$path).sort(), ['/orders/a', '/orders/c']);
+  });
+
+  it('paginates after filtering', async () => {
+    const parent = createMemoryTree();
+    for (let i = 0; i < 5; i++)
+      await parent.set({ $path: `/items/${i}`, $type: 'item', status: { $type: 's', value: 'active' } } as NodeData);
+    await parent.set({ $path: '/items/x', $type: 'item', status: { $type: 's', value: 'archived' } } as NodeData);
+
+    const qs = createQueryTree({ source: '/items', match: { 'status.value': 'active' } }, parent);
+    const page = await qs.getChildren('/view/active', { limit: 2 });
+
+    assert.equal(page.items.length, 2);
+    assert.equal(page.total, 5);
+  });
+
+  it('get delegates to parent store', async () => {
+    const parent = createMemoryTree();
+    await parent.set(createNode('/items/a', 'item'));
+
+    const qs = createQueryTree({ source: '/items', match: {} }, parent);
+    const node = await qs.get('/items/a');
+
+    assert.equal(node?.$type, 't.item');
+  });
+
+  it('set delegates to parent store', async () => {
+    const parent = createMemoryTree();
+    const qs = createQueryTree({ source: '/items', match: {} }, parent);
+    await qs.set(createNode('/items/new', 'item'));
+
+    assert.equal((await parent.get('/items/new'))?.$type, 't.item');
+  });
+
+  it('remove delegates to parent store', async () => {
+    const parent = createMemoryTree();
+    await parent.set(createNode('/items/a', 'item'));
+
+    const qs = createQueryTree({ source: '/items', match: {} }, parent);
+    assert.equal(await qs.remove('/items/a'), true);
+    assert.equal(await parent.get('/items/a'), undefined);
+  });
+
+  it('excludes non-matching nodes like mount configs', async () => {
+    const parent = createMemoryTree();
+    await parent.set({ $path: '/orders/a', $type: 'order', status: { $type: 's', value: 'new' } } as NodeData);
+    await parent.set(createNode('/orders/incoming', 'mount-point')); // mount config — no status
+    await parent.set(createNode('/orders/kanban', 'orders.kanban')); // view — no status
+
+    const qs = createQueryTree({ source: '/orders', match: { 'status.value': 'new' } }, parent);
+    const result = await qs.getChildren('/orders/incoming');
+
+    assert.equal(result.items.length, 1);
+    assert.equal(result.items[0].$path, '/orders/a');
+  });
+});

package/src/tree/query.ts

@@ -0,0 +1,70 @@
+// Treenity Query Tree — Layer 1
+// Virtual filtered view over a parent store's children.
+// Used by t.mount.query to create virtual folders (e.g., /orders/incoming shows orders where status.value === 'incoming').
+
+import { type NodeData, toStorageKeys } from '#core';
+import sift from 'sift';
+import { type Tree } from './index';
+
+export type QueryConfig = {
+  source: string;
+  match: Record<string, unknown>;
+};
+
+export function mapSiftQuery(q: unknown): unknown {
+  if (Array.isArray(q)) return q.map(mapSiftQuery);
+  if (q && typeof q === 'object' && q.constructor === Object) {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(q)) {
+      let newKey = k;
+      if (k === '$type') newKey = '_type';
+      else if (k === '$path') newKey = '_path';
+      else if (k === '$acl') newKey = '_acl';
+      else if (k === '$owner') newKey = '_owner';
+      else if (k === '$rev') newKey = '_rev';
+      out[newKey] = mapSiftQuery(v);
+    }
+    return out;
+  }
+  return q;
+}
+
+export function mapNodeForSift(node: NodeData): Record<string, unknown> {
+  return toStorageKeys(node);
+}
+
+export function createSiftTest(match: Record<string, unknown>): (node: Record<string, unknown>) => boolean {
+  return sift(mapSiftQuery(match) as Record<string, unknown>);
+}
+
+export function matchesFilter(node: NodeData, match: Record<string, unknown>): boolean {
+  return sift(mapSiftQuery(match))(mapNodeForSift(node));
+}
+
+export function createQueryTree(config: QueryConfig, parentStore: Tree): Tree {
+  return {
+    async get(path, ctx) {
+      return parentStore.get(path, ctx);
+    },
+
+    async getChildren(_path, opts, ctx) {
+      // Pass ctx properly to ensure auth/context flows through the query mount
+      const mappedQuery = mapSiftQuery(config.match) as Record<string, unknown>;
+      const mergedQuery = opts?.query ? { $and: [opts.query, mappedQuery] } : mappedQuery;
+      const res = await parentStore.getChildren(config.source, { ...opts, depth: 1, query: mergedQuery }, ctx);
+      return { ...res, queryMount: { source: config.source, match: config.match } };
+    },
+
+    async set(node, ctx) {
+      return parentStore.set(node, ctx);
+    },
+
+    async remove(path, ctx) {
+      return parentStore.remove(path, ctx);
+    },
+
+    async patch(path, ops, ctx) {
+      return parentStore.patch(path, ops, ctx);
+    },
+  };
+}