@graphprotocol/hypergraph 0.0.1

package/src/utils/index.ts

@@ -0,0 +1,8 @@
+export * from './assertExhaustive.js';
+export * from './automergeId.js';
+export * from './base58.js';
+export * from './generateId.js';
+export * from './hexBytesAddressUtils.js';
+export * from './isRelationField.js';
+export * from './jsc.js';
+export * from './stringToUint8Array.js';

package/src/utils/internal/base58Utils.ts

@@ -0,0 +1,47 @@
+export const BASE58_ALLOWED_CHARS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+export function decodeBase58(str: string) {
+  let x = BigInt(0);
+  for (let i = 0; i < str.length; i++) {
+    const charIndex = BASE58_ALLOWED_CHARS.indexOf(str[i]);
+    if (charIndex < 0) {
+      throw new Error('Invalid Base58 character');
+    }
+    x = x * 58n + BigInt(charIndex);
+  }
+
+  const bytes: number[] = [];
+  while (x > 0) {
+    bytes.push(Number(x % 256n));
+    x = x >> 8n;
+  }
+
+  bytes.reverse();
+  // Pad to 16 bytes for a UUID
+  while (bytes.length < 16) {
+    bytes.unshift(0);
+  }
+
+  return new Uint8Array(bytes);
+}
+
+export function encodeBase58(data: Uint8Array) {
+  let x = BigInt(0);
+  for (const byte of data) {
+    x = (x << 8n) + BigInt(byte);
+  }
+
+  let encoded = '';
+  while (x > 0) {
+    const remainder = x % 58n;
+    x = x / 58n;
+    encoded = BASE58_ALLOWED_CHARS[Number(remainder)] + encoded;
+  }
+
+  // deal with leading zeros (0x00 bytes)
+  for (let i = 0; i < data.length && data[i] === 0; i++) {
+    encoded = `1${encoded}`;
+  }
+
+  return encoded;
+}

package/src/utils/internal/deep-merge.ts

@@ -0,0 +1,38 @@
+// A “plain object” is any non-null object that isn’t an array
+const isPlainObject = (obj: unknown): obj is Record<string, unknown> =>
+  typeof obj === 'object' && obj !== null && !Array.isArray(obj);
+
+/**
+ * Deeply merges two plain‐object types T and U,
+ * returning a new object that has properties of both.
+ * Arrays or other non‐object values in `source` simply overwrite.
+ */
+export const deepMerge = <T extends Record<string, unknown>, U extends Record<string, unknown>>(
+  target: T,
+  source: U,
+): T & U => {
+  // Start with a shallow clone of target
+  const result = { ...target } as T & U;
+
+  for (const key of Object.keys(source) as (keyof U)[]) {
+    const srcVal = source[key];
+    // biome-ignore lint/suspicious/noExplicitAny: good enough
+    const tgtVal = (target as any)[key];
+
+    if (isPlainObject(srcVal) && isPlainObject(tgtVal)) {
+      // Both sides are plain objects → recurse
+      // biome-ignore lint/suspicious/noExplicitAny: good enough
+      result[key] = deepMerge(tgtVal as Record<string, unknown>, srcVal as Record<string, unknown>) as any;
+    } else if (isPlainObject(srcVal)) {
+      // Source is object but target missing or not object → clone source
+      // biome-ignore lint/suspicious/noExplicitAny: good enough
+      result[key] = deepMerge({} as Record<string, unknown>, srcVal as Record<string, unknown>) as any;
+    } else {
+      // Non‐objects (including arrays) overwrite
+      // biome-ignore lint/suspicious/noExplicitAny: good enough
+      result[key] = srcVal as any;
+    }
+  }
+
+  return result;
+};

package/src/utils/isRelationField.ts

@@ -0,0 +1,9 @@
+import type * as Schema from 'effect/Schema';
+
+export const isRelationField = (field: Schema.Schema.All | Schema.PropertySignature.All<PropertyKey>) => {
+  // TODO: improve this check
+  if (field.ast._tag === 'TupleType') {
+    return true;
+  }
+  return false;
+};

package/src/utils/jsc.ts

@@ -0,0 +1,94 @@
+export class NaNNotAllowedError extends Error {
+  constructor() {
+    super('NaN is not allowed');
+  }
+}
+export class InfinityNotAllowedError extends Error {
+  constructor() {
+    super('Infinity is not allowed');
+  }
+}
+
+/**
+ * JSON canonicalize function.
+ * Creates crypto safe predictable canocalization of JSON as defined by RFC8785.
+ *
+ * @see https://tools.ietf.org/html/rfc8785
+ * @see https://www.rfc-editor.org/rfc/rfc8785
+ *
+ * @example <caption>Primitive values</caption>
+ * ```ts
+ * import { canonicalize } from '@graph-framework/utils'
+ *
+ * console.log(canonicalize(null)) // 'null'
+ * console.log(canonicalize(1)) // '1'
+ * console.log(canonicalize("test")) // "string"
+ * console.log(canonicalize(true)) // 'true'
+ * ```
+ *
+ * @example <caption>Objects</caption>
+ * ```
+ * import { canonicalize } from '@graph-framework/utils'
+ *
+ * const json = {
+ *    from_account: '543 232 625-3',
+ *    to_account: '321 567 636-4',
+ *    amount: 500,
+ *    currency: 'USD',
+ * };
+ * console.log(canonicalize(json)) // '{"amount":500,"currency":"USD","from_account":"543 232 625-3","to_account":"321 567 636-4"}'
+ * ```
+ *
+ * @example <caption>Arrays</caption>
+ * ```ts
+ * import { canonicalize } from '@graph-framework/utils'
+ *
+ * console.log(canonicalize([1, 'text', null, true, false])) // '[1,"text",null,true,false]'
+ * ```
+ *
+ * @param object object to JSC canonicalize
+ * @throws NaNNotAllowedError if given object is of type number, but is not a valid number
+ * @throws InfinityNotAllowedError if given object is of type number, but is the infinite number
+ */
+export function canonicalize<T = unknown>(object: T): string {
+  if (typeof object === 'number' && Number.isNaN(object)) {
+    throw new NaNNotAllowedError();
+  }
+  if (typeof object === 'number' && !Number.isFinite(object)) {
+    throw new InfinityNotAllowedError();
+  }
+
+  if (object === null || typeof object !== 'object') {
+    return JSON.stringify(object);
+  }
+
+  // biome-ignore lint/suspicious/noExplicitAny: typeof T is unknown, cast to any to check
+  if ((object as any).toJSON instanceof Function) {
+    // biome-ignore lint/suspicious/noExplicitAny: typeof T is unknown, cast to any to check
+    return canonicalize((object as any).toJSON());
+  }
+
+  if (Array.isArray(object)) {
+    const values = object.reduce((t, cv) => {
+      if (cv === undefined || typeof cv === 'symbol') {
+        return t; // Skip undefined and symbol values entirely
+      }
+      const comma = t.length === 0 ? '' : ',';
+      return `${t}${comma}${canonicalize(cv)}`;
+    }, '');
+    return `[${values}]`;
+  }
+
+  const values = Object.keys(object)
+    .sort()
+    .reduce((t, cv) => {
+      // biome-ignore lint/suspicious/noExplicitAny: typeof T is unknown, cast to any to check
+      if ((object as any)[cv] === undefined || typeof (object as any)[cv] === 'symbol') {
+        return t;
+      }
+      const comma = t.length === 0 ? '' : ',';
+      // biome-ignore lint/suspicious/noExplicitAny: typeof T is unknown, cast to any to check
+      return `${t}${comma}${canonicalize(cv)}:${canonicalize((object as any)[cv])}`;
+    }, '');
+  return `{${values}}`;
+}

package/src/utils/stringToUint8Array.ts

@@ -0,0 +1,9 @@
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export const stringToUint8Array = (str: string): Uint8Array => {
+  return encoder.encode(str);
+};
+
+export const uint8ArrayToString = (uint8Array: Uint8Array): string => {
+  return decoder.decode(uint8Array);
+};