@dxos/graph 0.8.2-staging.7ac8446 → 0.8.2

package/src/types.ts

@@ -2,38 +2,50 @@
 // Copyright 2024 DXOS.org
 //
 
-import { S } from '@dxos/echo-schema';
+import { Schema } from 'effect';
+
 import { type Specialize } from '@dxos/util';
 
-export const BaseGraphNode = S.Struct({
-  id: S.String,
-  type: S.optional(S.String),
-  data: S.optional(S.Any),
+//
+// Node
+//
+
+// TODO(burdon): Make type extensible (i.e., not dependent on `data` property)?
+export const BaseGraphNode = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  data: Schema.optional(Schema.Any),
 });
 
 /** Raw base type. */
-export type BaseGraphNode = S.Schema.Type<typeof BaseGraphNode>;
+export type BaseGraphNode = Schema.Schema.Type<typeof BaseGraphNode>;
 
 /** Typed node data. */
-export type GraphNode<Data = any, Optional extends boolean = false> = Specialize<
+type GraphNode<Data = any, Optional extends boolean = false> = Specialize<
   BaseGraphNode,
   Optional extends true ? { data?: Data } : { data: Data }
 >;
 
 export declare namespace GraphNode {
-  export type Optional<T = any> = GraphNode<T, true>;
+  export type Any = GraphNode<any, true>;
+  export type Optional<Data = any> = GraphNode<Data, true>;
+  export type Required<Data = any> = GraphNode<Data, false>;
 }
 
-export const BaseGraphEdge = S.Struct({
-  id: S.String,
-  type: S.optional(S.String),
-  data: S.optional(S.Any),
-  source: S.String,
-  target: S.String,
+//
+// Edge
+//
+
+export const BaseGraphEdge = Schema.Struct({
+  id: Schema.String,
+  type: Schema.optional(Schema.String),
+  source: Schema.String,
+  target: Schema.String,
+  data: Schema.optional(Schema.Any),
 });
 
 /** Raw base type. */
-export type BaseGraphEdge = S.Schema.Type<typeof BaseGraphEdge>;
+export type BaseGraphEdge = Schema.Schema.Type<typeof BaseGraphEdge>;
 
 /** Typed edge data. */
 export type GraphEdge<Data = any, Optional extends boolean = false> = Specialize<
@@ -42,21 +54,19 @@ export type GraphEdge<Data = any, Optional extends boolean = false> = Specialize
 >;
 
 export declare namespace GraphEdge {
-  export type Optional<T = any> = GraphEdge<T, true>;
+  export type Any = GraphEdge<any, true>;
+  export type Optional<Data = any> = GraphEdge<Data, true>;
+  export type Required<Data = any> = GraphEdge<Data, false>;
 }
 
-/**
- * Allows any additional properties on graph nodes.
- */
-const ExtendableBaseGraphNode = S.extend(BaseGraphNode, S.Struct({}, { key: S.String, value: S.Any }));
-
-/**
- * Generic graph.
- */
-export const Graph = S.Struct({
-  id: S.optional(S.String),
-  nodes: S.mutable(S.Array(ExtendableBaseGraphNode)),
-  edges: S.mutable(S.Array(BaseGraphEdge)),
+//
+// Graph
+//
+
+export const Graph = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  nodes: Schema.mutable(Schema.Array(BaseGraphNode)),
+  edges: Schema.mutable(Schema.Array(BaseGraphEdge)),
 });
 
-export type Graph = S.Schema.Type<typeof Graph>;
+export type Graph = Schema.Schema.Type<typeof Graph>;

package/src/util.ts

@@ -2,15 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type ReactiveEchoObject } from '@dxos/echo-db';
-import { FormatEnum } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { getSchema, create } from '@dxos/live-object';
-import { log } from '@dxos/log';
-import { getSchemaProperties } from '@dxos/schema';
-
-import { GraphModel } from './model';
-import { Graph, type GraphNode } from './types';
 
 const KEY_REGEX = /\w+/;
 
@@ -28,42 +20,3 @@ export const parseEdgeId = (id: string): EdgeMeta => {
   invariant(source.length && target.length);
   return { source, relation: relation.length ? relation : undefined, target };
 };
-
-/**
- * Creates a new reactive graph from a set of ECHO objects.
- * References are mapped onto graph edges.
- */
-export const createGraph = (objects: ReactiveEchoObject<any>[]): GraphModel<GraphNode<ReactiveEchoObject<any>>> => {
-  const graph = new GraphModel<GraphNode<ReactiveEchoObject<any>>>(create(Graph, { nodes: [], edges: [] }));
-
-  // Map objects.
-  objects.forEach((object) => {
-    graph.addNode({ id: object.id, type: object.typename, data: object });
-  });
-
-  // Find references.
-  objects.forEach((object) => {
-    const schema = getSchema(object);
-    if (!schema) {
-      log.info('no schema for object', { id: object.id.slice(0, 8) });
-      return;
-    }
-
-    // Parse schema to follow referenced objects.
-    for (const prop of getSchemaProperties(schema.ast, object)) {
-      if (prop.format === FormatEnum.Ref) {
-        const source = object;
-        const target = object[prop.name]?.target;
-        if (target) {
-          graph.addEdge({
-            id: createEdgeId({ source: source.id, target: target.id, relation: String(prop.name) }),
-            source: source.id,
-            target: target.id,
-          });
-        }
-      }
-    }
-  });
-
-  return graph;
-};