@graphprotocol/hypergraph 0.0.1

package/src/entity/removeRelation.ts

@@ -0,0 +1,21 @@
+import type { DocHandle } from '@automerge/automerge-repo';
+import type { DocumentContent } from './types.js';
+
+/**
+ * Removes a relation from an entity
+ */
+export const removeRelation = (handle: DocHandle<DocumentContent>) => {
+  return (relationId: string): boolean => {
+    let result = false;
+
+    // apply changes to the repo -> removes the existing entity by its id
+    handle.change((doc) => {
+      if (doc.relations?.[relationId] !== undefined) {
+        doc.relations[relationId].__deleted = true;
+        result = true;
+      }
+    });
+
+    return result;
+  };
+};

package/src/entity/types.ts

@@ -0,0 +1,100 @@
+import type * as Schema from 'effect/Schema';
+
+export type Any = Schema.Schema.Any & {
+  readonly fields: Schema.Struct.Fields;
+  readonly insert: Schema.Schema.Any;
+  readonly update: Schema.Schema.Any;
+};
+
+export type AnyNoContext = Schema.Schema.AnyNoContext & {
+  readonly fields: Schema.Struct.Fields;
+  readonly insert: Schema.Schema.AnyNoContext;
+  readonly update: Schema.Schema.AnyNoContext;
+};
+
+export type Update<S extends Any> = S['update'];
+export type Insert<S extends Any> = S['insert'];
+
+export type Entity<S extends AnyNoContext> = Schema.Schema.Type<S> & {
+  type: string;
+  // TODO: can we solve this directly on the variante schema?
+  id: string;
+  // TODO: should we expose these internal fields?
+  // __deleted: boolean;
+  // __version: string;
+};
+
+export type EntityWithRelation<S extends AnyNoContext> = Entity<S> & {
+  _relation: { id: string } | undefined;
+};
+
+export type DocumentEntity = {
+  __deleted: boolean;
+  [key: string]: unknown;
+};
+
+export type DocumentRelation = {
+  from: string;
+  to: string;
+  fromTypeName: string;
+  fromPropertyName: string;
+  __deleted: boolean;
+  [key: string]: unknown;
+};
+
+export type DocumentContent = {
+  entities?: Record<string, DocumentEntity>;
+  relations?: Record<string, DocumentRelation>;
+};
+
+export type EntityCheckboxFilter = {
+  is: boolean;
+};
+
+export type EntityNumberFilter = {
+  is?: number;
+  greaterThan?: number;
+  lessThan?: number;
+  NOT?: EntityNumberFilter;
+  OR?: EntityNumberFilter[];
+};
+
+export type EntityTextFilter = {
+  is?: string;
+  startsWith?: string;
+  endsWith?: string;
+  contains?: string;
+  equals?: string;
+  NOT?: EntityTextFilter;
+  OR?: EntityTextFilter[];
+};
+
+export type CrossFieldFilter<T> = {
+  [K in keyof T]?: EntityFieldFilter<T[K]>;
+} & {
+  OR?: Array<CrossFieldFilter<T>>;
+  NOT?: CrossFieldFilter<T>;
+};
+
+export type EntityFieldFilter<T> = {
+  is?: T;
+  NOT?: EntityFieldFilter<T>;
+  OR?: Array<EntityFieldFilter<T>>;
+} & (T extends boolean
+  ? {
+      is?: boolean;
+    }
+  : T extends number
+    ? {
+        greaterThan?: number;
+        lessThan?: number;
+      }
+    : T extends string
+      ? {
+          startsWith?: string;
+          endsWith?: string;
+          contains?: string;
+        }
+      : Record<string, never>);
+
+export type EntityFilter<T> = CrossFieldFilter<T>;

package/src/entity/update.ts

@@ -0,0 +1,58 @@
+import type { DocHandle } from '@automerge/automerge-repo';
+import * as Schema from 'effect/Schema';
+import { EntityNotFoundError } from './entity.js';
+import type { AnyNoContext, DocumentContent, Entity, Update } from './types.js';
+
+/**
+ * Update an existing entity model of given type in the repo.
+ */
+export const update = <const S extends AnyNoContext>(handle: DocHandle<DocumentContent>, type: S) => {
+  const validate = Schema.validateSync(Schema.partial(type.update));
+  const encode = Schema.encodeSync(type.update);
+  const decode = Schema.decodeUnknownSync(type.update);
+
+  // TODO: what's the right way to get the name of the type?
+  // @ts-expect-error name is defined
+  const typeName = type.name;
+
+  return (id: string, data: Schema.Simplify<Partial<Schema.Schema.Type<Update<S>>>>): Entity<S> => {
+    validate(data);
+
+    // apply changes to the repo -> updates the existing entity to the repo entities document
+    let updated: Schema.Schema.Type<S> | undefined = undefined;
+    handle.change((doc) => {
+      if (doc.entities === undefined) {
+        return;
+      }
+
+      // TODO: Fetch the pre-decoded value from the local cache.
+      const entity = doc.entities[id] ?? undefined;
+      if (entity === undefined || typeof entity !== 'object') {
+        return;
+      }
+
+      // TODO: Try to get a diff of the entity properties and only override the changed ones.
+      updated = { ...decode(entity), ...data };
+
+      const encoded = {
+        ...encode(updated),
+        '@@types@@': [typeName],
+        __deleted: entity.__deleted ?? false,
+        __version: entity.__version ?? '',
+      };
+      // filter out undefined values otherwise Automerge will throw an error
+      for (const key in updated) {
+        if (updated[key] === undefined) {
+          delete encoded[key];
+        }
+      }
+      doc.entities[id] = encoded;
+    });
+
+    if (updated === undefined) {
+      throw new EntityNotFoundError({ id, type });
+    }
+
+    return { id, type: typeName, ...(updated as Schema.Schema.Type<S>) };
+  };
+};