@graphprotocol/hypergraph 0.0.14 → 0.2.0

package/src/mapping/Utils.ts

@@ -0,0 +1,156 @@
+import { Data, String as EffectString } from 'effect';
+
+/**
+ * Takes the input string and returns the camelCase equivalent
+ *
+ * @example
+ * ```ts
+ * import { toCamelCase } from '@graphprotocol/hypergraph/mapping'
+ *
+ * expect(toCamelCase('Address line 1')).toEqual('addressLine1');
+ * expect(toCamelCase('AddressLine1')).toEqual('addressLine1');
+ * expect(toCamelCase('addressLine1')).toEqual('addressLine1');
+ * expect(toCamelCase('address_line_1')).toEqual('addressLine1');
+ * expect(toCamelCase('address-line-1')).toEqual('addressLine1');
+ * expect(toCamelCase('address-line_1')).toEqual('addressLine1');
+ * expect(toCamelCase('address-line 1')).toEqual('addressLine1');
+ * expect(toCamelCase('ADDRESS_LINE_1')).toEqual('addressLine1');
+ * ```
+ *
+ * @since 0.2.0
+ *
+ * @param str input string
+ * @returns camelCased value of the input string
+ */
+export function toCamelCase(str: string): string {
+  if (EffectString.isEmpty(str)) {
+    throw new InvalidInputError({ input: str, cause: 'Input is empty' });
+  }
+
+  let result = '';
+  let capitalizeNext = false;
+  let i = 0;
+
+  // Skip leading non-alphanumeric characters
+  while (i < EffectString.length(str) && !/[a-zA-Z0-9]/.test(str[i])) {
+    i++;
+  }
+
+  for (; i < EffectString.length(str); i++) {
+    const char = str[i];
+
+    if (/[a-zA-Z0-9]/.test(char)) {
+      if (capitalizeNext) {
+        result += EffectString.toUpperCase(char);
+        capitalizeNext = false;
+      } else if (EffectString.length(result) === 0) {
+        // First character should always be lowercase
+        result += EffectString.toLowerCase(char);
+      } else if (/[A-Z]/.test(char) && i > 0 && /[a-z0-9]/.test(str[i - 1])) {
+        // Capital letter following lowercase/number - this indicates a word boundary
+        // So we need to capitalize this letter (it starts a new word)
+        result += EffectString.toUpperCase(char);
+      } else {
+        result += EffectString.toLowerCase(char);
+      }
+    } else {
+      // Non-alphanumeric character - set flag to capitalize next letter
+      capitalizeNext = EffectString.length(result) > 0; // Only capitalize if we have existing content
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Takes the input string and returns the PascalCase equivalent
+ *
+ * @example
+ * ```ts
+ * iimport { toPascalCase } from '@graphprotocol/hypergraph/mapping'
+ *
+ * expect(toPascalCase('Address line 1')).toEqual('AddressLine1');
+ * expect(toPascalCase('AddressLine1')).toEqual('AddressLine1');
+ * expect(toPascalCase('addressLine1')).toEqual('AddressLine1');
+ * expect(toPascalCase('address_line_1')).toEqual('AddressLine1');
+ * expect(toPascalCase('address-line-1')).toEqual('AddressLine1');
+ * expect(toPascalCase('address-line_1')).toEqual('AddressLine1');
+ * expect(toPascalCase('address-line 1')).toEqual('AddressLine1');
+ * expect(toPascalCase('ADDRESS_LINE_1')).toEqual('AddressLine1');
+ * ```
+ *
+ * @since 0.2.0
+ *
+ * @param str input string
+ * @returns PascalCased value of the input string
+ */
+export function toPascalCase(str: string): string {
+  if (EffectString.isEmpty(str)) {
+    throw new InvalidInputError({ input: str, cause: 'Input is empty' });
+  }
+
+  let result = '';
+  let capitalizeNext = true; // Start with true to capitalize the first letter
+  let i = 0;
+
+  // Skip leading non-alphanumeric characters
+  while (i < EffectString.length(str) && !/[a-zA-Z0-9]/.test(str[i])) {
+    i++;
+  }
+
+  for (; i < EffectString.length(str); i++) {
+    const char = str[i];
+
+    if (/[a-zA-Z0-9]/.test(char)) {
+      if (capitalizeNext) {
+        result += EffectString.toUpperCase(char);
+        capitalizeNext = false;
+      } else if (/[A-Z]/.test(char) && i > 0 && /[a-z0-9]/.test(str[i - 1])) {
+        // Capital letter following lowercase/number - this indicates a word boundary
+        // So we need to capitalize this letter (it starts a new word)
+        result += EffectString.toUpperCase(char);
+      } else {
+        result += EffectString.toLowerCase(char);
+      }
+    } else {
+      // Non-alphanumeric character - set flag to capitalize next letter
+      capitalizeNext = true;
+    }
+  }
+
+  return result;
+}
+
+export class InvalidInputError extends Data.TaggedError('/typesync/errors/InvalidInputError')<{
+  readonly input: string;
+  readonly cause: unknown;
+}> {}
+
+/**
+ * Adds schema validation that the array of objects with property `name` only has unique names
+ *
+ * @example <caption>only unique names -> returns true</caption>
+ * ```ts
+ * const types = [{name:'Account'}, {name:'Event'}]
+ * expect(namesAreUnique(types)).toEqual(true)
+ * ```
+ *
+ * @example <caption>duplicate name -> returns false</caption>
+ * ```ts
+ * const types = [{name:'Account'}, {name:'Event'}, {name:'Account'}]
+ * expect(namesAreUnique(types)).toEqual(false)
+ * ```
+ */
+export function namesAreUnique<T extends { readonly name: string }>(entries: ReadonlyArray<T>): boolean {
+  const names = new Set<string>();
+
+  for (const entry of entries) {
+    const name = EffectString.toLowerCase(entry.name);
+    if (names.has(name)) {
+      return false;
+    }
+    names.add(name);
+  }
+
+  return true;
+}

package/src/mapping/index.ts

@@ -0,0 +1,2 @@
+export * from './Mapping.js';
+export * from './Utils.js';

package/src/messages/types.ts

@@ -245,7 +245,6 @@ export const RequestConnectCreateAppIdentity = Schema.Struct({
   address: Schema.String,
   accountAddress: Schema.String,
   ciphertext: Schema.String,
-  nonce: Schema.String,
   signaturePublicKey: Schema.String,
   encryptionPublicKey: Schema.String,
   accountProof: Schema.String,
@@ -450,6 +449,7 @@ export const ResponseIdentity = Schema.Struct({
   encryptionPublicKey: Schema.String,
   accountProof: Schema.String,
   keyProof: Schema.String,
+  appId: Schema.optional(Schema.String),
 });
 
 export type ResponseIdentity = Schema.Schema.Type<typeof ResponseIdentity>;

package/src/space-events/apply-event.ts

@@ -18,7 +18,10 @@ import {
 type Params = {
   state: SpaceState | undefined;
   event: SpaceEvent;
-  getVerifiedIdentity: (accountAddress: string) => Effect.Effect<PublicIdentity, InvalidIdentityError>;
+  getVerifiedIdentity: (
+    accountAddress: string,
+    publicKey: string,
+  ) => Effect.Effect<PublicIdentity, InvalidIdentityError>;
 };
 
 const decodeSpaceEvent = Schema.decodeUnknownEither(SpaceEvent);
@@ -50,7 +53,7 @@ export const applyEvent = ({
   const authorPublicKey = `0x${signatureInstance.recoverPublicKey(sha256(encodedTransaction)).toHex()}`;
 
   return Effect.gen(function* () {
-    const identity = yield* getVerifiedIdentity(event.author.accountAddress);
+    const identity = yield* getVerifiedIdentity(event.author.accountAddress, authorPublicKey);
     if (authorPublicKey !== identity.signaturePublicKey) {
       yield* Effect.fail(new VerifySignatureError());
     }

package/src/space-info/decrypt-space-info.ts

@@ -6,13 +6,7 @@ import { SpaceInfoContent } from './types.js';
 
 const decodeSpaceInfoContent = Schema.decodeSync(SpaceInfoContent);
 
-export const decryptSpaceInfo = ({
-  spaceInfo,
-  secretKey,
-}: {
-  spaceInfo: Uint8Array;
-  secretKey: string;
-}) => {
+export const decryptSpaceInfo = ({ spaceInfo, secretKey }: { spaceInfo: Uint8Array; secretKey: string }) => {
   const decrypted = decryptMessage({
     nonceAndCiphertext: spaceInfo,
     secretKey: hexToBytes(secretKey),

package/src/store-connect.ts

@@ -1,5 +1,5 @@
 import type { AnyDocumentId, DocHandle, Repo } from '@automerge/automerge-repo';
-import { type Store, createStore } from '@xstate/store';
+import { createStore, type Store } from '@xstate/store';
 import type { Address } from 'viem';
 import { mergeMessages } from './inboxes/merge-messages.js';
 import type { InboxSenderAuthPolicy } from './inboxes/types.js';

package/src/store.ts

@@ -1,12 +1,12 @@
 import type { AnyDocumentId, DocHandle, Repo } from '@automerge/automerge-repo';
-import { type Store, createStore } from '@xstate/store';
+import { createStore, type Store } from '@xstate/store';
 import type { PrivateAppIdentity } from './connect/types.js';
 import type { DocumentContent } from './entity/types.js';
 import { mergeMessages } from './inboxes/merge-messages.js';
 import type { InboxSenderAuthPolicy } from './inboxes/types.js';
+import type { Mapping } from './mapping/Mapping.js';
 import type { Invitation, Updates } from './messages/index.js';
 import type { SpaceEvent, SpaceState } from './space-events/index.js';
-import type { Mapping } from './types.js';
 import { idToAutomergeId } from './utils/automergeId.js';
 
 export type InboxMessageStorageEntry = {
@@ -64,7 +64,8 @@ interface StoreContext {
       signaturePublicKey: string;
       accountProof: string;
       keyProof: string;
-    };
+      appId: string | null;
+    }[];
   };
   authenticated: boolean;
   identity: PrivateAppIdentity | null;
@@ -104,6 +105,7 @@ type StoreEvent =
       signaturePublicKey: string;
       accountProof: string;
       keyProof: string;
+      appId: string | null;
     }
   | {
       type: 'setSpaceInbox';
@@ -291,18 +293,46 @@ export const store: Store<StoreContext, StoreEvent, GenericEventObject> = create
         signaturePublicKey: string;
         accountProof: string;
         keyProof: string;
+        appId: string | null;
       },
     ) => {
+      const existingIdentity = context.identities[event.accountAddress]?.find(
+        (identity) => identity.signaturePublicKey === event.signaturePublicKey,
+      );
+      if (existingIdentity) {
+        return context;
+      }
+      if (context.identities[event.accountAddress]) {
+        return {
+          ...context,
+          identities: {
+            ...context.identities,
+            [event.accountAddress]: [
+              ...context.identities[event.accountAddress],
+              {
+                encryptionPublicKey: event.encryptionPublicKey,
+                signaturePublicKey: event.signaturePublicKey,
+                accountProof: event.accountProof,
+                keyProof: event.keyProof,
+                appId: event.appId,
+              },
+            ],
+          },
+        };
+      }
       return {
         ...context,
         identities: {
           ...context.identities,
-          [event.accountAddress]: {
-            encryptionPublicKey: event.encryptionPublicKey,
-            signaturePublicKey: event.signaturePublicKey,
-            accountProof: event.accountProof,
-            keyProof: event.keyProof,
-          },
+          [event.accountAddress]: [
+            {
+              encryptionPublicKey: event.encryptionPublicKey,
+              signaturePublicKey: event.signaturePublicKey,
+              accountProof: event.accountProof,
+              keyProof: event.keyProof,
+              appId: event.appId,
+            },
+          ],
         },
       };
     },

package/src/type/type.ts

@@ -8,7 +8,6 @@ export const Number = Schema.Number;
 export const Checkbox = Schema.Boolean;
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
 export const Date = Schema.Date;
-export const Url = Schema.URL;
 export const Point = Schema.transform(Schema.String, Schema.Array(Number), {
   strict: true,
   decode: (str: string) => {

package/src/types.ts

@@ -1,4 +1,3 @@
-import type { Id as Grc20Id } from '@graphprotocol/grc-20';
 import * as Data from 'effect/Data';
 import * as Schema from 'effect/Schema';
 
@@ -49,17 +48,3 @@ export class FailedToParseConnectAuthUrl extends Data.TaggedError('FailedToParse
 export class FailedToParseAuthCallbackUrl extends Data.TaggedError('FailedToParseAuthCallbackUrl')<{
   message: string;
 }> {}
-
-export type MappingEntry = {
-  typeIds: Grc20Id.Id[];
-  properties?: {
-    [key: string]: Grc20Id.Id;
-  };
-  relations?: {
-    [key: string]: Grc20Id.Id;
-  };
-};
-
-export type Mapping = {
-  [key: string]: MappingEntry;
-};