only allow list one level deep of property type

it is not possible to define property on a node label/ relationship type as a list of list,
only simple types and a homogeneous array of the same simple types are allowed.

https://neo4j.com/docs/cypher-manual/current/values-and-types/property-structural-constructed/

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

@@ -8,7 +8,7 @@ import {
   Property,
   PropertyArrayType,
   PropertyBaseType,
-  PropertyTypeRecursive,
+  PropertyType,
   RelationshipObjectType,
   RelationshipType,
   RelationshipTypeConstraint,
@@ -18,10 +18,16 @@ import {
   isNodeLabelIndex,
   isRelationshipTypeConstraint,
   isRelationshipTypeIndex,
+  isPropertyTypeList,
+  isPropertyBaseType,
+  isPropertyArrayType,
 } from "../../model/index.js";
 import {
   ConstraintJsonStruct,
   IndexJsonStruct,
+  isPrimitivePropertyTypesArrayTypeJsonStruct,
+  isPrimitivePropertyTypesTypeJsonStruct,
+  isPropertyTypeListJsonStruct,
   LookupIndexJsonStruct,
   NodeLabelConstraintJsonStruct,
   NodeLabelIndexJsonStruct,
@@ -30,7 +36,7 @@ import {
   PrimitivePropertyTypesArrayType,
   PrimitivePropertyTypesType,
   PropertyJsonStruct,
-  PropertyTypeJsonStructRecrsive,
+  PropertyTypeJsonStruct,
   RelationshipObjectTypeJsonStruct,
   RelationshipTypeConstraintJsonStruct,
   RelationshipTypeIndexJsonStruct,
@@ -470,24 +476,36 @@ const property = {
 };
 
 const propertyType = {
-  extract: (pt: PropertyTypeRecursive): PropertyTypeJsonStructRecrsive => {
-    if (Array.isArray(pt)) {
-      return pt.map(propertyType.extract);
+  extract: (pt: PropertyType): PropertyTypeJsonStruct => {
+    if (isPropertyTypeList(pt)) {
+      return pt.map((p) => {
+        if (isPropertyBaseType(p)) {
+          return propertyBaseType.extract(p);
+        } else if (isPropertyArrayType(p)) {
+          return propertyArrayType.extract(p);
+        }
+        throw Error(`Unknown property type in list ${p}`);
+      });
     }
-    if (pt instanceof PropertyBaseType) {
+    if (isPropertyBaseType(pt)) {
       return propertyBaseType.extract(pt);
-    } else if (pt instanceof PropertyArrayType) {
+    } else if (isPropertyArrayType(pt)) {
       return propertyArrayType.extract(pt);
     }
     throw new Error(`Unknown property type ${pt}`);
   },
-  create: (
-    propertyTypeJson: PropertyTypeJsonStructRecrsive
-  ): PropertyTypeRecursive => {
-    if (Array.isArray(propertyTypeJson)) {
-      return propertyTypeJson.map((pt) => propertyType.create(pt));
+  create: (propertyTypeJson: PropertyTypeJsonStruct): PropertyType => {
+    if (isPropertyTypeListJsonStruct(propertyTypeJson)) {
+      return propertyTypeJson.map((pt) => {
+        if (isPrimitivePropertyTypesTypeJsonStruct(pt)) {
+          return propertyBaseType.create(pt);
+        } else if (isPrimitivePropertyTypesArrayTypeJsonStruct(pt)) {
+          return propertyArrayType.create(pt.items.type);
+        }
+        throw new Error(`Unknown property type in list ${pt}`);
+      });
     }
-    if (propertyTypeJson.type === "array") {
+    if (isPrimitivePropertyTypesArrayTypeJsonStruct(propertyTypeJson)) {
       return propertyArrayType.create(propertyTypeJson.items.type);
     }
     return propertyBaseType.create(propertyTypeJson);

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

@@ -3,7 +3,7 @@ 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 { PropertyArrayType, PropertyBaseType } from "../../model/index.js";
 
 import { validateSchema } from "../../validation.js";
 
@@ -66,7 +66,11 @@ describe("Parser tests", () => {
       "roles"
     );
     assert.strictEqual(
-      (parsed.relationshipTypes[0].properties[0].type as PropertyTypes).type,
+      (
+        parsed.relationshipTypes[0].properties[0].type as
+          | PropertyBaseType
+          | PropertyArrayType
+      ).type,
       "array"
     );
   });

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

@@ -105,7 +105,7 @@ export type LookupIndexJsonStruct = IndexJsonStruct & {
 export type PropertyJsonStruct = {
   $id: string;
   token: string;
-  type: PropertyTypeJsonStructRecrsive;
+  type: PropertyTypeJsonStruct;
   nullable: boolean;
 };
 
@@ -115,11 +115,27 @@ export type PrimitivePropertyTypesArrayType = {
   items: { type: PrimitivePropertyTypes };
 };
 
+export type PropertyTypeListJsonStruct = (PrimitivePropertyTypesType | PrimitivePropertyTypesArrayType)[]
+
 export type PropertyTypeJsonStruct =
   | PrimitivePropertyTypesArrayType
   | PrimitivePropertyTypesType
-  | (PrimitivePropertyTypesType | PrimitivePropertyTypesArrayType)[];
-
-export type PropertyTypeJsonStructRecrsive =
-  | PropertyTypeJsonStruct
-  | Array<PropertyTypeJsonStruct | PropertyTypeJsonStructRecrsive[]>;
+  | PropertyTypeListJsonStruct;
+
+export const isPropertyTypeListJsonStruct = (
+  propertyType: PropertyTypeJsonStruct
+): propertyType is PropertyTypeListJsonStruct => {
+  return Array.isArray(propertyType);
+}
+
+export const isPrimitivePropertyTypesTypeJsonStruct = (
+  propertyType: PropertyTypeJsonStruct
+): propertyType is PrimitivePropertyTypesType => {
+  return typeof propertyType === "object" && "type" in propertyType && propertyType.type !== "array";
+}
+
+export const isPrimitivePropertyTypesArrayTypeJsonStruct = (
+  propertyType: PropertyTypeJsonStruct
+): propertyType is PrimitivePropertyTypesArrayType => {
+  return typeof propertyType === "object" && "type" in propertyType && propertyType.type === "array" && propertyType.items !== undefined;
+}

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

@@ -2,8 +2,7 @@ import {
   GraphSchema,
   NodeObjectType,
   PropertyBaseType,
-  PropertyTypeRecursive,
-  PropertyTypes,
+  PropertyType,
   RelationshipObjectType,
 } from "../../model/index.js";
 import { ElementPropertyObject } from "./types.js";
@@ -141,7 +140,7 @@ export function toOskars(schema: GraphSchema): string {
   return out.join("\n");
 }
 
-function formatPropertyType(type: PropertyTypeRecursive): string {
+function formatPropertyType(type: PropertyType): string {
   if (Array.isArray(type)) {
     return type.map(formatPropertyType).join("|");
   }

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

@@ -295,20 +295,35 @@ export type IndexType =
 
 export type EntityType = "node" | "relationship";
 
-export type PropertyTypes = PropertyBaseType | PropertyArrayType;
-export type PropertyTypeRecursive =
-  | PropertyTypes
-  | Array<PropertyTypes | PropertyTypeRecursive[]>;
+export type PropertyType =
+  | PropertyBaseType
+  | PropertyArrayType
+  | PropertyTypeList;
+
+export type PropertyTypeList = (PropertyBaseType | PropertyArrayType)[];
+
+export const isPropertyBaseType = (p: PropertyType): p is PropertyBaseType => {
+  return p instanceof PropertyBaseType;
+}
+
+export const isPropertyArrayType = (p: PropertyType): p is PropertyArrayType => {
+  return p instanceof PropertyArrayType;
+}
+
+export const isPropertyTypeList = (p: PropertyType): p is PropertyTypeList => {
+  return Array.isArray(p);
+}
+
 export class Property {
   $id: string;
   token: string;
-  type: PropertyTypeRecursive;
+  type: PropertyType;
   nullable: boolean;
 
   constructor(
     $id: string,
     token: string,
-    type: PropertyTypeRecursive,
+    type: PropertyType,
     nullable: boolean
   ) {
     this.$id = $id;

packages/graph-schema-utils/test/model/programatical.test.ts

@@ -2,7 +2,9 @@ import { strict as assert } from "node:assert";
 import { describe, expect, test } from "vitest";
 import { model } from "../../src/index.js";
 import {
-  PropertyTypes,
+  PropertyArrayType,
+  PropertyBaseType,
+  PropertyType,
   isLookupIndex,
   isNodeLabelConstraint,
   isNodeLabelIndex,
@@ -147,8 +149,9 @@ describe("Programatic model tests", () => {
     );
     assert.strictEqual(
       (
-        graphSchema.relationshipObjectTypes[0].type.properties[0]
-          .type as PropertyTypes
+        graphSchema.relationshipObjectTypes[0].type.properties[0].type as
+          | PropertyBaseType
+          | PropertyArrayType
       ).type,
       "array"
     );
@@ -165,7 +168,11 @@ describe("Programatic model tests", () => {
       assert.strictEqual(graphSchema.constraints[0].nodeLabel, labels[0]);
     }
     assert.strictEqual(
-      (graphSchema.constraints[0].properties[0].type as PropertyTypes).type,
+      (
+        graphSchema.constraints[0].properties[0].type as
+          | PropertyBaseType
+          | PropertyArrayType
+      ).type,
       "string"
     );
     assert.strictEqual(graphSchema.constraints[1].name, "existence");
@@ -187,7 +194,11 @@ describe("Programatic model tests", () => {
       assert.strictEqual(graphSchema.indexes[0].nodeLabel, labels[0]);
       assert.strictEqual(graphSchema.indexes[0].properties.length, 1);
       assert.strictEqual(
-        (graphSchema.indexes[0].properties[0].type as PropertyTypes).type,
+        (
+          graphSchema.indexes[0].properties[0].type as
+            | PropertyBaseType
+            | PropertyArrayType
+        ).type,
         "string"
       );
     }
@@ -204,7 +215,11 @@ describe("Programatic model tests", () => {
       );
       assert.strictEqual(graphSchema.indexes[1].properties.length, 1);
       assert.strictEqual(
-        (graphSchema.indexes[1].properties[0].type as PropertyTypes).type,
+        (
+          graphSchema.indexes[1].properties[0].type as
+            | PropertyBaseType
+            | PropertyArrayType
+        ).type,
         "array"
       );
     }

packages/introspection/src/index.ts

@@ -61,12 +61,16 @@ async function introspectNodes(
               Neo4jPropertyType | Neo4jPropertyArrayType
             >;
 
-            const types = neo4jTypes.map(createPropertyInstance);
+            const types: (model.PropertyBaseType | model.PropertyArrayType)[] =
+              neo4jTypes.map(createPropertyInstance);
+
+            const propertyType: model.PropertyType =
+              types.length === 1 ? types.pop() : types;
 
             return new model.Property(
               `${nl}_${p.propertyName}`,
               p.propertyName,
-              types.length > 1 ? types : types.pop(),
+              propertyType,
               !p.mandatory
             );
           });
@@ -125,11 +129,13 @@ async function introspectRelationships(
           >;
 
           const types = neo4jTypes.map(createPropertyInstance);
+          const propertyType: model.PropertyType =
+            types.length === 1 ? types.pop() : types;
 
           return new model.Property(
             `${relType}_${p.propertyName}`,
             p.propertyName,
-            types.length > 1 ? types : types.pop(),
+            propertyType,
             !p.mandatory
           );
         });