@treenity/core 1.0.47 → 3.0.0

package/src/schema/load.ts

@@ -0,0 +1,24 @@
+// Load generated JSON schemas into core registry
+// Import this BEFORE any defineComponent/registerType calls (import order matters in ESM)
+
+import { normalizeType, register } from '#core';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const dir = new URL('./generated', import.meta.url).pathname;
+
+export function loadSchemas() {
+// TODO load async, wrap with function, call from some init
+  if (fs.existsSync(dir)) {
+    for (const file of fs.readdirSync(dir).filter((f) => f.endsWith('.json'))) {
+      const raw = fs.readFileSync(path.join(dir, file), 'utf-8').trim();
+      if (!raw) throw new Error(`[schema] empty file: ${file}`);
+      const schema = JSON.parse(raw);
+      if (!schema.$id) throw new Error(`[schema] no $id: ${file}`);
+      schema.$id = normalizeType(schema.$id);
+      register(schema.$id, 'schema', () => schema);
+    }
+  }
+}
+
+loadSchemas();

package/src/schema/schema.test.ts

@@ -0,0 +1,86 @@
+import { registerType } from '#comp';
+import { getRegisteredTypes, register, resolve } from '#core';
+import { clearRegistry } from '#core/index.test';
+import { loadSchemas } from '#schema/load';
+import assert from 'node:assert/strict';
+import { before, describe, it } from 'node:test';
+import './load';
+
+describe('schema loader', () => {
+  before(() => {
+    loadSchemas();
+  })
+
+  it('loads JSON schemas from dist/schema/ into registry', () => {
+    const types = getRegisteredTypes('schema');
+    assert.ok(types.length > 0, 'no schemas loaded');
+  });
+
+  it('each schema has $id, type, properties', () => {
+    const types = getRegisteredTypes('schema');
+    for (const type of types) {
+      const handler = resolve(type, 'schema') as (() => any) | null;
+      assert.ok(handler, `no schema handler for ${type}`);
+      const schema = handler();
+      assert.equal(schema.$id, type, `$id mismatch for ${type}`);
+      assert.equal(schema.type, 'object', `${type} should be type=object`);
+      assert.ok(schema.properties !== undefined, `${type} missing properties`);
+    }
+  });
+
+  it('schemas with properties have titled properties', () => {
+    const types = getRegisteredTypes('schema');
+    assert.ok(types.length > 0);
+    // At least some schemas should have property titles (quality check)
+    let withTitles = 0;
+    for (const type of types) {
+      const schema = (resolve(type, 'schema') as () => any)();
+      const props = Object.values(schema.properties ?? {}) as any[];
+      if (props.length > 0 && props.every((p: any) => p.title)) withTitles++;
+    }
+    assert.ok(withTitles > 0, 'no schemas have fully titled properties');
+  });
+
+  it('component schemas have methods', () => {
+    const handler = resolve('test.fixture', 'schema') as (() => any) | null;
+    assert.ok(handler, 'test.fixture schema not loaded');
+    const schema = handler();
+    assert.ok(schema.methods, 'test.fixture missing methods');
+    assert.ok(schema.methods.rename, 'test.fixture missing rename method');
+    assert.ok(schema.methods.clear, 'test.fixture missing clear method');
+    assert.deepEqual(schema.methods.clear.arguments, []);
+    assert.equal(schema.methods.rename.arguments[0].type, 'object');
+  });
+
+  it('emits refType when property type is a registered component class', () => {
+    const handler = resolve('cafe.contact', 'schema') as (() => any) | null;
+    assert.ok(handler, 'cafe.contact schema not loaded');
+    const schema = handler();
+    const ms = schema.properties.mailService;
+    assert.ok(ms, 'mailService property missing');
+    assert.equal(ms.format, 'path', 'format should be path');
+    assert.equal(ms.refType, 'cafe.mail', 'refType should reference cafe.mail');
+    // Non-component fields should NOT have refType
+    assert.equal(schema.properties.recipient.refType, undefined, 'recipient should not have refType');
+  });
+
+  it('defineComponent works independently of schema loader', () => {
+    clearRegistry();
+
+    register('test.type', 'schema', () => ({
+      $id: 'test.type',
+      type: 'object',
+      title: 'Test',
+      properties: { name: { type: 'string', title: 'Name' } },
+    }));
+
+    class TestType {
+      name = '';
+    }
+    registerType('test.type', TestType);
+
+    const schema = resolve('test.type', 'schema');
+    assert.ok(schema, 'schema not in registry');
+    assert.equal((schema as () => { title: string })().title, 'Test');
+  });
+});

package/src/schema/test-fixture.types.ts

@@ -0,0 +1,21 @@
+// Test fixture type — used by schema.test.ts to verify schema extraction
+// This file is NOT a .test.ts so extract-schemas picks it up
+import { registerType } from '#comp';
+
+/** Test fixture with properties and methods */
+class TestFixture {
+  /** @title Name */
+  name = '';
+  /** @title Count */
+  count = 0;
+
+  rename(data: { newName: string }) {
+    this.name = data.newName;
+  }
+
+  clear() {
+    this.name = '';
+    this.count = 0;
+  }
+}
+registerType('test.fixture', TestFixture);

package/src/schema/test-opaque.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env tsx
+// Quick test: does getAliasedSymbol resolve import to original @opaque decl?
+
+import * as ts from 'typescript';
+import * as path from 'node:path';
+
+const tsconfigPath = path.resolve(import.meta.dirname, '../../../tsconfig.json');
+const configFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(tsconfigPath));
+const program = ts.createProgram(parsed.fileNames, parsed.options);
+const checker = program.getTypeChecker();
+
+for (const sf of program.getSourceFiles()) {
+  if (!sf.fileName.includes('brahman/types')) continue;
+
+  ts.forEachChild(sf, (node) => {
+    if (!ts.isClassDeclaration(node) || !node.name) return;
+    if (node.name.text !== 'MessageAction') return;
+
+    for (const member of node.members) {
+      if (!ts.isMethodDeclaration(member) || !member.name || !ts.isIdentifier(member.name)) continue;
+      if (member.name.text !== 'run') continue;
+
+      const param = member.parameters[0];
+      if (!param?.type || !ts.isTypeReferenceNode(param.type)) { console.log('no type ref'); return; }
+
+      let sym = checker.getSymbolAtLocation(param.type.typeName);
+      console.log('sym:', sym?.name, 'flags:', sym?.flags, 'isAlias:', !!(sym?.flags! & ts.SymbolFlags.Alias));
+
+      if (sym?.flags! & ts.SymbolFlags.Alias) {
+        sym = checker.getAliasedSymbol(sym!);
+        console.log('aliased to:', sym?.name, 'decls:', sym?.declarations?.length);
+        const decl = sym?.declarations?.[0];
+        if (decl) {
+          console.log('decl kind:', ts.SyntaxKind[decl.kind], 'at', path.basename(decl.getSourceFile().fileName));
+          console.log('JSDoc tags:', ts.getJSDocTags(decl).map(t => t.tagName.text));
+        }
+      }
+    }
+  });
+  break;
+}

package/src/schema/types.ts

@@ -0,0 +1,33 @@
+// Schema types — used by SchemaForm, NodeEditor, PageEditor
+
+export type PropertySchema = {
+  type: string; // JSON Schema type or custom (e.g. "image")
+  title: string;
+  description?: string;
+  format?: string; // JSON Schema format hint (e.g. "uri", "textarea", "integer", "timestamp")
+  refType?: string; // component type name — field can hold ref or embedded value of this type
+  readOnly?: boolean;
+  enum?: string[]; // allowed values → renders as <select>
+  items?: { type?: string; properties?: Record<string, unknown> }; // for array fields
+};
+
+export type MethodSchema = {
+  title?: string;
+  description?: string;
+  streaming?: boolean; // true if async generator — use streamAction, not execute
+  arguments: Array<{
+    name: string;
+    type: string;
+    properties?: Record<string, Partial<PropertySchema>>;
+    required?: string[];
+  }>;
+  yields?: { type: string }; // yield type for streaming actions
+  return?: { type: string };
+};
+
+export type TypeSchema = {
+  title: string;
+  type: 'object';
+  properties: Record<string, PropertySchema>;
+  methods?: Record<string, MethodSchema>;
+};

package/src/server/CLAUDE.md

@@ -0,0 +1,26 @@
+## server
+HTTP сервер + tRPC + auth + mount system + store pipeline
+
+### Файлы
+- index.ts — bootstrap: overlay(base,work) → mount → volatile → validate → subscriptions
+- trpc.ts — tRPC router, Immer drafts in execute, OCC→CONFLICT mapping
+- auth.ts — ACL, sessions, withAcl wrapper, buildClaims
+- mount.ts — withMounts walks path, resolves monts
+- mount-adapters.ts — t.mount.mongo/fs/memory/overlay/types/query (MountAdapter)
+- types-mount.ts — createTypesStore: /sys/types virtual tree from all registered types
+- validate.ts — Write-Barrier: schema validation before tree.set()
+- volatile.ts — in-memory overlay for volatile components
+- watch.ts — watchChildren, prefix watch, notify
+- sub.ts — withSubscriptions wrapper, NodeEvent emit
+- actions.ts — executeAction(tree,path,type?,key?,action,data?), createNodeHandle, serverNodeHandle; callAction deleted
+- seed/ — initial tree: core.ts + domain module seeds
+- mcp.ts — MCP server: get_node, list_children, set_node, remove_node, execute
+
+### Конвенции
+- Tree pipeline: withMounts → volatile → validated → subscriptions
+- Mount = component on node, adapter via resolve($type, "mount")
+- ACL: GroupPerm[], p>0 allow, p=0 deny all sticky, p<0 deny bits sticky
+- Sealed registry: register() throws on duplicate (no overrides)
+- types-mount: getRegisteredTypes() — all types in /sys/types, not just schema-registered
+- executeAction: type=$type for scan/verify, key=field name; no patches → skip persist
+- trpc execute: {path, type?, key?, action, data?, watch?} — NO component field (deleted)

package/src/server/actions.test.ts

@@ -0,0 +1,272 @@
+import { registerType } from '#comp';
+import { createNode, isComponent, normalizeType, resolve } from '#core';
+import { clearRegistry } from '#core/index.test';
+import { createMemoryTree } from '#tree';
+import assert from 'node:assert/strict';
+import { beforeEach, describe, it } from 'node:test';
+import { collectSiblings, createNodeHandle, executeAction, registerBuiltinActions } from './actions';
+
+// ── Component classes ──
+
+class Metadata {
+  title = '';
+  description = '';
+
+  async rename({ title }: { title: string }) {
+    this.title = title;
+  }
+
+  async clear() {
+    this.title = '';
+    this.description = '';
+  }
+}
+
+class Status {
+  value = 'draft';
+
+  async publish() {
+    this.value = 'published';
+  }
+
+  async draft() {
+    this.value = 'draft';
+  }
+}
+
+// ── Tests ──
+
+describe('defineComponent', () => {
+  beforeEach(() => {
+    clearRegistry();
+  });
+
+  function setup() {
+    registerType('metadata', Metadata);
+    registerType('status', Status);
+  }
+
+  it('registers methods as action:name', () => {
+    setup();
+    assert.ok(resolve('metadata', 'action:rename'));
+    assert.ok(resolve('metadata', 'action:clear'));
+    assert.ok(resolve('status', 'action:publish'));
+  });
+
+  it('stores class → type mapping', () => {
+    setup();
+    assert.equal(normalizeType(Metadata), 't.metadata');
+    assert.equal(normalizeType(Status), 't.status');
+  });
+
+  it('action mutates component via this', () => {
+    setup();
+    const comp = { $type: 'metadata', title: 'old', description: 'desc' } as any;
+    resolve('metadata', 'action:rename')!({ comp } as any, { title: 'new' });
+    assert.equal(comp.title, 'new');
+    assert.equal(comp.description, 'desc');
+  });
+
+  it('end-to-end: simulate trpc execute', async () => {
+    setup();
+    const store = createMemoryTree();
+    await store.set(
+      createNode('/p', 'page', {}, {
+        metadata: { $type: 'metadata', title: 'old', description: 'x' },
+        status: { $type: 'status', value: 'draft' },
+      }),
+    );
+
+    async function execute(path: string, component: string, action: string, data?: unknown) {
+      const n = (await store.get(path))!;
+      const cv = n[component];
+      if (!isComponent(cv)) throw new Error(`Component "${component}" not found`);
+      const siblings = collectSiblings(n, component);
+      resolve(cv.$type, `action:${action}`)!({ node: n, comp: cv, siblings, store } as any, data);
+      await store.set(n);
+    }
+
+    await execute('/p', 'metadata', 'rename', { title: 'new' });
+    await execute('/p', 'status', 'publish');
+
+    const result = (await store.get('/p'))!;
+    assert.equal((result['metadata'] as any).title, 'new');
+    assert.equal((result['status'] as any).value, 'published');
+  });
+
+  it('node.get(Class).action() — typed client proxy', async () => {
+    setup();
+    const calls: any[] = [];
+    const mockStream = (_input: any) => (async function* () {})();
+    const node = createNodeHandle(async (input: any) => {
+      calls.push(input);
+    }, mockStream);
+
+    const page = node('/pages/main');
+    await page.get(Metadata).rename({ title: 'test' });
+    await page.get(Status).publish();
+
+    assert.equal(calls.length, 2);
+    assert.deepEqual(calls[0], {
+      path: '/pages/main',
+      type: 't.metadata',
+      key: undefined,
+      action: 'rename',
+      data: { title: 'test' },
+    });
+    assert.deepEqual(calls[1], {
+      path: '/pages/main',
+      type: 't.status',
+      key: undefined,
+      action: 'publish',
+      data: undefined,
+    });
+  });
+
+  it('defineComponent with needs option', () => {
+    registerType('metadata', Metadata, { needs: ['status'] });
+    registerType('status', Status);
+
+    const node = createNode('/p', 'page', {}, {
+      metadata: { $type: 'metadata', title: 'old', description: 'x' },
+      status: { $type: 'status', value: 'draft' },
+    });
+    const siblings = collectSiblings(node, 'metadata');
+    assert.equal(Object.keys(siblings).length, 1);
+    assert.equal((siblings.status as any).value, 'draft');
+  });
+
+  it('action receives deps as second arg', () => {
+    class Article {
+      title = '';
+
+      publishAndRename({ title }: { title: string }, deps: { status: any }) {
+        this.title = title;
+        deps.status.value = 'published';
+      }
+    }
+
+    registerType('article', Article, { needs: ['status'] });
+    registerType('status', Status);
+
+    const node = createNode('/a', 'page', {}, {
+      article: { $type: 'article', title: 'old' },
+      status: { $type: 'status', value: 'draft' },
+    });
+
+    const comp = node['article'] as any;
+    const deps = collectSiblings(node, 'article');
+    resolve(comp.$type, 'action:publishAndRename')!({ node, comp, deps } as any, {
+      title: 'new',
+    });
+
+    assert.equal(comp.title, 'new');
+    assert.equal((node['status'] as any).value, 'published');
+  });
+
+  it('patch action: shallow fields', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'old', count: 1 }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', { title: 'new', count: 2 });
+
+    const result = (await store.get('/n'))!;
+    assert.equal(result.title, 'new');
+    assert.equal(result.count, 2);
+  });
+
+  it('patch action: deep merges nested objects', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', {
+      mesh: { $type: 't3d.mesh', width: 5, height: 10 },
+    }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', {
+      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('patch action: guards $ fields', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { title: 'ok' }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', {
+      $type: 'hacked', $path: '/evil', title: 'patched',
+    });
+
+    const result = (await store.get('/n'))!;
+    assert.equal(result.$type, 't.mytype');
+    assert.equal(result.$path, '/n');
+    assert.equal(result.title, 'patched');
+  });
+
+  it('patch action: replaces arrays wholesale', async () => {
+    registerBuiltinActions();
+    const store = createMemoryTree();
+    await store.set(createNode('/n', 'mytype', { tags: ['a', 'b'] }));
+
+    await executeAction(store, '/n', undefined, undefined, 'patch', { tags: ['c'] });
+
+    const result = (await store.get('/n'))!;
+    assert.deepEqual(result.tags, ['c']);
+  });
+
+  it('end-to-end execute with needs injection', async () => {
+    class Article {
+      title = '';
+
+      publishAndRename({ title }: { title: string }, deps: { status: any }) {
+        this.title = title;
+        deps.status.value = 'published';
+      }
+    }
+
+    registerType('article', Article, { needs: ['status'] });
+    registerType('status', Status);
+
+    const store = createMemoryTree();
+    await store.set(
+      createNode('/a', 'page', {}, {
+        article: { $type: 'article', title: 'old' },
+        status: { $type: 'status', value: 'draft' },
+      }),
+    );
+
+    const node = (await store.get('/a'))!;
+    const comp = node['article'] as any;
+    const deps = collectSiblings(node, 'article');
+    resolve(comp.$type, 'action:publishAndRename')!({ node, comp, deps, store } as any, {
+      title: 'new',
+    });
+    await store.set(node);
+
+    const result = (await store.get('/a'))!;
+    assert.equal((result['article'] as any).title, 'new');
+    assert.equal((result['status'] as any).value, 'published');
+  });
+
+  it('executeAction resolves dotless node.$type against normalized componentType', async () => {
+    // Regression: normalizeType('autostart') → 't.autostart', but node.$type is 'autostart'.
+    // resolveActionHandler compared raw node.$type against normalized componentType — mismatch.
+    class Svc {
+      async ping() { return 'pong'; }
+    }
+    registerType('svc', Svc);
+
+    const store = createMemoryTree();
+    await store.set({ $path: '/s', $type: 'svc' } as NodeData);
+
+    // componentType = 't.svc' (normalized), node.$type = 'svc' (raw) — must match
+    const result = await executeAction(store, '/s', 't.svc', undefined, 'ping', undefined);
+    assert.equal(result, 'pong');
+  });
+});