wip

Author: nikgraf

src/graph/create-relation-type.ts

@@ -5,12 +5,10 @@ import { Triple } from '../triple.js';
 import type { CreateRelationOp, Op, SetTripleOp } from '../types.js';
 
 type Params = {
-  from: string;
-  to: string;
   name: string;
 };
 
-export const createRelationType = async ({ from, to, name }: Params) => {
+export const createRelationType = async ({ name }: Params) => {
   const id = generate();
   const ops: Op[] = [];
 

src/graph/create-type.ts

@@ -1,46 +1,67 @@
-import { SCHEMA_TYPE, TYPES_ATTRIBUTE } from '../core/ids/system.js';
+import { ATTRIBUTE, SCHEMA_TYPE, TYPES_ATTRIBUTE } from '../core/ids/system.js';
 import { generate } from '../id.js';
 import { Relation } from '../relation.js';
 import { Triple } from '../triple.js';
 import type { CreateRelationOp, Op, SetTripleOp, ValueType } from '../types.js';
 
 type Params = {
-  attributes: {
-    [filedName: string]: { id?: string; type: ValueType; name: string };
+  existingAttributes?: { [filedName: string]: { id: string; type: ValueType } };
+  newAttributes?: {
+    [filedName: string]: { type: ValueType; name: string };
   };
   relations?: Array<{
     relationTypeId: string;
     toId: string;
   }>;
 };
 
-export const createType = async ({ attributes }: Params) => {
+export const createType = async ({ newAttributes, existingAttributes }: Params) => {
   const id = generate();
   const ops: Op[] = [];
   const mapping: Record<string, { id: string; type: ValueType }> = {};
 
-  for (const [fieldName, item] of Object.entries(attributes)) {
-    const attributeId = item.id || generate();
-    const setTripleOp: SetTripleOp = Triple.make({
-      entityId: id,
-      attributeId,
-      value: {
-        type: item.type,
-        value: fieldName,
-      },
-    });
-
-    ops.push(setTripleOp);
-    mapping[fieldName] = { id: attributeId, type: item.type };
-  }
-
   // add the type relation
-  const setRelationOp: CreateRelationOp = Relation.make({
+  const relationOp: CreateRelationOp = Relation.make({
     fromId: id,
     relationTypeId: TYPES_ATTRIBUTE,
     toId: SCHEMA_TYPE,
   });
-  ops.push(setRelationOp);
+  ops.push(relationOp);
+
+  if (newAttributes) {
+    for (const [fieldName, item] of Object.entries(newAttributes)) {
+      const attributeId = generate();
+      const setTripleOp: SetTripleOp = Triple.make({
+        entityId: id,
+        attributeId,
+        value: {
+          type: item.type,
+          value: fieldName,
+        },
+      });
+
+      const relationOp: CreateRelationOp = Relation.make({
+        fromId: id,
+        relationTypeId: ATTRIBUTE,
+        toId: attributeId,
+      });
+
+      ops.push(setTripleOp, relationOp);
+      mapping[fieldName] = { id: attributeId, type: item.type };
+    }
+  }
+
+  if (existingAttributes) {
+    for (const [fieldName, item] of Object.entries(existingAttributes)) {
+      const relationOp: CreateRelationOp = Relation.make({
+        fromId: id,
+        relationTypeId: ATTRIBUTE,
+        toId: item.id,
+      });
+      ops.push(relationOp);
+      mapping[fieldName] = { id: item.id, type: item.type };
+    }
+  }
 
   // TODO relations
 

src/graph/graph.test.ts

@@ -7,52 +7,51 @@ import { createType } from './create-type.js';
 
 describe('Graph', () => {
   it('creates multiple types, relation types, entities, relations', async () => {
-    const operations: Array<Op> = [];
+    const ops: Array<Op> = [];
 
     // create person type
     const {
       id: personTypeId,
       ops: createPersonTypeOps,
       mapping: personMapping,
     } = await createType({
-      attributes: {
-        name: {
-          id: NAME_ATTRIBUTE,
-          type: 'TEXT',
-          name: 'Name',
-        },
+      newAttributes: {
         age: {
-          // ID is optional and will be generated automatically
           type: 'NUMBER',
           name: 'Age',
         },
       },
+      existingAttributes: {
+        name: {
+          id: NAME_ATTRIBUTE,
+          type: 'TEXT',
+        },
+      },
     });
-    operations.push(...createPersonTypeOps);
+    ops.push(...createPersonTypeOps);
 
     // create restaurant type
     const {
       id: restaurantTypeId,
       ops: createRestaurantTypeOps,
       mapping: restaurantMapping,
     } = await createType({
-      attributes: {
+      existingAttributes: {
         name: {
           id: NAME_ATTRIBUTE,
           type: 'TEXT',
-          name: 'Name',
         },
       },
     });
-    operations.push(...createRestaurantTypeOps);
+    ops.push(...createRestaurantTypeOps);
 
     // create loves relation type
     const { id: relationTypeId, ops: createRelationTypeOps } = await createRelationType({
       from: personTypeId,
       to: restaurantTypeId,
       name: 'Loves',
     });
-    operations.push(...createRelationTypeOps);
+    ops.push(...createRelationTypeOps);
 
     // create restaurant entity
     const { id: restaurantId, ops: createRestaurantOps } = await createEntity({
@@ -62,7 +61,7 @@ describe('Graph', () => {
       },
       mapping: restaurantMapping,
     });
-    operations.push(...createRestaurantOps);
+    ops.push(...createRestaurantOps);
 
     // create person entity
     const { id: personId, ops: createPersonOps } = await createEntity({
@@ -73,17 +72,17 @@ describe('Graph', () => {
       mapping: personMapping,
       relations: [{ relationTypeId, toId: restaurantId }],
     });
-    operations.push(...createPersonOps);
+    ops.push(...createPersonOps);
 
-    expect(operations.length).toBe(12);
+    expect(ops.length).toBe(12);
 
     from: Person
 to: Name
 relation type: PROPERTIES
 
     // publish all changes
     // const { proposalId } = await publish({
-    //   operations,
+    //   ops,
     //   editName: 'Create person, restaurant, and loves relation',
     //   spaceId: '0x1',
     //   accountId: '0x2',

src/graph/graph2.test.ts

@@ -0,0 +1,59 @@
+const schema = {
+  event: {
+    types: ['AaGd6UMXfNtL6U6Xx7K8Cv'], // Event type
+  },
+};
+
+const { ops, id: ageAttributeId } = createAttributeEntity({
+  type: 'NUMBER',
+  name: 'Age',
+});
+
+const { ops, id: metFirstAttributeId } = createAttributeEntity({
+  type: 'TIME',
+  name: 'Met First',
+});
+
+const { ops, mapping } = createType({
+  attributes: {
+    name: {
+      id: NAME_ATTRIBUTE,
+      type: 'TEXT',
+    },
+    age: {
+      id: ageAttributeId,
+      type: 'NUMBER',
+    },
+  },
+  relations: {
+    friend: {
+      relationTypeId: 'AaGd6UMXfNtL6U6Xx7K8Cv',
+      attributes: {
+        metFirst: {
+          id: metFirstAttributeId,
+          type: 'TIME',
+        },
+      },
+    },
+  },
+});
+
+schema.person = mapping;
+
+const createEntity = createEntityFactory(schema);
+
+const { ops: personOps, mapping: personMapping } = createEntity({
+  attributes: {
+    name: 'John Doe',
+  },
+  relations: {
+    friend: [
+      {
+        id: 'ABCD', // other person ID
+        attributes: {
+          metFirst: 'Jane Doe',
+        },
+      },
+    ],
+  },
+});