implement prepare publish

Author: nikgraf

packages/hypergraph-react/src/prepare-publish.ts

@@ -1,14 +1,8 @@
-import {
-  type EntityRelationParams,
-  Graph,
-  type Id,
-  type Op,
-  type PropertiesParam,
-  type RelationsParam,
-} from '@graphprotocol/grc-20';
-import type { Entity } from '@graphprotocol/hypergraph';
-import { store } from '@graphprotocol/hypergraph';
+import { Graph, type Id, type Op, type PropertiesParam, type RelationsParam } from '@graphprotocol/grc-20';
+import { Constants, type Entity, Utils } from '@graphprotocol/hypergraph';
+import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
+import * as SchemaAST from 'effect/SchemaAST';
 import request, { gql } from 'graphql-request';
 
 export type PreparePublishParams<S extends Schema.Schema.AnyNoContext> = {
@@ -63,101 +57,70 @@ export const preparePublish = async <S extends Schema.Schema.AnyNoContext>({
     },
   );
 
-  const mapping = store.getSnapshot().context.mapping;
-  const typeName = entity.type;
-  const mappingEntry = mapping[typeName];
-  if (!mappingEntry) {
-    throw new Error(`Mapping entry for ${typeName} not found`);
-  }
-
   const ops: Op[] = [];
   const values: PropertiesParam = [];
   const relations: RelationsParam = {};
-  const fields = entity.__schema.fields;
+  const type = entity.__schema;
 
   if (data?.entity === null) {
-    for (const [key, propertyId] of Object.entries(mappingEntry.properties || {})) {
-      if (entity[key] === undefined) {
-        if (TypeUtils.isOptional(fields[key])) {
-          continue;
-        }
-        throw new Error(`Value for ${key} is undefined`);
-      }
-      let serializedValue: string = entity[key];
-      if (TypeUtils.isBooleanOrOptionalBooleanType(fields[key])) {
-        serializedValue = Graph.serializeBoolean(entity[key]);
-      } else if (TypeUtils.isDateOrOptionalDateType(fields[key])) {
-        serializedValue = Graph.serializeDate(entity[key]);
-      } else if (TypeUtils.isPointOrOptionalPointType(fields[key])) {
-        serializedValue = Graph.serializePoint(entity[key]);
-      } else if (TypeUtils.isNumberOrOptionalNumberType(fields[key])) {
-        serializedValue = Graph.serializeNumber(entity[key]);
-      }
-      values.push({ property: propertyId, value: serializedValue });
-    }
-    for (const [key, relationId] of Object.entries(mappingEntry.relations || {})) {
-      // @ts-expect-error - TODO: fix the types error
-      relations[relationId] = entity[key].map((relationEntity) => {
-        const newRelation: EntityRelationParams = { toEntity: relationEntity.id };
-        if (relationEntity._relation.id) {
-          newRelation.id = relationEntity._relation.id;
+    const ast = type.ast as SchemaAST.TypeLiteral;
+
+    const typeIds = SchemaAST.getAnnotation<string[]>(Constants.TypeIdsSymbol)(ast).pipe(Option.getOrElse(() => []));
+
+    for (const prop of ast.propertySignatures) {
+      const propertyId = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
+      const propertyType = SchemaAST.getAnnotation<string>(Constants.PropertyTypeSymbol)(prop.type);
+      if (!Option.isSome(propertyId) || !Option.isSome(propertyType)) continue;
+
+      if (Utils.isRelation(prop.type)) {
+        // @ts-expect-error any is ok here
+        relations[propertyId.value] = entity[prop.name].map((relationEntity) => {
+          const newRelation: Record<string, string> = { toEntity: relationEntity.id };
+          if (relationEntity._relation.id) {
+            newRelation.id = relationEntity._relation.id;
+          }
+          if (relationEntity._relation.position) {
+            newRelation.position = relationEntity._relation.position;
+          }
+          return newRelation;
+        });
+      } else {
+        if (entity[prop.name] === undefined) {
+          if (prop.isOptional) {
+            continue;
+          }
+          throw new Error(`Value for ${String(prop.name)} is undefined`);
         }
-        if (relationEntity._relation.position) {
-          newRelation.position = relationEntity._relation.position;
+        let serializedValue: string = entity[prop.name];
+        if (propertyType.value === 'boolean') {
+          serializedValue = Graph.serializeBoolean(entity[prop.name]);
+        } else if (propertyType.value === 'date') {
+          serializedValue = Graph.serializeDate(entity[prop.name]);
+        } else if (propertyType.value === 'point') {
+          serializedValue = Graph.serializePoint(entity[prop.name]);
+        } else if (propertyType.value === 'number') {
+          serializedValue = Graph.serializeNumber(entity[prop.name]);
         }
-        return newRelation;
-      });
+        values.push({ property: propertyId.value, value: serializedValue });
+      }
     }
+
     const { ops: createOps } = Graph.createEntity({
       id: entity.id,
-      types: mappingEntry.typeIds,
+      types: typeIds,
       values,
       relations,
     });
     ops.push(...createOps);
     return { ops };
   }
 
-  if (data?.entity) {
-    for (const [key, propertyId] of Object.entries(mappingEntry.properties || {})) {
-      if (entity[key] === undefined) {
-        if (TypeUtils.isOptional(fields[key])) {
-          continue;
-        }
-        throw new Error(`Value for ${key} is undefined`);
-      }
-
-      const existingValueEntry = data.entity.valuesList.find((value) => value.propertyId === propertyId);
-      let existingValue = existingValueEntry?.string;
-      let serializedValue: string = entity[key];
-      if (TypeUtils.isBooleanOrOptionalBooleanType(fields[key])) {
-        existingValue =
-          existingValueEntry?.boolean !== undefined ? Graph.serializeBoolean(existingValueEntry.boolean) : undefined;
-        serializedValue = Graph.serializeBoolean(entity[key]);
-      } else if (TypeUtils.isDateOrOptionalDateType(fields[key])) {
-        existingValue = existingValueEntry?.time;
-        serializedValue = Graph.serializeDate(entity[key]);
-      } else if (TypeUtils.isPointOrOptionalPointType(fields[key])) {
-        existingValue = existingValueEntry?.point;
-        serializedValue = Graph.serializePoint(entity[key]);
-      } else if (TypeUtils.isNumberOrOptionalNumberType(fields[key])) {
-        existingValue =
-          existingValueEntry?.number !== undefined ? Graph.serializeNumber(existingValueEntry.number) : undefined;
-        serializedValue = Graph.serializeNumber(entity[key]);
-      }
-
-      if (serializedValue !== existingValue) {
-        values.push({ property: propertyId, value: serializedValue });
-      }
-    }
-
-    // TODO: handle added or removed relations
-    // TODO: handle updated relations
-    // TODO: handle added or removed types
-    if (values.length > 0) {
-      const { ops: updateEntityOps } = Graph.updateEntity({ id: entity.id, values });
-      ops.push(...updateEntityOps);
-    }
+  // TODO: handle added or removed relations
+  // TODO: handle updated relations
+  // TODO: handle added or removed types
+  if (values.length > 0) {
+    const { ops: updateEntityOps } = Graph.updateEntity({ id: entity.id, values });
+    ops.push(...updateEntityOps);
   }
 
   return { ops };