@graphprotocol/hypergraph 0.2.0 → 0.4.0

package/src/cli/services/Utils.ts

@@ -0,0 +1,187 @@
+import { Data, Effect, Array as EffectArray } from 'effect';
+import ts from 'typescript';
+
+import * as Mapping from '../../mapping/Mapping.js';
+import * as Utils from '../../mapping/Utils.js';
+
+/**
+ * Takes a parsed schema.ts file and maps it to a the Mapping.Schema type.
+ *
+ * @internal
+ *
+ * @param sourceCode the read schema.ts file
+ * @param mapping the parsed mappint.ts file
+ * @returns the parsed Schema instance
+ */
+export const parseSchema = (
+  sourceCode: string,
+  mapping: Mapping.Mapping,
+): Effect.Effect<Mapping.Schema, SchemaParserFailure> =>
+  Effect.try({
+    try() {
+      const sourceFile = ts.createSourceFile('schema.ts', sourceCode, ts.ScriptTarget.Latest, true);
+
+      const entities: Array<Mapping.SchemaType> = [];
+
+      const visit = (node: ts.Node) => {
+        if (ts.isClassDeclaration(node) && node.name) {
+          const className = node.name.text;
+          const properties: Array<Mapping.SchemaTypePropertyPrimitive | Mapping.SchemaTypePropertyRelation> = [];
+
+          // Find the Entity.Class call
+          if (node.heritageClauses) {
+            for (const clause of node.heritageClauses) {
+              for (const type of clause.types) {
+                if (ts.isCallExpression(type.expression)) {
+                  const callExpr = type.expression;
+
+                  // Look for the object literal with properties
+                  if (callExpr.arguments.length > 0) {
+                    const arg = callExpr.arguments[0];
+                    if (ts.isObjectLiteralExpression(arg)) {
+                      for (const prop of arg.properties) {
+                        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                          const propName = prop.name.text;
+                          let dataType: Mapping.SchemaDataType = 'String';
+                          let relationType: string | undefined;
+
+                          const mappingEntry = mapping[className];
+                          const camelCasePropName = Utils.toCamelCase(propName);
+
+                          // Extract the type
+                          if (ts.isPropertyAccessExpression(prop.initializer)) {
+                            // Simple types like Type.Text
+                            dataType = Mapping.getDataType(prop.initializer.name.text);
+
+                            // Look up the property's knowledgeGraphId from the mapping
+                            const propKnowledgeGraphId = mappingEntry?.properties?.[camelCasePropName] || null;
+
+                            // push to type properties as primitive property
+                            properties.push({
+                              name: propName,
+                              dataType: dataType as Mapping.SchemaDataTypePrimitive,
+                              knowledgeGraphId: propKnowledgeGraphId,
+                            } satisfies Mapping.SchemaTypePropertyPrimitive);
+                          } else if (ts.isCallExpression(prop.initializer)) {
+                            // Relation types like Type.Relation(User)
+                            const callNode = prop.initializer;
+                            if (ts.isPropertyAccessExpression(callNode.expression)) {
+                              const typeName = callNode.expression.name.text;
+
+                              if (typeName === 'Relation' && callNode.arguments.length > 0) {
+                                const relationArg = callNode.arguments[0];
+                                if (ts.isIdentifier(relationArg)) {
+                                  relationType = relationArg.text;
+                                  dataType = `Relation(${relationType})`;
+
+                                  // Look up the relation property's knowledgeGraphId from the mapping
+                                  const relKnowledgeGraphId = mappingEntry?.relations?.[camelCasePropName] || null;
+
+                                  // push to type properties as relation property
+                                  properties.push({
+                                    name: propName,
+                                    dataType,
+                                    relationType,
+                                    knowledgeGraphId: relKnowledgeGraphId,
+                                  } satisfies Mapping.SchemaTypePropertyRelation);
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          // Look up the type's knowledgeGraphId from the mapping
+          const mappingEntry = mapping[Utils.toPascalCase(className)];
+          const typeKnowledgeGraphId = mappingEntry?.typeIds?.[0] ? mappingEntry.typeIds[0] : null;
+
+          entities.push({ name: className, knowledgeGraphId: typeKnowledgeGraphId, properties });
+        }
+
+        ts.forEachChild(node, visit);
+      };
+
+      visit(sourceFile);
+
+      return {
+        types: entities,
+      } as const;
+    },
+    catch(error) {
+      return new SchemaParserFailure({
+        message: `Failed to parse schema: ${error}`,
+        cause: error,
+      });
+    },
+  });
+
+export class SchemaParserFailure extends Data.TaggedError('/Hypergraph/cli/errors/SchemaParserFailure')<{
+  readonly message: string;
+  readonly cause: unknown;
+}> {}
+
+/**
+ * @internal
+ *
+ * Runtime check to see if a value looks like a Mapping
+ */
+function isMappingLike(value: unknown): value is Mapping.Mapping {
+  if (!value || typeof value !== 'object') return false;
+  return Object.values(value).every(
+    (entry) =>
+      entry &&
+      typeof entry === 'object' &&
+      'typeIds' in entry &&
+      // biome-ignore lint/suspicious/noExplicitAny: parsing so type unknown
+      EffectArray.isArray((entry as any).typeIds),
+  );
+}
+
+/**
+ * @internal
+ *
+ * Look at the exported object from the mapping.ts file loaded via jiti and try to pull out the hypergraph mapping.
+ * Default should be:
+ * ```typescript
+ * export const mapping: Mapping
+ * ```
+ * But this is not guaranteed. This function looks through the file to try to find it using some logical defaults/checks.
+ *
+ * @param moduleExport the object imported from jiti from the mapping.ts file
+ */
+// biome-ignore lint/suspicious/noExplicitAny: type should be import object from jiti
+export function parseHypergraphMapping(moduleExport: any): Mapping.Mapping {
+  // Handle null/undefined inputs
+  if (!moduleExport || typeof moduleExport !== 'object') {
+    return {} as Mapping.Mapping;
+  }
+
+  // Find all exports that look like Mapping objects
+  const mappingCandidates = Object.entries(moduleExport).filter(([, value]) => isMappingLike(value));
+
+  if (mappingCandidates.length === 0) {
+    return {} as Mapping.Mapping;
+  }
+
+  if (mappingCandidates.length === 1) {
+    return mappingCandidates[0][1] as Mapping.Mapping;
+  }
+
+  // Multiple candidates - prefer common names
+  const preferredNames = ['mapping', 'default', 'config'];
+  for (const preferredName of preferredNames) {
+    const found = mappingCandidates.find(([name]) => name === preferredName);
+    if (found) {
+      return found[1] as Mapping.Mapping;
+    }
+  }
+
+  // If no preferred names found, use the first one
+  return mappingCandidates[0][1] as Mapping.Mapping;
+}

package/src/cli/subcommands/typesync.ts

@@ -0,0 +1,93 @@
+import { createServer } from 'node:http';
+import { Command, Options } from '@effect/cli';
+import {
+  HttpApi,
+  HttpApiBuilder,
+  HttpApiEndpoint,
+  HttpApiError,
+  HttpApiGroup,
+  HttpApiSchema,
+  HttpMiddleware,
+  HttpServer,
+  HttpServerResponse,
+} from '@effect/platform';
+import { NodeHttpServer } from '@effect/platform-node';
+import { AnsiDoc } from '@effect/printer-ansi';
+import { Effect, Layer, Schema } from 'effect';
+import * as Typesync from '../services/Typesync.js';
+
+const hypergraphTypeSyncApi = HttpApi.make('HypergraphTypeSyncApi')
+  .add(
+    HttpApiGroup.make('SchemaStreamGroup')
+      .add(
+        // exposes an api endpoint at /api/vX/schema/events that is a stream of the current Schema parsed from the directory the hypergraph-cli tool is running in
+        HttpApiEndpoint.get('HypergraphSchemaEventStream')`/schema/events`
+          .addError(HttpApiError.InternalServerError)
+          .addSuccess(
+            Schema.String.pipe(
+              HttpApiSchema.withEncoding({
+                kind: 'Json',
+                contentType: 'text/event-stream',
+              }),
+            ),
+          ),
+      )
+      .prefix('/v1'),
+  )
+  .prefix('/api');
+
+const hypergraphTypeSyncApiLive = HttpApiBuilder.group(hypergraphTypeSyncApi, 'SchemaStreamGroup', (handlers) =>
+  handlers.handle('HypergraphSchemaEventStream', () =>
+    Effect.gen(function* () {
+      const schemaStream = yield* Typesync.TypesyncSchemaStreamBuilder;
+
+      const stream = yield* schemaStream
+        .hypergraphSchemaStream()
+        .pipe(Effect.catchAll(() => new HttpApiError.InternalServerError()));
+
+      return yield* HttpServerResponse.stream(stream, { contentType: 'text/event-stream' }).pipe(
+        HttpServerResponse.setHeaders({
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          Connection: 'keep-alive',
+        }),
+      );
+    }),
+  ),
+);
+
+const HypergraphTypeSyncApiLive = HttpApiBuilder.api(hypergraphTypeSyncApi).pipe(
+  Layer.provide(hypergraphTypeSyncApiLive),
+  Layer.provide(Typesync.layer),
+);
+
+const HypergraphTypeSyncApiLayer = HttpApiBuilder.serve(HttpMiddleware.logger).pipe(
+  Layer.provide(HttpApiBuilder.middlewareCors()),
+  Layer.provide(HypergraphTypeSyncApiLive),
+);
+
+export const typesync = Command.make('typesync', {
+  args: {
+    port: Options.integer('port').pipe(
+      Options.withAlias('p'),
+      Options.withDefault(3000),
+      Options.withDescription('The port to run the Hypergraph TypeSync studio server on. Default 3000'),
+    ),
+  },
+}).pipe(
+  Command.withDescription(
+    'Opens the TypeSync studio to help users build and publish their Hypergraph application schema',
+  ),
+  Command.withHandler(({ args }) =>
+    Effect.gen(function* () {
+      yield* HypergraphTypeSyncApiLayer.pipe(
+        HttpServer.withLogAddress,
+        Layer.provide(NodeHttpServer.layer(createServer, { port: args.port })),
+        Layer.tap(() =>
+          Effect.logInfo(AnsiDoc.text(`🎉 TypeSync studio started and running at http://localhost:${args.port}`)),
+        ),
+        Layer.launch,
+      );
+    }),
+  ),
+);

package/src/entity/findMany.ts

@@ -15,7 +15,7 @@ import type {
   EntityFieldFilter,
   EntityFilter,
   EntityNumberFilter,
-  EntityTextFilter,
+  EntityStringFilter,
 } from './types.js';
 
 const documentChangeListener: {
@@ -298,19 +298,19 @@ export function findMany<const S extends AnyNoContext>(
 
     if (typeof fieldValue === 'string') {
       if ('startsWith' in fieldFilter) {
-        const textFilter = fieldFilter as EntityTextFilter;
+        const textFilter = fieldFilter as EntityStringFilter;
         if (textFilter.startsWith !== undefined && !fieldValue.startsWith(textFilter.startsWith)) {
           return false;
         }
       }
       if ('endsWith' in fieldFilter) {
-        const textFilter = fieldFilter as EntityTextFilter;
+        const textFilter = fieldFilter as EntityStringFilter;
         if (textFilter.endsWith !== undefined && !fieldValue.endsWith(textFilter.endsWith)) {
           return false;
         }
       }
       if ('contains' in fieldFilter) {
-        const textFilter = fieldFilter as EntityTextFilter;
+        const textFilter = fieldFilter as EntityStringFilter;
         if (textFilter.contains !== undefined && !fieldValue.includes(textFilter.contains)) {
           return false;
         }

package/src/entity/types.ts

@@ -47,7 +47,7 @@ export type DocumentContent = {
   relations?: Record<string, DocumentRelation>;
 };
 
-export type EntityCheckboxFilter = {
+export type EntityBooleanFilter = {
   is: boolean;
 };
 
@@ -59,14 +59,14 @@ export type EntityNumberFilter = {
   or?: EntityNumberFilter[];
 };
 
-export type EntityTextFilter = {
+export type EntityStringFilter = {
   is?: string;
   startsWith?: string;
   endsWith?: string;
   contains?: string;
   equals?: string;
-  not?: EntityTextFilter;
-  or?: EntityTextFilter[];
+  not?: EntityStringFilter;
+  or?: EntityStringFilter[];
 };
 
 export type CrossFieldFilter<T> = {

package/src/index.ts

@@ -1,3 +1,4 @@
+export { Id } from '@graphprotocol/grc-20';
 export * as Connect from './connect/index.js';
 export * as Entity from './entity/index.js';
 export * as Identity from './identity/index.js';
@@ -10,5 +11,6 @@ export * as SpaceInfo from './space-info/index.js';
 export * from './store.js';
 export * as StoreConnect from './store-connect.js';
 export * as Type from './type/type.js';
+export * as TypeUtils from './type-utils/type-utils.js';
 export * from './types.js';
 export * as Utils from './utils/index.js';

package/src/mapping/Mapping.ts

@@ -10,30 +10,30 @@ import { namesAreUnique, toCamelCase, toPascalCase } from './Utils.js';
  */
 export type MappingEntry = {
   /**
-   * Array of the `Id.Id` of the type in the Knowledge Graph.
+   * Array of the `Id` of the type in the Knowledge Graph.
    * Is an array because a type can belong to multiple spaces/extend multiple types.
    *
    * @since 0.2.0
    */
-  typeIds: Array<Grc20Id.Id>;
+  typeIds: Array<Grc20Id>;
   /**
-   * Record of property names to the `Id.Id` of the type in the Knowledge Graph
+   * Record of property names to the `Id` of the type in the Knowledge Graph
    *
    * @since 0.2.0
    */
   properties?:
     | {
-        [key: string]: Grc20Id.Id;
+        [key: string]: Grc20Id;
       }
     | undefined;
   /**
-   * Record of relation properties to the `Id.Id` of the type in the Knowledge Graph
+   * Record of relation properties to the `Id` of the type in the Knowledge Graph
    *
    * @since 0.2.0
    */
   relations?:
     | {
-        [key: string]: Grc20Id.Id;
+        [key: string]: Grc20Id;
       }
     | undefined;
 };
@@ -46,20 +46,20 @@ export type MappingEntry = {
  *
  * const mapping: Mapping = {
  *   Account: {
- *     typeIds: [Id.Id('a5fd07b1-120f-46c6-b46f-387ef98396a6')],
+ *     typeIds: [Id('a5fd07b1-120f-46c6-b46f-387ef98396a6')],
  *     properties: {
- *       username: Id.Id('994edcff-6996-4a77-9797-a13e5e3efad8'),
- *       createdAt: Id.Id('64bfba51-a69b-4746-be4b-213214a879fe')
+ *       username: Id('994edcff-6996-4a77-9797-a13e5e3efad8'),
+ *       createdAt: Id('64bfba51-a69b-4746-be4b-213214a879fe')
  *     }
  *   },
  *   Event: {
- *     typeIds: [Id.Id('0349187b-526f-435f-b2bb-9e9caf23127a')],
+ *     typeIds: [Id('0349187b-526f-435f-b2bb-9e9caf23127a')],
  *     properties: {
- *       name: Id.Id('3808e060-fb4a-4d08-8069-35b8c8a1902b'),
- *       description: Id.Id('1f0d9007-8da2-4b28-ab9f-3bc0709f4837'),
+ *       name: Id('3808e060-fb4a-4d08-8069-35b8c8a1902b'),
+ *       description: Id('1f0d9007-8da2-4b28-ab9f-3bc0709f4837'),
  *     },
  *     relations: {
- *       speaker: Id.Id('a5fd07b1-120f-46c6-b46f-387ef98396a6')
+ *       speaker: Id('a5fd07b1-120f-46c6-b46f-387ef98396a6')
  *     }
  *   }
  * }
@@ -94,11 +94,17 @@ export type SchemaDataTypeRelation = typeof SchemaDataTypeRelation.Type;
 /**
  * @since 0.2.0
  */
-export const SchemaDataTypePrimitive = EffectSchema.Literal('Text', 'Number', 'Checkbox', 'Date', 'Point');
+export const SchemaDataTypePrimitive = EffectSchema.Literal('String', 'Number', 'Boolean', 'Date', 'Point');
 /**
  * @since 0.2.0
  */
 export type SchemaDataTypePrimitive = typeof SchemaDataTypePrimitive.Type;
+/**
+ * @since 0.4.0
+ */
+export function isDataTypePrimitive(val: string): val is SchemaDataTypePrimitive {
+  return ['String', 'Number', 'Boolean', 'Date', 'Point'].includes(val);
+}
 /**
  * @since 0.2.0
  */
@@ -107,6 +113,22 @@ export const SchemaDataType = EffectSchema.Union(SchemaDataTypePrimitive, Schema
  * @since 0.2.0
  */
 export type SchemaDataType = typeof SchemaDataType.Type;
+/**
+ * @since 0.4.0
+ */
+export function isDataType(val: string): val is SchemaDataType {
+  return isDataTypePrimitive(val) || isDataTypeRelation(val);
+}
+/**
+ * @since 0.4.0
+ */
+export function getDataType(val: string): SchemaDataType {
+  const dataType = isDataTypePrimitive(val) || isDataTypeRelation(val);
+  if (dataType) {
+    return val;
+  }
+  throw new Error(`Passed dataType ${val} is not supported`);
+}
 /**
  * @since 0.2.0
  */
@@ -195,7 +217,7 @@ export const Schema = EffectSchema.Struct({
         {
           name: 'Account',
           knowledgeGraphId: null,
-          properties: [{ name: 'username', knowledgeGraphId: null, dataType: 'Text' }],
+          properties: [{ name: 'username', knowledgeGraphId: null, dataType: 'String' }],
         },
       ],
     },
@@ -204,7 +226,7 @@ export const Schema = EffectSchema.Struct({
         {
           name: 'Account',
           knowledgeGraphId: 'a5fd07b1-120f-46c6-b46f-387ef98396a6',
-          properties: [{ name: 'name', knowledgeGraphId: 'a126ca53-0c8e-48d5-b888-82c734c38935', dataType: 'Text' }],
+          properties: [{ name: 'name', knowledgeGraphId: 'a126ca53-0c8e-48d5-b888-82c734c38935', dataType: 'String' }],
         },
       ],
     },
@@ -238,7 +260,7 @@ export const SchemaUnknownDecoder = EffectSchema.decodeUnknownSync(Schema);
  *     properties: [
  *       {
  *         name: "username",
- *         dataType: "Text",
+ *         dataType: "String",
  *         knowledgeGraphId: null
  *       }
  *     ]
@@ -297,8 +319,8 @@ export function allRelationPropertyTypesExist(types: ReadonlyArray<SchemaType>):
 export type GenerateMappingResult = [mapping: Mapping, ops: ReadonlyArray<Op>];
 
 // Helper types for internal processing
-type PropertyIdMapping = { propName: string; id: Grc20Id.Id };
-type TypeIdMapping = Map<string, Grc20Id.Id | null>;
+type PropertyIdMapping = { propName: string; id: Grc20Id };
+type TypeIdMapping = Map<string, Grc20Id | null>;
 type ProcessedProperty =
   | { type: 'resolved'; mapping: PropertyIdMapping; ops: Array<Op> }
   | { type: 'deferred'; property: SchemaTypePropertyRelation };
@@ -342,7 +364,7 @@ function createPropertyWithOps(
   if (property.knowledgeGraphId) {
     return {
       type: 'resolved',
-      mapping: { propName: property.name, id: Grc20Id.Id(property.knowledgeGraphId) },
+      mapping: { propName: property.name, id: Grc20Id(property.knowledgeGraphId) },
       ops: [],
     };
   }
@@ -421,7 +443,7 @@ function processType(type: SchemaType, typeIdMap: TypeIdMapping): ProcessedType
   if (type.knowledgeGraphId) {
     const entry: MappingEntry & { typeName: string } = {
       typeName: toPascalCase(type.name),
-      typeIds: [Grc20Id.Id(type.knowledgeGraphId)],
+      typeIds: [Grc20Id(type.knowledgeGraphId)],
     };
 
     if (EffectArray.isNonEmptyArray(primitiveProperties)) {
@@ -487,7 +509,7 @@ function processType(type: SchemaType, typeIdMap: TypeIdMapping): ProcessedType
  * @example
  * ```ts
  * import { Id } from "@graphprotocol/grc-20"
- * import { generateMapping } from "@graphprotocol/typesync"
+ * import { generateMapping } from "@graphprotocol/hypergraph"
  *
  * const schema: Schema = {
  *   types: [
@@ -497,7 +519,7 @@ function processType(type: SchemaType, typeIdMap: TypeIdMapping): ProcessedType
  *       properties: [
  *         {
  *           name: "username",
- *           dataType: "Text",
+ *           dataType: "String",
  *           knowledgeGraphId: "994edcff-6996-4a77-9797-a13e5e3efad8"
  *         },
  *         {
@@ -513,12 +535,12 @@ function processType(type: SchemaType, typeIdMap: TypeIdMapping): ProcessedType
  *       properties: [
  *         {
  *           name: "name",
- *           dataType: "Text",
+ *           dataType: "String",
  *           knowledgeGraphId: "3808e060-fb4a-4d08-8069-35b8c8a1902b"
  *         },
  *         {
  *           name: "description",
- *           dataType: "Text",
+ *           dataType: "String",
  *           knowledgeGraphId: null
  *         },
  *         {
@@ -535,20 +557,20 @@ function processType(type: SchemaType, typeIdMap: TypeIdMapping): ProcessedType
  *
  * expect(mapping).toEqual({
  *   Account: {
- *     typeIds: [Id.Id("a5fd07b1-120f-46c6-b46f-387ef98396a6")], // comes from input schema
+ *     typeIds: [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
+ *       username: Id("994edcff-6996-4a77-9797-a13e5e3efad8"), // comes from input schema
+ *       createdAt: 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
+ *     typeIds: [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
+ *       name: Id("3808e060-fb4a-4d08-8069-35b8c8a1902b"), // comes from input schema
+ *       description: 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
+ *       speaker: Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"), // generated from Graph.createProperty Op
  *     }
  *   }
  * })
@@ -557,23 +579,23 @@ function processType(type: SchemaType, typeIdMap: TypeIdMapping): ProcessedType
  *   {
  *     type: "CREATE_PROPERTY",
  *     property: {
- *       id: Id.Id("8cd7d9ac-a878-4287-8000-e71e6f853117"),
- *       dataType: "TEXT"
+ *       id: Id("8cd7d9ac-a878-4287-8000-e71e6f853117"),
+ *       dataType: "String"
  *     }
  *   },
  *   // Graph.createProperty Op for Event.description property
  *   {
  *     type: "CREATE_PROPERTY",
  *     property: {
- *       id: Id.Id("8fc4e17c-7581-4d6c-a712-943385afc7b5"),
- *       dataType: "TEXT"
+ *       id: Id("8fc4e17c-7581-4d6c-a712-943385afc7b5"),
+ *       dataType: "String"
  *     }
  *   },
  *   // Graph.createProperty Op for Event.speaker property
  *   {
  *     type: "CREATE_PROPERTY",
  *     property: {
- *       id: Id.Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"),
+ *       id: Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"),
  *       dataType: "RELATION"
  *     }
  *   },
@@ -581,7 +603,7 @@ function processType(type: SchemaType, typeIdMap: TypeIdMapping): ProcessedType
  *   {
  *     type: "CREATE_PROPERTY",
  *     property: {
- *       id: Id.Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"),
+ *       id: Id("651ce59f-643b-4931-bf7a-5dc0ca0f5a47"),
  *       dataType: "RELATION"
  *     }
  *   },
@@ -600,8 +622,8 @@ export function generateMapping(input: Schema): GenerateMappingResult {
   // Build initial type ID map
   const typeIdMap: TypeIdMapping = pipe(
     schema.types,
-    EffectArray.reduce(new Map<string, Grc20Id.Id | null>(), (map, type) =>
-      map.set(type.name, type.knowledgeGraphId != null ? Grc20Id.Id(type.knowledgeGraphId) : null),
+    EffectArray.reduce(new Map<string, Grc20Id | null>(), (map, type) =>
+      map.set(type.name, type.knowledgeGraphId != null ? Grc20Id(type.knowledgeGraphId) : null),
     ),
   );
 
@@ -749,8 +771,8 @@ export class RelationValueTypeDoesNotExistError extends Data.TaggedError(
  */
 export function mapSchemaDataTypeToGRC20PropDataType(dataType: SchemaDataType): CreatePropertyParams['dataType'] {
   switch (true) {
-    case dataType === 'Checkbox': {
-      return 'CHECKBOX';
+    case dataType === 'Boolean': {
+      return 'BOOLEAN';
     }
     case dataType === 'Date': {
       return 'TIME';
@@ -765,7 +787,7 @@ export function mapSchemaDataTypeToGRC20PropDataType(dataType: SchemaDataType):
       return 'RELATION';
     }
     default: {
-      return 'TEXT';
+      return 'STRING';
     }
   }
 }

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>>>,