refactoring the names of property types

Author: eijawerner

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

@@ -6,8 +6,8 @@ import {
   NodeLabelIndex,
   NodeObjectType,
   Property,
-  PropertyArrayType,
-  PropertyBaseType,
+  PrimitiveArrayPropertyType,
+  PrimitivePropertyType,
   PropertyType,
   RelationshipObjectType,
   RelationshipType,
@@ -18,23 +18,21 @@ import {
   isNodeLabelIndex,
   isRelationshipTypeConstraint,
   isRelationshipTypeIndex,
-  isPropertyTypeList,
-  isPropertyBaseType,
-  isPropertyArrayType,
+  isPrimitivePropertyType,
+  isPrimitiveArrayPropertyType,
 } from "../../model/index.js";
 import {
   ConstraintJsonStruct,
   IndexJsonStruct,
-  isPrimitivePropertyTypesArrayTypeJsonStruct,
-  isPrimitivePropertyTypesTypeJsonStruct,
-  isPropertyTypeListJsonStruct,
+  isPrimitiveArrayPropertyTypeJsonStruct,
+  isPrimitivePropertyTypeJsonStruct,
   LookupIndexJsonStruct,
   NodeLabelConstraintJsonStruct,
   NodeLabelIndexJsonStruct,
   NodeLabelJsonStruct,
   NodeObjectTypeJsonStruct,
-  PrimitivePropertyTypesArrayType,
-  PrimitivePropertyTypesType,
+  PrimitiveArrayPropertyTypeJsonStruct,
+  PrimitivePropertyTypeJsonStruct,
   PropertyJsonStruct,
   PropertyTypeJsonStruct,
   RelationshipObjectTypeJsonStruct,
@@ -476,36 +474,40 @@ const property = {
 };
 
 const propertyType = {
-  extract: (pt: PropertyType): PropertyTypeJsonStruct => {
-    if (isPropertyTypeList(pt)) {
+  extract: (
+    pt: PropertyType | PropertyType[]
+  ): PropertyTypeJsonStruct | PropertyTypeJsonStruct[] => {
+    if (Array.isArray(pt)) {
       return pt.map((p) => {
-        if (isPropertyBaseType(p)) {
+        if (isPrimitivePropertyType(p)) {
           return propertyBaseType.extract(p);
-        } else if (isPropertyArrayType(p)) {
+        } else if (isPrimitiveArrayPropertyType(p)) {
           return propertyArrayType.extract(p);
         }
         throw Error(`Unknown property type in list ${p}`);
       });
     }
-    if (isPropertyBaseType(pt)) {
+    if (isPrimitivePropertyType(pt)) {
       return propertyBaseType.extract(pt);
-    } else if (isPropertyArrayType(pt)) {
+    } else if (isPrimitiveArrayPropertyType(pt)) {
       return propertyArrayType.extract(pt);
     }
     throw new Error(`Unknown property type ${pt}`);
   },
-  create: (propertyTypeJson: PropertyTypeJsonStruct): PropertyType => {
-    if (isPropertyTypeListJsonStruct(propertyTypeJson)) {
+  create: (
+    propertyTypeJson: PropertyTypeJsonStruct | PropertyTypeJsonStruct[]
+  ): PropertyType | PropertyType[] => {
+    if (Array.isArray(propertyTypeJson)) {
       return propertyTypeJson.map((pt) => {
-        if (isPrimitivePropertyTypesTypeJsonStruct(pt)) {
+        if (isPrimitivePropertyTypeJsonStruct(pt)) {
           return propertyBaseType.create(pt);
-        } else if (isPrimitivePropertyTypesArrayTypeJsonStruct(pt)) {
+        } else if (isPrimitiveArrayPropertyTypeJsonStruct(pt)) {
           return propertyArrayType.create(pt.items.type);
         }
         throw new Error(`Unknown property type in list ${pt}`);
       });
     }
-    if (isPrimitivePropertyTypesArrayTypeJsonStruct(propertyTypeJson)) {
+    if (isPrimitiveArrayPropertyTypeJsonStruct(propertyTypeJson)) {
       return propertyArrayType.create(propertyTypeJson.items.type);
     }
     return propertyBaseType.create(propertyTypeJson);
@@ -514,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 { PropertyArrayType, PropertyBaseType } from "../../model/index.js";
+import {
+  PrimitiveArrayPropertyType,
+  PrimitivePropertyType,
+} from "../../model/index.js";
 
 import { validateSchema } from "../../validation.js";
 
@@ -68,8 +71,8 @@ describe("Parser tests", () => {
     assert.strictEqual(
       (
         parsed.relationshipTypes[0].properties[0].type as
-          | PropertyBaseType
-          | PropertyArrayType
+          | 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,37 +106,37 @@ export type LookupIndexJsonStruct = IndexJsonStruct & {
 export type PropertyJsonStruct = {
   $id: string;
   token: string;
-  type: PropertyTypeJsonStruct;
+  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 PropertyTypeListJsonStruct = (PrimitivePropertyTypesType | PrimitivePropertyTypesArrayType)[]
-
 export type PropertyTypeJsonStruct =
-  | PrimitivePropertyTypesArrayType
-  | PrimitivePropertyTypesType
-  | PropertyTypeListJsonStruct;
-
-export const isPropertyTypeListJsonStruct = (
-  propertyType: PropertyTypeJsonStruct
-): propertyType is PropertyTypeListJsonStruct => {
-  return Array.isArray(propertyType);
-}
+  | PrimitiveArrayPropertyTypeJsonStruct
+  | PrimitivePropertyTypeJsonStruct;
 
-export const isPrimitivePropertyTypesTypeJsonStruct = (
+export const isPrimitivePropertyTypeJsonStruct = (
   propertyType: PropertyTypeJsonStruct
-): propertyType is PrimitivePropertyTypesType => {
-  return typeof propertyType === "object" && "type" in propertyType && propertyType.type !== "array";
-}
+): propertyType is PrimitivePropertyTypeJsonStruct => {
+  return (
+    typeof propertyType === "object" &&
+    "type" in propertyType &&
+    PRIMITIVE_TYPE_OPTIONS.some((p) => propertyType.type === p)
+  );
+};
 
-export const isPrimitivePropertyTypesArrayTypeJsonStruct = (
+export const isPrimitiveArrayPropertyTypeJsonStruct = (
   propertyType: PropertyTypeJsonStruct
-): propertyType is PrimitivePropertyTypesArrayType => {
-  return typeof propertyType === "object" && "type" in propertyType && propertyType.type === "array" && propertyType.items !== undefined;
-}
+): 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,7 +1,7 @@
 import {
   GraphSchema,
   NodeObjectType,
-  PropertyBaseType,
+  PrimitivePropertyType,
   PropertyType,
   RelationshipObjectType,
 } from "../../model/index.js";
@@ -140,11 +140,11 @@ export function toOskars(schema: GraphSchema): string {
   return out.join("\n");
 }
 
-function formatPropertyType(type: PropertyType): 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,35 +295,38 @@ export type IndexType =
 
 export type EntityType = "node" | "relationship";
 
-export type PropertyType =
-  | PropertyBaseType
-  | PropertyArrayType
-  | PropertyTypeList;
+export type PropertyType = PrimitivePropertyType | PrimitiveArrayPropertyType;
 
-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 isPrimitiveArrayPropertyType = (
+  property: PropertyType
+): property is PrimitiveArrayPropertyType => {
+  return (
+    property instanceof Object &&
+    property.type === "array" &&
+    property.items !== undefined
+  );
+};
 
-export const isPropertyTypeList = (p: PropertyType): p is PropertyTypeList => {
-  return Array.isArray(p);
-}
+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: PropertyType;
+  type: PropertyType | PropertyType[];
   nullable: boolean;
 
   constructor(
     $id: string,
     token: string,
-    type: PropertyType,
+    type: PropertyType | PropertyType[],
     nullable: boolean
   ) {
     this.$id = $id;
@@ -333,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];