feat(typesync pkg): create utils to convert name to camelCase or PascalCase

Author: cmwhited

packages/typesync/package.json

@@ -26,19 +26,17 @@
     "./Mapping": {
       "types": "./dist/Mapping.d.ts",
       "default": "./dist/Mapping.js"
+    },
+    "./Utils": {
+      "types": "./dist/Utils.d.ts",
+      "default": "./dist/Utils.js"
     }
   },
   "sideEffects": [],
   "scripts": {
     "build": "tsc -b --force tsconfig.build.json && babel dist --plugins annotate-pure-calls --out-dir dist --source-maps && node ../../scripts/package.mjs",
     "test": "vitest"
   },
-  "peerDependencies": {
-    "@graphprotocol/hypergraph": "workspace:*"
-  },
-  "devDependencies": {
-    "@graphprotocol/hypergraph": "workspace:*"
-  },
   "dependencies": {
     "@graphprotocol/grc-20": "^0.17.1",
     "effect": "^3.16.5"

packages/typesync/src/Mapping.ts

@@ -1,6 +1,8 @@
 import { type CreatePropertyParams, Graph, Id as Grc20Id, type Op } from '@graphprotocol/grc-20';
 import { Array as EffectArray, Schema as EffectSchema, pipe } from 'effect';
 
+import { namesAreUnique, toCamelCase, toPascalCase } from './Utils.js';
+
 /**
  * Mappings for a schema type and its properties/relations
  *
@@ -24,16 +26,6 @@ export type MappingEntry = {
         [key: string]: Grc20Id.Id;
       }
     | undefined;
-  /**
-   * Record of schema type relation names to the `Id.Id` of the relation in the Knowledge Graph
-   *
-   * @since 0.0.1
-   */
-  relations?:
-    | {
-        [key: string]: Grc20Id.Id;
-      }
-    | undefined;
 };
 
 /**
@@ -55,10 +47,8 @@ export type MappingEntry = {
  *     properties: {
  *       name: Id.Id('3808e060-fb4a-4d08-8069-35b8c8a1902b'),
  *       description: Id.Id('1f0d9007-8da2-4b28-ab9f-3bc0709f4837'),
+ *       speaker: Id.Id('a5fd07b1-120f-46c6-b46f-387ef98396a6')
  *     },
- *     relations: {
- *       account: Id.Id('a5fd07b1-120f-46c6-b46f-387ef98396a6')
- *     }
  *   }
  * }
  * ```
@@ -69,21 +59,43 @@ export type Mapping = {
   [key: string]: MappingEntry;
 };
 
+/**
+ * @since 0.0.1
+ */
 export type DataTypeRelation = `Relation(${string})`;
+/**
+ * @since 0.0.1
+ */
 export function isDataTypeRelation(val: string): val is DataTypeRelation {
   return /^Relation\((.+)\)$/.test(val);
 }
+/**
+ * @since 0.0.1
+ */
 export const SchemaDataTypeRelation = EffectSchema.NonEmptyTrimmedString.pipe(
   EffectSchema.filter((val) => isDataTypeRelation(val)),
 );
+/**
+ * @since 0.0.1
+ */
 export type SchemaDataTypeRelation = typeof SchemaDataTypeRelation.Type;
-
+/**
+ * @since 0.0.1
+ */
 export const SchemaDataType = EffectSchema.Union(
   EffectSchema.Literal('Text', 'Number', 'Boolean', 'Date', 'Point', 'Url'),
   SchemaDataTypeRelation,
 );
+/**
+ * @since 0.0.1
+ */
 export type SchemaDataType = typeof SchemaDataType.Type;
 
+/**
+ * Represents the user-built schema object to generate a `Mappings` definition for
+ *
+ * @since 0.0.1
+ */
 export const Schema = EffectSchema.Struct({
   types: EffectSchema.Array(
     EffectSchema.Struct({
@@ -95,9 +107,23 @@ export const Schema = EffectSchema.Struct({
           knowledgeGraphId: EffectSchema.NullOr(EffectSchema.UUID),
           dataType: SchemaDataType,
         }),
-      ).pipe(EffectSchema.minItems(1)),
+      ).pipe(
+        EffectSchema.minItems(1),
+        EffectSchema.filter(namesAreUnique, {
+          identifier: 'DuplicatePropertyNames',
+          jsonSchema: {},
+          description: 'The property.name must be unique across all properties in the type',
+        }),
+      ),
+    }),
+  ).pipe(
+    EffectSchema.minItems(1),
+    EffectSchema.filter(namesAreUnique, {
+      identifier: 'DuplicateTypeNames',
+      jsonSchema: {},
+      description: 'The type.name must be unique across all types in the schema',
     }),
-  ).pipe(EffectSchema.minItems(1)),
+  ),
 }).annotations({
   identifier: 'typesync/Schema',
   title: 'TypeSync app Schema',
@@ -123,8 +149,27 @@ export const Schema = EffectSchema.Struct({
     },
   ],
 });
+/**
+ * @since 0.0.1
+ */
 export type Schema = typeof Schema.Type;
+/**
+ * @since 0.0.1
+ */
+export const SchemaKnownDecoder = EffectSchema.decodeSync(Schema);
+/**
+ * @since 0.0.1
+ */
+export const SchemaUnknownDecoder = EffectSchema.decodeUnknownSync(Schema);
 
+/**
+ *
+ *
+ * @since 0.0.1
+ *
+ * @param schema user-built and submitted schema
+ * @returns the generated [Mapping] definition from the submitted schema
+ */
 export async function generateMapping(schema: Schema): Promise<Mapping> {
   const entries: Array<MappingEntry & { typeName: string }> = [];
   const ops: Array<Op> = [];
@@ -134,35 +179,45 @@ export async function generateMapping(schema: Schema): Promise<Mapping> {
     for (const property of type.properties) {
       if (property.knowledgeGraphId) {
         typePropertyIds.push({ propName: property.name, id: Grc20Id.Id(property.knowledgeGraphId) });
+
         continue;
       }
       // create op for creating type property
+      const dataType = mapSchemaDataTypeToGRC20PropDataType(property.dataType);
+      if (dataType === 'RELATION') {
+        const { id, ops: createTypePropOp } = Graph.createProperty({
+          name: property.name,
+          dataType: 'RELATION',
+          relationValueTypes: [],
+          properties: [],
+        });
+        typePropertyIds.push({ propName: property.name, id });
+        ops.push(...createTypePropOp);
+
+        continue;
+      }
       const { id, ops: createTypePropOp } = Graph.createProperty({
         name: property.name,
         dataType: mapSchemaDataTypeToGRC20PropDataType(property.dataType),
       });
       typePropertyIds.push({ propName: property.name, id });
-      // add createProperty ops to array to submit in batch to KG
       ops.push(...createTypePropOp);
     }
 
     const properties: MappingEntry['properties'] = pipe(
       typePropertyIds,
       EffectArray.reduce({} as NonNullable<MappingEntry['properties']>, (props, { propName, id }) => {
-        props[propName] = id;
+        props[toCamelCase(propName)] = id;
 
         return props;
       }),
     );
 
-    const relations: MappingEntry['relations'] = undefined;
-
     if (type.knowledgeGraphId) {
       entries.push({
-        typeName: type.name,
+        typeName: toPascalCase(type.name),
         typeIds: [Grc20Id.Id(type.knowledgeGraphId)],
         properties,
-        relations,
       });
       continue;
     }
@@ -174,14 +229,15 @@ export async function generateMapping(schema: Schema): Promise<Mapping> {
     ops.push(...createTypeOp);
 
     entries.push({
-      typeName: type.name,
+      typeName: toPascalCase(type.name),
       typeIds: [id],
       properties,
-      relations,
     });
   }
 
-  // @todo send ops to Knowledge Graph
+  /**
+   * @todo publish the schema onchain to the Knowledge Graph with hypergraph connect app to the application space
+   */
 
   return pipe(
     entries,

packages/typesync/src/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 * as Utils from '@graphprotocol/typesync/Utils'
+ *
+ * expect(Utils.toCamelCase('Address line 1')).toEqual('addressLine1');
+ * expect(Utils.toCamelCase('AddressLine1')).toEqual('addressLine1');
+ * expect(Utils.toCamelCase('addressLine1')).toEqual('addressLine1');
+ * expect(Utils.toCamelCase('address_line_1')).toEqual('addressLine1');
+ * expect(Utils.toCamelCase('address-line-1')).toEqual('addressLine1');
+ * expect(Utils.toCamelCase('address-line_1')).toEqual('addressLine1');
+ * expect(Utils.toCamelCase('address-line 1')).toEqual('addressLine1');
+ * expect(Utils.toCamelCase('ADDRESS_LINE_1')).toEqual('addressLine1');
+ * ```
+ *
+ * @since 0.0.1
+ *
+ * @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
+ * import * as Utils from '@graphprotocol/typesync/Utils'
+ *
+ * expect(Utils.toPascalCase('Address line 1')).toEqual('AddressLine1');
+ * expect(Utils.toPascalCase('AddressLine1')).toEqual('AddressLine1');
+ * expect(Utils.toPascalCase('addressLine1')).toEqual('AddressLine1');
+ * expect(Utils.toPascalCase('address_line_1')).toEqual('AddressLine1');
+ * expect(Utils.toPascalCase('address-line-1')).toEqual('AddressLine1');
+ * expect(Utils.toPascalCase('address-line_1')).toEqual('AddressLine1');
+ * expect(Utils.toPascalCase('address-line 1')).toEqual('AddressLine1');
+ * expect(Utils.toPascalCase('ADDRESS_LINE_1')).toEqual('AddressLine1');
+ * ```
+ *
+ * @since 0.0.1
+ *
+ * @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;
+}

packages/typesync/src/index.ts

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