@rool-dev/client 0.3.1-dev.de3060f → 0.3.1-dev.ff89f50

package/dist/graph.js

@@ -1,6 +1,6 @@
 // =============================================================================
 // Graph
-// First-class Graph object with node/edge operations, undo/redo, and events
+// First-class Graph object with object/edge operations, undo/redo, and events
 // =============================================================================
 import { immutableJSONPatch } from 'immutable-json-patch';
 import { EventEmitter } from './event-emitter.js';
@@ -18,7 +18,7 @@ export function generateEntityId() {
  * First-class Graph object.
  *
  * Features:
- * - High-level node/edge operations
+ * - High-level object/edge operations
  * - Built-in undo/redo with checkpoints
  * - Metadata management
  * - Event emission for state changes
@@ -210,250 +210,322 @@ export class RoolGraph extends EventEmitter {
         this.redoStack = [];
     }
     // ===========================================================================
-    // Node Operations
+    // Object Operations
     // ===========================================================================
     /**
-     * Get a node by ID.
-     * @throws Error if node not found
+     * Get an object's data by ID.
+     * Returns just the data portion (RoolObject), not the full entry with meta/links.
+     * @throws Error if object not found
      */
-    getNode(nodeId) {
-        const node = this._data.nodes[nodeId];
-        if (!node) {
-            throw new Error(`Node ${nodeId} not found`);
+    getObject(objectId) {
+        const entry = this._data.objects[objectId];
+        if (!entry) {
+            throw new Error(`Object ${objectId} not found`);
         }
-        return node;
+        return entry.data;
     }
     /**
-     * Get a node by ID, or undefined if not found.
+     * Get an object's data by ID, or undefined if not found.
      */
-    getNodeOrUndefined(nodeId) {
-        return this._data.nodes[nodeId];
+    getObjectOrUndefined(objectId) {
+        return this._data.objects[objectId]?.data;
     }
     /**
-     * Get all nodes of a specific type.
+     * Get an object's metadata (position, UI state, etc).
      */
-    getNodesByType(type) {
-        return Object.values(this._data.nodes).filter(node => node.type === type);
+    getObjectMeta(objectId) {
+        const entry = this._data.objects[objectId];
+        if (!entry) {
+            throw new Error(`Object ${objectId} not found`);
+        }
+        return entry.meta;
     }
     /**
-     * Get all node IDs.
+     * Get all objects of a specific type.
      */
-    getNodeIds() {
-        return Object.keys(this._data.nodes);
+    getObjectsByType(type) {
+        return Object.values(this._data.objects)
+            .filter(entry => entry.data.type === type)
+            .map(entry => entry.data);
     }
     /**
-     * Create a new node with optional AI generation.
-     * @param options.type - The node type (required)
-     * @param options.fields - Node fields (optional). Use {{placeholder}} for AI-generated content.
+     * Get all object IDs.
+     */
+    getObjectIds() {
+        return Object.keys(this._data.objects);
+    }
+    /**
+     * Create a new object with optional AI generation.
+     * @param options.type - The object type (required)
+     * @param options.fields - Object fields (optional). Use {{placeholder}} for AI-generated content.
      * @param options.meta - Client-private metadata (optional). Hidden from AI operations.
      * @param options.prompt - AI prompt for content generation (optional).
-     * @returns The generated node ID
+     * @returns The generated object ID
      */
-    createNode(options) {
-        const nodeId = generateEntityId();
+    async createObject(options) {
+        const objectId = generateEntityId();
         const { type, fields, meta, prompt } = options;
-        // Build the node for local state
-        const node = { type, _meta: meta ?? {}, ...fields };
+        // Build the entry for local state
+        const entry = {
+            meta: meta ?? {},
+            links: {},
+            data: { type, ...fields },
+        };
         // Update local state immediately (optimistic)
-        this._data.nodes[nodeId] = node;
-        this.emit('nodeCreated', { nodeId, node, source: 'local_user' });
-        // Fire-and-forget server call - errors trigger resync
-        this.graphqlClient.createNode(this.id, nodeId, type, fields, meta, prompt)
-            .catch((error) => {
-            console.error('[Graph] Failed to create node:', error);
+        this._data.objects[objectId] = entry;
+        this.emit('objectCreated', { objectId, object: entry.data, source: 'local_user' });
+        // Await server call
+        try {
+            const message = await this.graphqlClient.createObject(this.id, objectId, type, fields, meta, prompt);
+            return { id: objectId, message };
+        }
+        catch (error) {
+            console.error('[Graph] Failed to create object:', error);
             this.resyncFromServer(error instanceof Error ? error : new Error(String(error)));
-        });
-        return nodeId;
+            throw error;
+        }
     }
     /**
-     * Update an existing node.
-     * @param nodeId - The ID of the node to update
-     * @param options.type - Optional new type for the node
+     * Update an existing object.
+     * @param objectId - The ID of the object to update
+     * @param options.type - Optional new type for the object
      * @param options.fields - Fields to add or update. Use {{placeholder}} for AI-generated content.
      * @param options.meta - Client-private metadata to merge. Hidden from AI operations.
      * @param options.prompt - AI prompt for content editing (optional).
      */
-    updateNode(nodeId, options) {
-        const node = this._data.nodes[nodeId];
-        if (!node) {
-            throw new Error(`Node ${nodeId} not found for update`);
+    async updateObject(objectId, options) {
+        const entry = this._data.objects[objectId];
+        if (!entry) {
+            throw new Error(`Object ${objectId} not found for update`);
         }
         const { type, fields, meta } = options;
         // Build local updates
         if (type) {
-            node.type = type;
+            entry.data.type = type;
         }
         if (fields) {
-            Object.assign(node, fields);
+            Object.assign(entry.data, fields);
         }
         if (meta) {
-            node._meta = { ...node._meta, ...meta };
+            entry.meta = { ...entry.meta, ...meta };
         }
-        // Emit semantic event with updated node
+        // Emit semantic event with updated object
         if (type || fields || meta) {
-            this.emit('nodeUpdated', { nodeId, node, source: 'local_user' });
+            this.emit('objectUpdated', { objectId, object: entry.data, source: 'local_user' });
         }
-        // Fire-and-forget server call - errors trigger resync
-        this.graphqlClient.updateNode(this.id, nodeId, type, fields, meta, options.prompt)
-            .catch((error) => {
-            console.error('[Graph] Failed to update node:', error);
+        // Await server call
+        try {
+            return await this.graphqlClient.updateObject(this.id, objectId, type, fields, meta, options.prompt);
+        }
+        catch (error) {
+            console.error('[Graph] Failed to update object:', error);
             this.resyncFromServer(error instanceof Error ? error : new Error(String(error)));
-        });
+            throw error;
+        }
     }
     /**
-     * Delete nodes by IDs.
-     * Also removes any edges connected to the deleted nodes.
+     * Delete objects by IDs.
+     * Outbound links are automatically deleted with the object.
+     * Inbound links become orphans (tolerated).
      */
-    deleteNodes(nodeIds) {
-        if (nodeIds.length === 0)
+    async deleteObjects(objectIds) {
+        if (objectIds.length === 0)
             return;
-        const nodeIdSet = new Set(nodeIds);
-        const deletedEdgeIds = [];
-        const deletedNodeIds = [];
-        // Remove edges connected to any deleted node (local state)
-        for (const [edgeId, edge] of Object.entries(this._data.edges)) {
-            const hasDeletedSource = edge.sources.some(s => nodeIdSet.has(s));
-            const hasDeletedTarget = edge.targets.some(t => nodeIdSet.has(t));
-            if (hasDeletedSource || hasDeletedTarget) {
-                delete this._data.edges[edgeId];
-                deletedEdgeIds.push(edgeId);
+        const deletedObjectIds = [];
+        // Collect edges that will be orphaned (for events)
+        const deletedEdges = [];
+        for (const objectId of objectIds) {
+            const entry = this._data.objects[objectId];
+            if (entry) {
+                // Collect outbound edges for deletion events
+                for (const [edgeType, targets] of Object.entries(entry.links)) {
+                    for (const targetId of Object.keys(targets)) {
+                        deletedEdges.push({ sourceId: objectId, targetId, edgeType });
+                    }
+                }
             }
         }
-        // Remove nodes (local state)
-        for (const nodeId of nodeIds) {
-            if (this._data.nodes[nodeId]) {
-                delete this._data.nodes[nodeId];
-                deletedNodeIds.push(nodeId);
+        // Remove objects (local state)
+        for (const objectId of objectIds) {
+            if (this._data.objects[objectId]) {
+                delete this._data.objects[objectId];
+                deletedObjectIds.push(objectId);
             }
         }
         // Emit semantic events
-        for (const edgeId of deletedEdgeIds) {
-            this.emit('edgeDeleted', { edgeId, source: 'local_user' });
+        for (const edge of deletedEdges) {
+            this.emit('edgeDeleted', { ...edge, source: 'local_user' });
         }
-        for (const nodeId of deletedNodeIds) {
-            this.emit('nodeDeleted', { nodeId, source: 'local_user' });
+        for (const objectId of deletedObjectIds) {
+            this.emit('objectDeleted', { objectId, source: 'local_user' });
         }
-        // Fire-and-forget server call - errors trigger resync
-        this.graphqlClient.deleteNodes(this.id, nodeIds)
-            .catch((error) => {
-            console.error('[Graph] Failed to delete nodes:', error);
+        // Await server call
+        try {
+            await this.graphqlClient.deleteObjects(this.id, objectIds);
+        }
+        catch (error) {
+            console.error('[Graph] Failed to delete objects:', error);
             this.resyncFromServer(error instanceof Error ? error : new Error(String(error)));
-        });
+            throw error;
+        }
     }
     // ===========================================================================
     // Edge Operations
     // ===========================================================================
     /**
-     * Create an edge between nodes.
-     * @returns The generated edge ID
+     * Create a link between objects.
+     * Links are stored on the source object.
      */
-    createEdge(sourceId, targetId, edgeType) {
-        const edgeId = generateEntityId();
-        const edge = {
-            sources: [sourceId],
-            targets: [targetId],
-            type: edgeType,
-            _meta: {},
-        };
+    async link(sourceId, targetId, edgeType) {
+        const entry = this._data.objects[sourceId];
+        if (!entry) {
+            throw new Error(`Source object ${sourceId} not found`);
+        }
         // Update local state immediately
-        this._data.edges[edgeId] = edge;
-        this.emit('edgeCreated', { edgeId, edge, source: 'local_user' });
-        // Fire-and-forget server call - errors trigger resync
-        this.graphqlClient.createEdge(this.id, edgeId, sourceId, targetId, edgeType)
-            .catch((error) => {
-            console.error('[Graph] Failed to create edge:', error);
+        if (!entry.links[edgeType]) {
+            entry.links[edgeType] = {};
+        }
+        entry.links[edgeType][targetId] = {};
+        const linkData = entry.links[edgeType][targetId];
+        this.emit('edgeCreated', { sourceId, targetId, edgeType, linkData, source: 'local_user' });
+        // Await server call
+        try {
+            await this.graphqlClient.link(this.id, sourceId, targetId, edgeType);
+        }
+        catch (error) {
+            console.error('[Graph] Failed to create link:', error);
             this.resyncFromServer(error instanceof Error ? error : new Error(String(error)));
-        });
-        return edgeId;
+            throw error;
+        }
     }
     /**
-     * Remove edges between two nodes.
-     * @returns true if any edges were removed
+     * Remove a link between two objects.
+     * @param edgeType - Optional: if provided, only removes that type; otherwise removes all links between the objects
+     * @returns true if any links were removed
      */
-    deleteEdge(sourceId, targetId) {
-        const deletedEdgeIds = [];
+    async unlink(sourceId, targetId, edgeType) {
+        const entry = this._data.objects[sourceId];
+        if (!entry) {
+            throw new Error(`Source object ${sourceId} not found`);
+        }
+        const deletedEdges = [];
         // Update local state
-        for (const [edgeId, edge] of Object.entries(this._data.edges)) {
-            if (edge.sources.includes(sourceId) && edge.targets.includes(targetId)) {
-                delete this._data.edges[edgeId];
-                deletedEdgeIds.push(edgeId);
+        if (edgeType) {
+            // Remove specific edge type
+            if (entry.links[edgeType]?.[targetId] !== undefined) {
+                delete entry.links[edgeType][targetId];
+                deletedEdges.push({ edgeType });
+            }
+        }
+        else {
+            // Remove all links from source to target
+            for (const [type, targets] of Object.entries(entry.links)) {
+                if (targets[targetId] !== undefined) {
+                    delete targets[targetId];
+                    deletedEdges.push({ edgeType: type });
+                }
             }
         }
         // Emit semantic events
-        for (const edgeId of deletedEdgeIds) {
-            this.emit('edgeDeleted', { edgeId, source: 'local_user' });
+        for (const edge of deletedEdges) {
+            this.emit('edgeDeleted', { sourceId, targetId, edgeType: edge.edgeType, source: 'local_user' });
         }
-        // Fire-and-forget server call - errors trigger resync
-        this.graphqlClient.deleteEdge(this.id, sourceId, targetId)
-            .catch((error) => {
-            console.error('[Graph] Failed to delete edge:', error);
+        // Await server call
+        try {
+            await this.graphqlClient.unlink(this.id, sourceId, targetId);
+        }
+        catch (error) {
+            console.error('[Graph] Failed to remove link:', error);
             this.resyncFromServer(error instanceof Error ? error : new Error(String(error)));
-        });
-        return deletedEdgeIds.length > 0;
+            throw error;
+        }
+        return deletedEdges.length > 0;
     }
     /**
-     * Get parent node IDs (nodes that have edges pointing TO this node).
+     * Get parent object IDs (objects that have edges pointing TO this object).
      * @param edgeType - Optional filter by edge type
      */
-    getParents(nodeId, edgeType) {
-        return Object.values(this._data.edges)
-            .filter(edge => edge.targets.includes(nodeId) &&
-            (!edgeType || edge.type === edgeType))
-            .flatMap(edge => edge.sources);
+    getParents(objectId, edgeType) {
+        const parents = [];
+        for (const [entryId, entry] of Object.entries(this._data.objects)) {
+            for (const [type, targets] of Object.entries(entry.links)) {
+                if ((!edgeType || type === edgeType) && objectId in targets) {
+                    parents.push(entryId);
+                    break; // Found a link, move to next object
+                }
+            }
+        }
+        return parents;
     }
     /**
-     * Get child node IDs (nodes that this node has edges pointing TO).
+     * Get child object IDs (objects that this object has edges pointing TO).
+     * Filters out orphan targets (targets that don't exist).
      * @param edgeType - Optional filter by edge type
      */
-    getChildren(nodeId, edgeType) {
-        return Object.values(this._data.edges)
-            .filter(edge => edge.sources.includes(nodeId) &&
-            (!edgeType || edge.type === edgeType))
-            .flatMap(edge => edge.targets);
-    }
-    /**
-     * Get an edge by ID.
-     */
-    getEdge(edgeId) {
-        return this._data.edges[edgeId];
+    getChildren(objectId, edgeType) {
+        const entry = this._data.objects[objectId];
+        if (!entry)
+            return [];
+        const children = [];
+        for (const [type, targets] of Object.entries(entry.links)) {
+            if (!edgeType || type === edgeType) {
+                for (const targetId of Object.keys(targets)) {
+                    // Filter orphans - only return existing targets
+                    if (this._data.objects[targetId]) {
+                        children.push(targetId);
+                    }
+                }
+            }
+        }
+        return children;
     }
     /**
-     * Get all edge IDs.
+     * Get all child object IDs including orphans (targets that may not exist).
+     * @param edgeType - Optional filter by edge type
      */
-    getEdgeIds() {
-        return Object.keys(this._data.edges);
+    getChildrenIncludingOrphans(objectId, edgeType) {
+        const entry = this._data.objects[objectId];
+        if (!entry)
+            return [];
+        const children = [];
+        for (const [type, targets] of Object.entries(entry.links)) {
+            if (!edgeType || type === edgeType) {
+                children.push(...Object.keys(targets));
+            }
+        }
+        return children;
     }
     // ===========================================================================
     // Metadata Operations
     // ===========================================================================
     /**
-     * Set a metadata value.
-     * Metadata is stored in _meta and hidden from AI operations.
+     * Set a graph-level metadata value.
+     * Metadata is stored in meta and hidden from AI operations.
      */
     setMetadata(key, value) {
-        if (!this._data._meta) {
-            this._data._meta = {};
+        if (!this._data.meta) {
+            this._data.meta = {};
         }
-        this._data._meta[key] = value;
-        this.emit('metaUpdated', { meta: this._data._meta, source: 'local_user' });
+        this._data.meta[key] = value;
+        this.emit('metaUpdated', { meta: this._data.meta, source: 'local_user' });
         // Fire-and-forget server call - errors trigger resync
-        this.graphqlClient.setGraphMeta(this.id, this._data._meta)
+        this.graphqlClient.setGraphMeta(this.id, this._data.meta)
             .catch((error) => {
             console.error('[Graph] Failed to set graph meta:', error);
             this.resyncFromServer(error instanceof Error ? error : new Error(String(error)));
         });
     }
     /**
-     * Get a metadata value.
+     * Get a graph-level metadata value.
      */
     getMetadata(key) {
-        return this._data._meta?.[key];
+        return this._data.meta?.[key];
     }
     /**
-     * Get all metadata.
+     * Get all graph-level metadata.
      */
     getAllMetadata() {
-        return this._data._meta ?? {};
+        return this._data.meta ?? {};
     }
     // ===========================================================================
     // AI Operations
@@ -554,55 +626,73 @@ export class RoolGraph extends EventEmitter {
      * @internal
      */
     emitSemanticEventsFromPatch(patch, source) {
-        // Track which nodes have been updated (to avoid duplicate events)
-        const updatedNodes = new Set();
+        // Track which objects have been updated (to avoid duplicate events)
+        const updatedObjects = new Set();
         for (const op of patch) {
             const { path } = op;
-            // Node operations
-            if (path.startsWith('/nodes/')) {
+            // Object operations: /objects/{objectId}/...
+            if (path.startsWith('/objects/')) {
                 const parts = path.split('/');
-                const nodeId = parts[2];
+                const objectId = parts[2];
                 if (parts.length === 3) {
-                    // /nodes/{nodeId} - full node add or remove
+                    // /objects/{objectId} - full object add or remove
                     if (op.op === 'add') {
-                        const node = this._data.nodes[nodeId];
-                        if (node) {
-                            this.emit('nodeCreated', { nodeId, node, source });
+                        const entry = this._data.objects[objectId];
+                        if (entry) {
+                            this.emit('objectCreated', { objectId, object: entry.data, source });
                         }
                     }
                     else if (op.op === 'remove') {
-                        this.emit('nodeDeleted', { nodeId, source });
+                        this.emit('objectDeleted', { objectId, source });
                     }
                 }
-                else if (parts.length > 3 && !updatedNodes.has(nodeId)) {
-                    // /nodes/{nodeId}/{field} - field update
-                    const node = this._data.nodes[nodeId];
-                    if (node) {
-                        this.emit('nodeUpdated', { nodeId, node, source });
-                        updatedNodes.add(nodeId);
+                else if (parts[3] === 'data') {
+                    // /objects/{objectId}/data/... - data field update
+                    if (!updatedObjects.has(objectId)) {
+                        const entry = this._data.objects[objectId];
+                        if (entry) {
+                            this.emit('objectUpdated', { objectId, object: entry.data, source });
+                            updatedObjects.add(objectId);
+                        }
                     }
                 }
-            }
-            // Edge operations
-            else if (path.startsWith('/edges/')) {
-                const parts = path.split('/');
-                const edgeId = parts[2];
-                if (parts.length === 3) {
-                    // /edges/{edgeId} - full edge add or remove
-                    if (op.op === 'add') {
-                        const edge = this._data.edges[edgeId];
-                        if (edge) {
-                            this.emit('edgeCreated', { edgeId, edge, source });
+                else if (parts[3] === 'links') {
+                    // /objects/{objectId}/links/{type}/{targetId}
+                    if (parts.length >= 6) {
+                        const edgeType = parts[4];
+                        const targetId = parts[5];
+                        if (op.op === 'add') {
+                            const linkData = this._data.objects[objectId]?.links[edgeType]?.[targetId] ?? {};
+                            this.emit('edgeCreated', { sourceId: objectId, targetId, edgeType, linkData, source });
+                        }
+                        else if (op.op === 'remove') {
+                            this.emit('edgeDeleted', { sourceId: objectId, targetId, edgeType, source });
                         }
                     }
-                    else if (op.op === 'remove') {
-                        this.emit('edgeDeleted', { edgeId, source });
+                    else if (parts.length === 5 && op.op === 'add') {
+                        // /objects/{objectId}/links/{type} - new link type object added
+                        const edgeType = parts[4];
+                        const targets = this._data.objects[objectId]?.links[edgeType] ?? {};
+                        for (const [targetId, linkData] of Object.entries(targets)) {
+                            this.emit('edgeCreated', { sourceId: objectId, targetId, edgeType, linkData: linkData, source });
+                        }
+                    }
+                }
+                else if (parts[3] === 'meta') {
+                    // /objects/{objectId}/meta/... - object meta update
+                    // Could emit an objectMeta event if needed, but for now treat as object update
+                    if (!updatedObjects.has(objectId)) {
+                        const entry = this._data.objects[objectId];
+                        if (entry) {
+                            this.emit('objectUpdated', { objectId, object: entry.data, source });
+                            updatedObjects.add(objectId);
+                        }
                     }
                 }
             }
             // Graph metadata
-            else if (path === '/_meta' || path.startsWith('/_meta/')) {
-                this.emit('metaUpdated', { meta: this._data._meta, source });
+            else if (path === '/meta' || path.startsWith('/meta/')) {
+                this.emit('metaUpdated', { meta: this._data.meta, source });
             }
         }
     }