Merge pull request #34 from eijawerner/update-property-type

only allow list one level deep of property type

Author: eijawerner

.changeset/fluffy-spoons-camp.md

@@ -0,0 +1,6 @@
+---
+"@neo4j/graph-schema-utils": patch
+"@neo4j/graph-introspection": patch
+---
+
+removed recursive property type

packages/graph-schema-utils/src/formatters/json/extensions.ts

@@ -6,9 +6,9 @@ import {
   NodeLabelIndex,
   NodeObjectType,
   Property,
-  PropertyArrayType,
-  PropertyBaseType,
-  PropertyTypeRecursive,
+  PrimitiveArrayPropertyType,
+  PrimitivePropertyType,
+  PropertyType,
   RelationshipObjectType,
   RelationshipType,
   RelationshipTypeConstraint,
@@ -18,19 +18,23 @@ import {
   isNodeLabelIndex,
   isRelationshipTypeConstraint,
   isRelationshipTypeIndex,
+  isPrimitivePropertyType,
+  isPrimitiveArrayPropertyType,
 } from "../../model/index.js";
 import {
   ConstraintJsonStruct,
   IndexJsonStruct,
+  isPrimitiveArrayPropertyTypeJsonStruct,
+  isPrimitivePropertyTypeJsonStruct,
   LookupIndexJsonStruct,
   NodeLabelConstraintJsonStruct,
   NodeLabelIndexJsonStruct,
   NodeLabelJsonStruct,
   NodeObjectTypeJsonStruct,
-  PrimitivePropertyTypesArrayType,
-  PrimitivePropertyTypesType,
+  PrimitiveArrayPropertyTypeJsonStruct,
+  PrimitivePropertyTypeJsonStruct,
   PropertyJsonStruct,
-  PropertyTypeJsonStructRecrsive,
+  PropertyTypeJsonStruct,
   RelationshipObjectTypeJsonStruct,
   RelationshipTypeConstraintJsonStruct,
   RelationshipTypeIndexJsonStruct,
@@ -470,24 +474,40 @@ const property = {
 };
 
 const propertyType = {
-  extract: (pt: PropertyTypeRecursive): PropertyTypeJsonStructRecrsive => {
+  extract: (
+    pt: PropertyType | PropertyType[]
+  ): PropertyTypeJsonStruct | PropertyTypeJsonStruct[] => {
     if (Array.isArray(pt)) {
-      return pt.map(propertyType.extract);
+      return pt.map((p) => {
+        if (isPrimitivePropertyType(p)) {
+          return propertyBaseType.extract(p);
+        } else if (isPrimitiveArrayPropertyType(p)) {
+          return propertyArrayType.extract(p);
+        }
+        throw Error(`Unknown property type in list ${p}`);
+      });
     }
-    if (pt instanceof PropertyBaseType) {
+    if (isPrimitivePropertyType(pt)) {
       return propertyBaseType.extract(pt);
-    } else if (pt instanceof PropertyArrayType) {
+    } else if (isPrimitiveArrayPropertyType(pt)) {
       return propertyArrayType.extract(pt);
     }
     throw new Error(`Unknown property type ${pt}`);
   },
   create: (
-    propertyTypeJson: PropertyTypeJsonStructRecrsive
-  ): PropertyTypeRecursive => {
+    propertyTypeJson: PropertyTypeJsonStruct | PropertyTypeJsonStruct[]
+  ): PropertyType | PropertyType[] => {
     if (Array.isArray(propertyTypeJson)) {
-      return propertyTypeJson.map((pt) => propertyType.create(pt));
+      return propertyTypeJson.map((pt) => {
+        if (isPrimitivePropertyTypeJsonStruct(pt)) {
+          return propertyBaseType.create(pt);
+        } else if (isPrimitiveArrayPropertyTypeJsonStruct(pt)) {
+          return propertyArrayType.create(pt.items.type);
+        }
+        throw new Error(`Unknown property type in list ${pt}`);
+      });
     }
-    if (propertyTypeJson.type === "array") {
+    if (isPrimitiveArrayPropertyTypeJsonStruct(propertyTypeJson)) {
       return propertyArrayType.create(propertyTypeJson.items.type);
     }
     return propertyBaseType.create(propertyTypeJson);
@@ -496,23 +516,23 @@ const propertyType = {
 
 const propertyBaseType = {
   extract: (
-    propertyBaseType: PropertyBaseType
-  ): PrimitivePropertyTypesType => ({
+    propertyBaseType: PrimitivePropertyType
+  ): PrimitivePropertyTypeJsonStruct => ({
     type: propertyBaseType.type,
   }),
-  create: (btype: PrimitivePropertyTypesType) =>
-    new PropertyBaseType(btype.type),
+  create: (btype: PrimitivePropertyTypeJsonStruct) =>
+    new PrimitivePropertyType(btype.type),
 };
 
 const propertyArrayType = {
   extract: (
-    propertyArrayType: PropertyArrayType
-  ): PrimitivePropertyTypesArrayType => ({
+    propertyArrayType: PrimitiveArrayPropertyType
+  ): PrimitiveArrayPropertyTypeJsonStruct => ({
     type: "array",
     items: propertyBaseType.extract(propertyArrayType.items),
   }),
-  create: (type: PrimitivePropertyTypesArrayType["items"]["type"]) =>
-    new PropertyArrayType(propertyBaseType.create({ type })),
+  create: (type: PrimitiveArrayPropertyTypeJsonStruct["items"]["type"]) =>
+    new PrimitiveArrayPropertyType(propertyBaseType.create({ type })),
 };
 
 const nodeObjectType = {

packages/graph-schema-utils/src/formatters/json/parse.test.ts

@@ -3,7 +3,10 @@ import path from "path";
 import { readFile } from "../../../test/fs.utils.js";
 import { describe, test } from "vitest";
 import { fromJson } from "./index.js";
-import { PropertyTypes } from "../../model/index.js";
+import {
+  PrimitiveArrayPropertyType,
+  PrimitivePropertyType,
+} from "../../model/index.js";
 
 import { validateSchema } from "../../validation.js";
 
@@ -66,7 +69,11 @@ describe("Parser tests", () => {
       "roles"
     );
     assert.strictEqual(
-      (parsed.relationshipTypes[0].properties[0].type as PropertyTypes).type,
+      (
+        parsed.relationshipTypes[0].properties[0].type as
+          | PrimitivePropertyType
+          | PrimitiveArrayPropertyType
+      ).type,
       "array"
     );
   });

packages/graph-schema-utils/src/formatters/json/types.ts

@@ -2,6 +2,7 @@ import {
   ConstraintType,
   EntityType,
   IndexType,
+  PRIMITIVE_TYPE_OPTIONS,
   PrimitivePropertyTypes,
 } from "../../model/index.js";
 
@@ -105,21 +106,37 @@ export type LookupIndexJsonStruct = IndexJsonStruct & {
 export type PropertyJsonStruct = {
   $id: string;
   token: string;
-  type: PropertyTypeJsonStructRecrsive;
+  type: PropertyTypeJsonStruct | PropertyTypeJsonStruct[];
   nullable: boolean;
 };
 
-export type PrimitivePropertyTypesType = { type: PrimitivePropertyTypes };
-export type PrimitivePropertyTypesArrayType = {
+export type PrimitivePropertyTypeJsonStruct = { type: PrimitivePropertyTypes };
+export type PrimitiveArrayPropertyTypeJsonStruct = {
   type: "array";
   items: { type: PrimitivePropertyTypes };
 };
 
 export type PropertyTypeJsonStruct =
-  | PrimitivePropertyTypesArrayType
-  | PrimitivePropertyTypesType
-  | (PrimitivePropertyTypesType | PrimitivePropertyTypesArrayType)[];
-
-export type PropertyTypeJsonStructRecrsive =
-  | PropertyTypeJsonStruct
-  | Array<PropertyTypeJsonStruct | PropertyTypeJsonStructRecrsive[]>;
+  | PrimitiveArrayPropertyTypeJsonStruct
+  | PrimitivePropertyTypeJsonStruct;
+
+export const isPrimitivePropertyTypeJsonStruct = (
+  propertyType: PropertyTypeJsonStruct
+): propertyType is PrimitivePropertyTypeJsonStruct => {
+  return (
+    typeof propertyType === "object" &&
+    "type" in propertyType &&
+    PRIMITIVE_TYPE_OPTIONS.some((p) => propertyType.type === p)
+  );
+};
+
+export const isPrimitiveArrayPropertyTypeJsonStruct = (
+  propertyType: PropertyTypeJsonStruct
+): propertyType is PrimitiveArrayPropertyTypeJsonStruct => {
+  return (
+    typeof propertyType === "object" &&
+    "type" in propertyType &&
+    propertyType.type === "array" &&
+    propertyType.items !== undefined
+  );
+};

packages/graph-schema-utils/src/formatters/llm-prompt/index.ts

@@ -1,9 +1,8 @@
 import {
   GraphSchema,
   NodeObjectType,
-  PropertyBaseType,
-  PropertyTypeRecursive,
-  PropertyTypes,
+  PrimitivePropertyType,
+  PropertyType,
   RelationshipObjectType,
 } from "../../model/index.js";
 import { ElementPropertyObject } from "./types.js";
@@ -141,11 +140,11 @@ export function toOskars(schema: GraphSchema): string {
   return out.join("\n");
 }
 
-function formatPropertyType(type: PropertyTypeRecursive): string {
+function formatPropertyType(type: PropertyType | PropertyType[]): string {
   if (Array.isArray(type)) {
     return type.map(formatPropertyType).join("|");
   }
-  if (type instanceof PropertyBaseType) {
+  if (type instanceof PrimitivePropertyType) {
     return type.type;
   }
   return `${type.items.type}[]`;

packages/graph-schema-utils/src/model/index.ts

@@ -295,20 +295,38 @@ export type IndexType =
 
 export type EntityType = "node" | "relationship";
 
-export type PropertyTypes = PropertyBaseType | PropertyArrayType;
-export type PropertyTypeRecursive =
-  | PropertyTypes
-  | Array<PropertyTypes | PropertyTypeRecursive[]>;
+export type PropertyType = PrimitivePropertyType | PrimitiveArrayPropertyType;
+
+export const isPrimitiveArrayPropertyType = (
+  property: PropertyType
+): property is PrimitiveArrayPropertyType => {
+  return (
+    property instanceof Object &&
+    property.type === "array" &&
+    property.items !== undefined
+  );
+};
+
+export const isPrimitivePropertyType = (
+  property: PropertyType
+): property is PrimitivePropertyType => {
+  return (
+    property instanceof Object &&
+    "type" in property &&
+    PRIMITIVE_TYPE_OPTIONS.some((p) => property.type === p)
+  );
+};
+
 export class Property {
   $id: string;
   token: string;
-  type: PropertyTypeRecursive;
+  type: PropertyType | PropertyType[];
   nullable: boolean;
 
   constructor(
     $id: string,
     token: string,
-    type: PropertyTypeRecursive,
+    type: PropertyType | PropertyType[],
     nullable: boolean
   ) {
     this.$id = $id;
@@ -318,32 +336,35 @@ export class Property {
   }
 }
 
-export class PropertyBaseType {
+export class PrimitivePropertyType {
   type: PrimitivePropertyTypes;
   constructor(type: PrimitivePropertyTypes) {
     this.type = type;
   }
 }
 
-export class PropertyArrayType {
-  items: PropertyBaseType;
+export class PrimitiveArrayPropertyType {
+  items: PrimitivePropertyType;
   type: "array";
 
-  constructor(items: PropertyBaseType) {
+  constructor(items: PrimitivePropertyType) {
     this.type = "array";
     this.items = items;
   }
 }
 
-export type PrimitivePropertyTypes =
-  | "integer"
-  | "string"
-  | "float"
-  | "boolean"
-  | "point"
-  | "date"
-  | "datetime"
-  | "time"
-  | "localtime"
-  | "localdatetime"
-  | "duration";
+export const PRIMITIVE_TYPE_OPTIONS = [
+  "integer",
+  "string",
+  "float",
+  "boolean",
+  "point",
+  "date",
+  "datetime",
+  "time",
+  "localtime",
+  "localdatetime",
+  "duration",
+] as const;
+
+export type PrimitivePropertyTypes = (typeof PRIMITIVE_TYPE_OPTIONS)[number];