@graphprotocol/hypergraph 0.1.0 → 0.3.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/store.ts

@@ -1,10 +1,10 @@
 import type { AnyDocumentId, DocHandle, Repo } from '@automerge/automerge-repo';
-import type { Mapping } from '@graphprotocol/typesync/Mapping';
 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 { idToAutomergeId } from './utils/automergeId.js';

package/src/type/type.ts

@@ -2,10 +2,12 @@ import * as Schema from 'effect/Schema';
 import { Field } from '../entity/entity.js';
 import type { AnyNoContext, EntityWithRelation } from '../entity/types.js';
 
-export const Text = Schema.String;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
+export const String = Schema.String;
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
 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 Boolean = Schema.Boolean;
 // biome-ignore lint/suspicious/noShadowRestrictedNames: is part of a namespaces module and therefor ok
 export const Date = Schema.Date;
 export const Point = Schema.transform(Schema.String, Schema.Array(Number), {
@@ -16,6 +18,8 @@ export const Point = Schema.transform(Schema.String, Schema.Array(Number), {
   encode: (points: readonly number[]) => points.join(','),
 });
 
+export const optional = Schema.optional;
+
 export const Relation = <S extends AnyNoContext>(schema: S) => {
   const relationSchema = Field({
     select: Schema.Array(schema) as unknown as Schema.Schema<ReadonlyArray<EntityWithRelation<S>>>,

package/src/type-utils/type-utils.ts

@@ -0,0 +1,46 @@
+import * as Type from '../type/type.js';
+
+// biome-ignore lint/suspicious/noExplicitAny: TODO
+export const isStringOrOptionalStringType = (type: any) => {
+  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
+    return type.from === Type.String;
+  }
+  return type === Type.String;
+};
+
+// biome-ignore lint/suspicious/noExplicitAny: TODO
+export const isNumberOrOptionalNumberType = (type: any) => {
+  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
+    return type.from === Type.Number;
+  }
+  return type === Type.Number;
+};
+
+// biome-ignore lint/suspicious/noExplicitAny: TODO
+export const isDateOrOptionalDateType = (type: any) => {
+  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
+    return type.from === Type.Date;
+  }
+  return type === Type.Date;
+};
+
+// biome-ignore lint/suspicious/noExplicitAny: TODO
+export const isBooleanOrOptionalBooleanType = (type: any) => {
+  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
+    return type.from === Type.Boolean;
+  }
+  return type === Type.Boolean;
+};
+
+// biome-ignore lint/suspicious/noExplicitAny: TODO
+export const isPointOrOptionalPointType = (type: any) => {
+  if (type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional) {
+    return type.from === Type.Point;
+  }
+  return type === Type.Point;
+};
+
+// biome-ignore lint/suspicious/noExplicitAny: TODO
+export const isOptional = (type: any) => {
+  return type.ast && type.ast._tag === 'PropertySignatureDeclaration' && type.ast.isOptional;
+};