@graphprotocol/hypergraph 0.1.0 → 0.2.0

package/dist/mapping/Mapping.js

@@ -0,0 +1,554 @@
+import { Graph, Id as Grc20Id } from '@graphprotocol/grc-20';
+import { Data, Array as EffectArray, Schema as EffectSchema, Option, pipe } from 'effect';
+import { namesAreUnique, toCamelCase, toPascalCase } from './Utils.js';
+/**
+ * @since 0.2.0
+ */
+export function isDataTypeRelation(val) {
+  return /^Relation\((.+)\)$/.test(val);
+}
+/**
+ * @since 0.2.0
+ */
+export const SchemaDataTypeRelation = /*#__PURE__*/EffectSchema.NonEmptyTrimmedString.pipe(/*#__PURE__*/EffectSchema.filter(val => isDataTypeRelation(val)));
+/**
+ * @since 0.2.0
+ */
+export const SchemaDataTypePrimitive = /*#__PURE__*/EffectSchema.Literal('Text', 'Number', 'Checkbox', 'Date', 'Point');
+/**
+ * @since 0.2.0
+ */
+export const SchemaDataType = /*#__PURE__*/EffectSchema.Union(SchemaDataTypePrimitive, SchemaDataTypeRelation);
+/**
+ * @since 0.2.0
+ */
+export const SchemaTypePropertyRelation = /*#__PURE__*/EffectSchema.Struct({
+  name: EffectSchema.NonEmptyTrimmedString,
+  knowledgeGraphId: /*#__PURE__*/EffectSchema.NullOr(EffectSchema.UUID),
+  dataType: SchemaDataTypeRelation,
+  relationType: /*#__PURE__*/EffectSchema.NonEmptyTrimmedString.annotations({
+    identifier: 'SchemaTypePropertyRelation.relationType',
+    description: 'name of the type within the schema that this property is related to',
+    examples: ['Account']
+  })
+});
+/**
+ * @since 0.2.0
+ */
+export const SchemaTypePropertyPrimitive = /*#__PURE__*/EffectSchema.Struct({
+  name: EffectSchema.NonEmptyTrimmedString,
+  knowledgeGraphId: /*#__PURE__*/EffectSchema.NullOr(EffectSchema.UUID),
+  dataType: SchemaDataTypePrimitive
+});
+/**
+ * @since 0.2.0
+ */
+export function propertyIsRelation(property) {
+  return isDataTypeRelation(property.dataType);
+}
+/**
+ * @since 0.2.0
+ */
+export const SchemaType = /*#__PURE__*/EffectSchema.Struct({
+  name: EffectSchema.NonEmptyTrimmedString,
+  knowledgeGraphId: /*#__PURE__*/EffectSchema.NullOr(EffectSchema.UUID),
+  properties: /*#__PURE__*/EffectSchema.Array(EffectSchema.Union(SchemaTypePropertyPrimitive, SchemaTypePropertyRelation)).pipe(/*#__PURE__*/EffectSchema.minItems(1), /*#__PURE__*/EffectSchema.filter(namesAreUnique, {
+    identifier: 'DuplicatePropertyNames',
+    jsonSchema: {},
+    description: 'The property.name must be unique across all properties in the type'
+  }))
+});
+/**
+ * Represents the user-built schema object to generate a `Mappings` definition for
+ *
+ * @since 0.2.0
+ */
+export const Schema = /*#__PURE__*/EffectSchema.Struct({
+  types: EffectSchema.Array(SchemaType).pipe(EffectSchema.minItems(1), EffectSchema.filter(namesAreUnique, {
+    identifier: 'DuplicateTypeNames',
+    jsonSchema: {},
+    description: 'The type.name must be unique across all types in the schema'
+  }), EffectSchema.filter(allRelationPropertyTypesExist, {
+    identifier: 'AllRelationTypesExist',
+    jsonSchema: {},
+    description: 'Each type property of dataType RELATION must have a type of the same name in the schema'
+  }))
+}).annotations({
+  identifier: 'typesync/Schema',
+  title: 'TypeSync app Schema',
+  description: 'An array of types in the schema defined by the user to generate a Mapping object for',
+  examples: [{
+    types: [{
+      name: 'Account',
+      knowledgeGraphId: null,
+      properties: [{
+        name: 'username',
+        knowledgeGraphId: null,
+        dataType: 'Text'
+      }]
+    }]
+  }, {
+    types: [{
+      name: 'Account',
+      knowledgeGraphId: 'a5fd07b1-120f-46c6-b46f-387ef98396a6',
+      properties: [{
+        name: 'name',
+        knowledgeGraphId: 'a126ca53-0c8e-48d5-b888-82c734c38935',
+        dataType: 'Text'
+      }]
+    }]
+  }]
+});
+/**
+ * @since 0.2.0
+ */
+export const SchemaKnownDecoder = /*#__PURE__*/EffectSchema.decodeSync(Schema);
+/**
+ * @since 0.2.0
+ */
+export const SchemaUnknownDecoder = /*#__PURE__*/EffectSchema.decodeUnknownSync(Schema);
+/**
+ * Iterate through all properties in all types in the schema of `dataType` === `Relation(${string})`
+ * and validate that the schema.types have a type for the existing relation
+ *
+ * @example <caption>All types exist</caption>
+ * ```ts
+ * import { allRelationPropertyTypesExist, type Mapping } from '@graphprotocol/hypergraph/mapping'
+ *
+ * const types: Mapping['types'] = [
+ *   {
+ *     name: "Account",
+ *     knowledgeGraphId: null,
+ *     properties: [
+ *       {
+ *         name: "username",
+ *         dataType: "Text",
+ *         knowledgeGraphId: null
+ *       }
+ *     ]
+ *   },
+ *   {
+ *     name: "Event",
+ *     knowledgeGraphId: null,
+ *     properties: [
+ *       {
+ *         name: "speaker",
+ *         dataType: "Relation(Account)"
+ *         relationType: "Account",
+ *         knowledgeGraphId: null,
+ *       }
+ *     ]
+ *   }
+ * ]
+ * expect(allRelationPropertyTypesExist(types)).toEqual(true)
+ * ```
+ *
+ * @example <caption>Account type is missing</caption>
+ * ```ts
+ * import { allRelationPropertyTypesExist, type Mapping } from '@graphprotocol/hypergraph/mapping'
+ *
+ * const types: Mapping['types'] = [
+ *   {
+ *     name: "Event",
+ *     knowledgeGraphId: null,
+ *     properties: [
+ *       {
+ *         name: "speaker",
+ *         dataType: "Relation(Account)",
+ *         relationType: "Account",
+ *         knowledgeGraphId: null,
+ *       }
+ *     ]
+ *   }
+ * ]
+ * expect(allRelationPropertyTypesExist(types)).toEqual(false)
+ * ```
+ *
+ * @since 0.2.0
+ *
+ * @param types the user-submitted schema types
+ */
+export function allRelationPropertyTypesExist(types) {
+  const unqTypeNames = EffectArray.reduce(types, new Set(), (names, curr) => names.add(curr.name));
+  return pipe(types, EffectArray.flatMap(curr => curr.properties), EffectArray.filter(prop => propertyIsRelation(prop)), EffectArray.every(prop => unqTypeNames.has(prop.relationType)));
+}
+// Helper function to build property map from PropertyIdMappings
+function buildPropertyMap(properties) {
+  return pipe(properties, EffectArray.reduce({}, (props, {
+    propName,
+    id
+  }) => {
+    props[toCamelCase(propName)] = id;
+    return props;
+  }));
+}
+// Helper function to build relation map from PropertyIdMappings
+function buildRelationMap(relations) {
+  return pipe(relations, EffectArray.reduce({}, (rels, {
+    propName,
+    id
+  }) => {
+    rels[toCamelCase(propName)] = id;
+    return rels;
+  }));
+}
+// Helper function to create a property and return the result
+function createPropertyWithOps(property, typeIdMap) {
+  if (property.knowledgeGraphId) {
+    return {
+      type: 'resolved',
+      mapping: {
+        propName: property.name,
+        id: Grc20Id.Id(property.knowledgeGraphId)
+      },
+      ops: []
+    };
+  }
+  if (propertyIsRelation(property)) {
+    const relationTypeId = typeIdMap.get(property.relationType);
+    if (relationTypeId == null) {
+      return {
+        type: 'deferred',
+        property
+      };
+    }
+    const {
+      id,
+      ops
+    } = Graph.createProperty({
+      name: property.name,
+      dataType: 'RELATION',
+      relationValueTypes: [relationTypeId]
+    });
+    return {
+      type: 'resolved',
+      mapping: {
+        propName: property.name,
+        id
+      },
+      ops
+    };
+  }
+  const {
+    id,
+    ops
+  } = Graph.createProperty({
+    name: property.name,
+    dataType: mapSchemaDataTypeToGRC20PropDataType(property.dataType)
+  });
+  return {
+    type: 'resolved',
+    mapping: {
+      propName: property.name,
+      id
+    },
+    ops
+  };
+}
+// Helper function to process a single type
+function processType(type, typeIdMap) {
+  const processedProperties = pipe(type.properties, EffectArray.map(prop => createPropertyWithOps(prop, typeIdMap)));
+  const resolvedProperties = pipe(processedProperties, EffectArray.filterMap(p => p.type === 'resolved' ? Option.some(p) : Option.none()));
+  const deferredProperties = pipe(processedProperties, EffectArray.filterMap(p => p.type === 'deferred' ? Option.some(p.property) : Option.none()));
+  // Separate resolved properties into primitive properties and relations
+  const primitiveProperties = pipe(resolvedProperties, EffectArray.filter(p => {
+    const originalProp = type.properties.find(prop => prop.name === p.mapping.propName);
+    return originalProp ? !propertyIsRelation(originalProp) : false;
+  }), EffectArray.map(p => p.mapping));
+  const relationProperties = pipe(resolvedProperties, EffectArray.filter(p => {
+    const originalProp = type.properties.find(prop => prop.name === p.mapping.propName);
+    return originalProp ? propertyIsRelation(originalProp) : false;
+  }), EffectArray.map(p => p.mapping));
+  const propertyOps = pipe(resolvedProperties, EffectArray.flatMap(p => p.ops));
+  // If type exists in knowledge graph, return complete entry
+  if (type.knowledgeGraphId) {
+    const entry = {
+      typeName: toPascalCase(type.name),
+      typeIds: [Grc20Id.Id(type.knowledgeGraphId)]
+    };
+    if (EffectArray.isNonEmptyArray(primitiveProperties)) {
+      entry.properties = buildPropertyMap(primitiveProperties);
+    }
+    if (EffectArray.isNonEmptyArray(relationProperties)) {
+      entry.relations = buildRelationMap(relationProperties);
+    }
+    return {
+      type: 'complete',
+      entry,
+      ops: propertyOps
+    };
+  }
+  // If there are deferred properties, defer type creation
+  if (EffectArray.isNonEmptyArray(deferredProperties)) {
+    return {
+      type: 'deferred',
+      schemaType: type,
+      properties: primitiveProperties,
+      relations: relationProperties
+    };
+  }
+  // Create the type with all resolved properties (both primitive and relations)
+  const allPropertyIds = [...primitiveProperties, ...relationProperties];
+  const {
+    id,
+    ops: typeOps
+  } = Graph.createType({
+    name: type.name,
+    properties: pipe(allPropertyIds, EffectArray.map(p => p.id))
+  });
+  typeIdMap.set(type.name, id);
+  const entry = {
+    typeName: toPascalCase(type.name),
+    typeIds: [id]
+  };
+  if (EffectArray.isNonEmptyArray(primitiveProperties)) {
+    entry.properties = buildPropertyMap(primitiveProperties);
+  }
+  if (EffectArray.isNonEmptyArray(relationProperties)) {
+    entry.relations = buildRelationMap(relationProperties);
+  }
+  return {
+    type: 'complete',
+    entry,
+    ops: [...propertyOps, ...typeOps]
+  };
+}
+/**
+ * Takes the user-submitted schema, validates it, and build the `Mapping` definition for the schema as well as the GRC-20 Ops needed to publish the schema/schema changes to the Knowledge Graph.
+ *
+ * @example
+ * ```ts
+ * import { Id } from "@graphprotocol/grc-20"
+ * import { generateMapping } from "@graphprotocol/typesync"
+ *
+ * const schema: Schema = {
+ *   types: [
+ *     {
+ *       name: "Account",
+ *       knowledgeGraphId: "a5fd07b1-120f-46c6-b46f-387ef98396a6",
+ *       properties: [
+ *         {
+ *           name: "username",
+ *           dataType: "Text",
+ *           knowledgeGraphId: "994edcff-6996-4a77-9797-a13e5e3efad8"
+ *         },
+ *         {
+ *           name: "createdAt",
+ *           dataType: "Date",
+ *           knowledgeGraphId: null
+ *         }
+ *       ]
+ *     },
+ *     {
+ *       name: "Event",
+ *       knowledgeGraphId: null,
+ *       properties: [
+ *         {
+ *           name: "name",
+ *           dataType: "Text",
+ *           knowledgeGraphId: "3808e060-fb4a-4d08-8069-35b8c8a1902b"
+ *         },
+ *         {
+ *           name: "description",
+ *           dataType: "Text",
+ *           knowledgeGraphId: null
+ *         },
+ *         {
+ *           name: "speaker",
+ *           dataType: "Relation(Account)",
+ *           relationType: "Account",
+ *           knowledgeGraphId: null
+ *         }
+ *       ]
+ *     }
+ *   ],
+ * }
+ * const [mapping, ops] = generateMapping(schema)
+ *
+ * expect(mapping).toEqual({
+ *   Account: {
+ *     typeIds: [Id.Id("a5fd07b1-120f-46c6-b46f-387ef98396a6")], // comes from input schema
+ *     properties: {
+ *       username: Id.Id("994edcff-6996-4a77-9797-a13e5e3efad8"), // comes from input schema
+ *       createdAt: Id.Id("8cd7d9ac-a878-4287-8000-e71e6f853117"), // generated from Graph.createProperty Op
+ *     }
+ *   },
+ *   Event: {
+ *     typeIds: [Id.Id("20b3fe39-8e62-41a0-b9cb-92743fd760da")], // generated from Graph.createType Op
+ *     properties: {
+ *       name: Id.Id("3808e060-fb4a-4d08-8069-35b8c8a1902b"), // comes from input schema
+ *       description: Id.Id("8fc4e17c-7581-4d6c-a712-943385afc7b5"), // generated from Graph.createProperty Op
+ *     },
+ *     relations: {
+ *       speaker: Id.Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"), // generated from Graph.createProperty Op
+ *     }
+ *   }
+ * })
+ * expect(ops).toEqual([
+ *   // Graph.createProperty Op for Account.createdAt property
+ *   {
+ *     type: "CREATE_PROPERTY",
+ *     property: {
+ *       id: Id.Id("8cd7d9ac-a878-4287-8000-e71e6f853117"),
+ *       dataType: "TEXT"
+ *     }
+ *   },
+ *   // Graph.createProperty Op for Event.description property
+ *   {
+ *     type: "CREATE_PROPERTY",
+ *     property: {
+ *       id: Id.Id("8fc4e17c-7581-4d6c-a712-943385afc7b5"),
+ *       dataType: "TEXT"
+ *     }
+ *   },
+ *   // Graph.createProperty Op for Event.speaker property
+ *   {
+ *     type: "CREATE_PROPERTY",
+ *     property: {
+ *       id: Id.Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"),
+ *       dataType: "RELATION"
+ *     }
+ *   },
+ *   // Graph.createType Op for Event type
+ *   {
+ *     type: "CREATE_PROPERTY",
+ *     property: {
+ *       id: Id.Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"),
+ *       dataType: "RELATION"
+ *     }
+ *   },
+ * ])
+ * ```
+ *
+ * @since 0.2.0
+ *
+ * @param input user-built and submitted schema
+ * @returns the generated [Mapping] definition from the submitted schema as well as the GRC-20 Ops required to publish the schema to the Knowledge Graph
+ */
+export function generateMapping(input) {
+  // Validate the schema
+  const schema = SchemaKnownDecoder(input);
+  // Build initial type ID map
+  const typeIdMap = pipe(schema.types, EffectArray.reduce(new Map(), (map, type) => map.set(type.name, type.knowledgeGraphId != null ? Grc20Id.Id(type.knowledgeGraphId) : null)));
+  // First pass: process all types
+  const processedTypes = pipe(schema.types, EffectArray.map(type => processType(type, typeIdMap)));
+  // Separate complete and deferred types
+  const [deferredTypes, completeTypes] = pipe(processedTypes, EffectArray.partition(result => result.type === 'complete'));
+  // Collect all operations from first pass
+  const firstPassOps = pipe(completeTypes, EffectArray.flatMap(t => t.ops));
+  // Second pass: resolve deferred relation properties and create deferred types
+  const {
+    entries: deferredEntries,
+    ops: secondPassOps
+  } = pipe(deferredTypes, EffectArray.reduce({
+    entries: [],
+    ops: []
+  }, (acc, deferred) => {
+    // Resolve all deferred relation properties for this type
+    const resolvedRelations = pipe(deferred.schemaType.properties, EffectArray.filterMap(prop => {
+      if (!propertyIsRelation(prop) || prop.knowledgeGraphId != null) {
+        return Option.none();
+      }
+      const relationTypeId = typeIdMap.get(prop.relationType);
+      if (relationTypeId == null) {
+        throw new RelationValueTypeDoesNotExistError({
+          message: `Failed to resolve type ID for relation type: ${prop.relationType}`,
+          property: prop.name,
+          relatedType: prop.relationType
+        });
+      }
+      const {
+        id,
+        ops
+      } = Graph.createProperty({
+        name: prop.name,
+        dataType: 'RELATION',
+        relationValueTypes: [relationTypeId]
+      });
+      return Option.some({
+        mapping: {
+          propName: prop.name,
+          id
+        },
+        ops
+      });
+    }));
+    // Combine resolved relations with existing relations
+    const allRelations = [...deferred.relations, ...pipe(resolvedRelations, EffectArray.map(r => r.mapping))];
+    // Combine all property IDs for type creation
+    const allPropertyIds = [...deferred.properties, ...allRelations];
+    // Create the type with all properties
+    const {
+      id,
+      ops: typeOps
+    } = Graph.createType({
+      name: deferred.schemaType.name,
+      properties: pipe(allPropertyIds, EffectArray.map(p => p.id))
+    });
+    typeIdMap.set(deferred.schemaType.name, id);
+    // Collect all operations
+    const allOps = [...pipe(resolvedRelations, EffectArray.flatMap(r => r.ops)), ...typeOps];
+    // Build the entry with properties and relations separated
+    const entry = {
+      typeName: toPascalCase(deferred.schemaType.name),
+      typeIds: [id]
+    };
+    if (EffectArray.isNonEmptyArray(deferred.properties)) {
+      entry.properties = buildPropertyMap(deferred.properties);
+    }
+    if (EffectArray.isNonEmptyArray(allRelations)) {
+      entry.relations = buildRelationMap(allRelations);
+    }
+    return {
+      entries: [...acc.entries, entry],
+      ops: [...acc.ops, ...allOps]
+    };
+  }));
+  // Combine all entries and build final mapping
+  const allEntries = [...pipe(completeTypes, EffectArray.map(t => t.entry)), ...deferredEntries];
+  const mapping = pipe(allEntries, EffectArray.reduce({}, (mapping, entry) => {
+    const {
+      typeName,
+      ...rest
+    } = entry;
+    mapping[typeName] = rest;
+    return mapping;
+  }));
+  return [mapping, [...firstPassOps, ...secondPassOps]];
+}
+export class RelationValueTypeDoesNotExistError extends /*#__PURE__*/Data.TaggedError('/typesync/errors/RelationValueTypeDoesNotExistError') {}
+/**
+ * @since 0.2.0
+ *
+ * @param dataType the dataType from the user-submitted schema
+ * @returns the mapped to GRC-20 dataType for the GRC-20 ops
+ */
+export function mapSchemaDataTypeToGRC20PropDataType(dataType) {
+  switch (true) {
+    case dataType === 'Checkbox':
+      {
+        return 'CHECKBOX';
+      }
+    case dataType === 'Date':
+      {
+        return 'TIME';
+      }
+    case dataType === 'Number':
+      {
+        return 'NUMBER';
+      }
+    case dataType === 'Point':
+      {
+        return 'POINT';
+      }
+    case isDataTypeRelation(dataType):
+      {
+        return 'RELATION';
+      }
+    default:
+      {
+        return 'TEXT';
+      }
+  }
+}
+//# sourceMappingURL=Mapping.js.map

package/dist/mapping/Mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Mapping.js","names":["Graph","Id","Grc20Id","Data","Array","EffectArray","Schema","EffectSchema","Option","pipe","namesAreUnique","toCamelCase","toPascalCase","isDataTypeRelation","val","test","SchemaDataTypeRelation","NonEmptyTrimmedString","filter","SchemaDataTypePrimitive","Literal","SchemaDataType","Union","SchemaTypePropertyRelation","Struct","name","knowledgeGraphId","NullOr","UUID","dataType","relationType","annotations","identifier","description","examples","SchemaTypePropertyPrimitive","propertyIsRelation","property","SchemaType","properties","minItems","jsonSchema","types","allRelationPropertyTypesExist","title","SchemaKnownDecoder","decodeSync","SchemaUnknownDecoder","decodeUnknownSync","unqTypeNames","reduce","Set","names","curr","add","flatMap","prop","every","has","buildPropertyMap","props","propName","id","buildRelationMap","relations","rels","createPropertyWithOps","typeIdMap","type","mapping","ops","relationTypeId","get","createProperty","relationValueTypes","mapSchemaDataTypeToGRC20PropDataType","processType","processedProperties","map","resolvedProperties","filterMap","p","some","none","deferredProperties","primitiveProperties","originalProp","find","relationProperties","propertyOps","entry","typeName","typeIds","isNonEmptyArray","schemaType","allPropertyIds","typeOps","createType","set","generateMapping","input","schema","Map","processedTypes","deferredTypes","completeTypes","partition","result","firstPassOps","t","entries","deferredEntries","secondPassOps","acc","deferred","resolvedRelations","RelationValueTypeDoesNotExistError","message","relatedType","allRelations","r","allOps","allEntries","rest","TaggedError"],"sources":["../../src/mapping/Mapping.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/mapping/Utils.d.ts

@@ -0,0 +1,74 @@
+/**
+ * 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 declare function toCamelCase(str: string): string;
+/**
+ * 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 declare function toPascalCase(str: string): string;
+declare const InvalidInputError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "/typesync/errors/InvalidInputError";
+} & Readonly<A>;
+export declare class InvalidInputError extends InvalidInputError_base<{
+    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 declare function namesAreUnique<T extends {
+    readonly name: string;
+}>(entries: ReadonlyArray<T>): boolean;
+export {};
+//# sourceMappingURL=Utils.d.ts.map

package/dist/mapping/Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.d.ts","sourceRoot":"","sources":["../../src/mapping/Utils.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAsC/C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAmChD;;;;AAED,qBAAa,iBAAkB,SAAQ,uBAAuD;IAC5F,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG;AAEL;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,OAAO,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAYtG"}