feat(validator): add property validator

bitbeckers · bitbeckers · commit 4e2bfd71480f · 2025-01-26T22:42:23.000+01:00
Add property validator that also specifically checks for geoJSONs. The
pattern should be scalable to multiple specific types of properties.

Updated the metadata validator to validate properties in metadata when
applicable.

Add and update test suite
diff --git a/src/resources/schema/metadata.json b/src/resources/schema/metadata.json
@@ -36,14 +36,26 @@
       "type": "array",
       "items": {
         "type": "object",
-        "properties": {
-          "trait_type": {
-            "type": "string"
+        "oneOf": [
+          {
+            "properties": {
+              "trait_type": { "type": "string" },
+              "value": { "type": "string" }
+            },
+            "required": ["trait_type", "value"],
+            "additionalProperties": false
           },
-          "value": {
-            "type": "string"
+          {
+            "properties": {
+              "trait_type": { "type": "string" },
+              "type": { "type": "string" },
+              "src": { "type": "string" },
+              "name": { "type": "string" }
+            },
+            "required": ["trait_type", "type", "src", "name"],
+            "additionalProperties": false
           }
-        }
+        ]
       }
     },
     "hypercert": {
diff --git a/src/types/metadata.d.ts b/src/types/metadata.d.ts
@@ -37,11 +37,18 @@ export interface HypercertMetadata {
    * A CID pointer to the merke tree proof json on ipfs
    */
   allowList?: string;
-  properties?: {
-    trait_type?: string;
-    value?: string;
-    [k: string]: unknown;
-  }[];
+  properties?: (
+    | {
+        trait_type: string;
+        value: string;
+      }
+    | {
+        trait_type: string;
+        type: string;
+        src: string;
+        name: string;
+      }
+  )[];
   hypercert?: HypercertClaimdata;
 }
 /**
diff --git a/src/validator/ValidatorFactory.ts b/src/validator/ValidatorFactory.ts
@@ -4,6 +4,7 @@ import { MerkleProofData, MerkleProofValidator } from "./validators/MerkleProofV
 import { MetadataValidator, ClaimDataValidator } from "./validators/MetadataValidator";
 import { AllowlistValidator } from "./validators/AllowListValidator";
 import { AllowlistValidationParams } from "./validators/AllowListValidator";
+import { PropertyValidator, PropertyValue } from "./validators/PropertyValidator";
 
 export class ValidatorFactory {
   static createMetadataValidator(): IValidator<HypercertMetadata> {
@@ -21,4 +22,8 @@ export class ValidatorFactory {
   static createMerkleProofValidator(): IValidator<MerkleProofData> {
     return new MerkleProofValidator();
   }
+
+  static createPropertyValidator(): IValidator<PropertyValue> {
+    return new PropertyValidator();
+  }
 }
diff --git a/src/validator/validators/MetadataValidator.ts b/src/validator/validators/MetadataValidator.ts
@@ -2,10 +2,37 @@ import { HypercertClaimdata, HypercertMetadata } from "src/types/metadata";
 import { SchemaValidator } from "../base/SchemaValidator";
 import claimDataSchema from "../../resources/schema/claimdata.json";
 import metaDataSchema from "../../resources/schema/metadata.json";
+import { PropertyValidator } from "./PropertyValidator";
 
 export class MetadataValidator extends SchemaValidator<HypercertMetadata> {
+  private propertyValidator: PropertyValidator;
+
   constructor() {
     super(metaDataSchema, [claimDataSchema]);
+    this.propertyValidator = new PropertyValidator();
+  }
+
+  validate(data: unknown) {
+    const result = super.validate(data);
+    const errors = [...(result.errors || [])];
+
+    if (data) {
+      const metadata = data as HypercertMetadata;
+      if (metadata.properties?.length) {
+        const propertyErrors = metadata.properties
+          .map((property) => this.propertyValidator.validate(property))
+          .filter((result) => !result.isValid)
+          .flatMap((result) => result.errors);
+
+        errors.push(...propertyErrors);
+      }
+    }
+
+    return {
+      isValid: errors.length === 0,
+      data: errors.length === 0 ? result.data : undefined,
+      errors,
+    };
   }
 }
 
diff --git a/src/validator/validators/PropertyValidator.ts b/src/validator/validators/PropertyValidator.ts
@@ -0,0 +1,100 @@
+import { ValidationError } from "../interfaces";
+import { SchemaValidator } from "../base/SchemaValidator";
+import { HypercertMetadata } from "src/types";
+import metaDataSchema from "../../resources/schema/metadata.json";
+
+export type PropertyValues = HypercertMetadata["properties"];
+type PropertyValue = NonNullable<PropertyValues>[number];
+
+interface PropertyValidationStrategy {
+  validate(property: NonNullable<PropertyValue>): ValidationError[];
+}
+
+interface GeoJSONProperty {
+  trait_type: string;
+  type: string;
+  src: string;
+  name: string;
+}
+
+class GeoJSONValidationStrategy implements PropertyValidationStrategy {
+  private readonly MIME_TYPE = "applications/geo+json";
+
+  validate(property: NonNullable<PropertyValue>): ValidationError[] {
+    if (!this.isGeoJSONProperty(property)) {
+      return [
+        {
+          field: "type",
+          code: "missing_type",
+          message: "GeoJSON property must have type field",
+        },
+      ];
+    }
+
+    const errors: ValidationError[] = [];
+
+    if (property.type !== this.MIME_TYPE) {
+      errors.push({
+        field: "type",
+        code: "invalid_mime_type",
+        message: `GeoJSON type must be ${this.MIME_TYPE}`,
+      });
+    }
+
+    if (!property.src?.startsWith("ipfs://") && !property.src?.startsWith("https://")) {
+      errors.push({
+        field: "src",
+        code: "invalid_url",
+        message: "GeoJSON src must start with ipfs:// or https://",
+      });
+    }
+
+    if (!property.name?.endsWith(".geojson")) {
+      errors.push({
+        field: "name",
+        code: "invalid_file_extension",
+        message: "GeoJSON name must end with .geojson",
+      });
+    }
+
+    return errors;
+  }
+
+  private isGeoJSONProperty(property: any): property is GeoJSONProperty {
+    return "type" in property && "src" in property && "name" in property;
+  }
+}
+
+export class PropertyValidator extends SchemaValidator<PropertyValue> {
+  private readonly validationStrategies: Record<string, PropertyValidationStrategy> = {
+    geoJSON: new GeoJSONValidationStrategy(),
+  };
+
+  constructor() {
+    super(metaDataSchema.properties.properties.items);
+  }
+
+  validate(data: unknown) {
+    const result = super.validate(data);
+
+    if (!result.isValid || !result.data) {
+      return result;
+    }
+
+    const property = result.data as NonNullable<PropertyValue>;
+    const strategy = this.validationStrategies[property.trait_type];
+
+    if (strategy) {
+      const errors = strategy.validate(property);
+      if (errors.length > 0) {
+        return {
+          isValid: false,
+          data: undefined,
+          errors,
+        };
+      }
+    }
+
+    return result;
+  }
+}
diff --git a/test/validator/validators/MetadataValidator.test.ts b/test/validator/validators/MetadataValidator.test.ts
@@ -43,41 +43,160 @@ describe("MetadataValidator", () => {
     hypercert: validClaimData,
   };
 
-  it("should validate valid metadata", () => {
-    const result = validator.validate(validMetadata);
+  describe("Basic Metadata Validation", () => {
+    it("should validate valid metadata", () => {
+      const result = validator.validate(validMetadata);
+      expect(result.isValid).to.be.true;
+      expect(result.data).to.deep.equal(validMetadata);
+      expect(result.errors).to.be.empty;
+    });
 
-    expect(result.isValid).to.be.true;
-    expect(result.data).to.deep.equal(validMetadata);
-    expect(result.errors).to.be.empty;
+    it("should validate required fields", () => {
+      const invalidMetadata = {
+        description: "Test Description",
+        image: "ipfs://test",
+      };
+
+      const result = validator.validate(invalidMetadata);
+      expect(result.isValid).to.be.false;
+      expect(result.errors[0].field).to.equal("name");
+    });
   });
 
-  it("should validate required fields", () => {
-    const invalidMetadata = {
-      description: "Test Description",
-      image: "ipfs://test",
-    };
+  describe("Property Validation", () => {
+    it("should validate metadata with valid properties", () => {
+      const metadataWithProperties = {
+        ...validMetadata,
+        properties: [
+          {
+            trait_type: "category",
+            value: "education",
+          },
+          {
+            trait_type: "geoJSON",
+            type: "applications/geo+json",
+            src: "ipfs://QmExample",
+            name: "location.geojson",
+          },
+        ],
+      };
 
-    const result = validator.validate(invalidMetadata);
+      const result = validator.validate(metadataWithProperties);
+      expect(result.isValid).to.be.true;
+      expect(result.data).to.deep.equal(metadataWithProperties);
+    });
 
-    expect(result.isValid).to.be.false;
-    expect(result.errors[0].field).to.equal("name");
+    it("should reject metadata with invalid simple property", () => {
+      const metadataWithInvalidProperty = {
+        ...validMetadata,
+        properties: [
+          {
+            trait_type: "category",
+            // missing required 'value' field
+          },
+        ],
+      };
+
+      const result = validator.validate(metadataWithInvalidProperty);
+      expect(result.isValid).to.be.false;
+      expect(result.errors).to.have.length.greaterThan(0);
+    });
+
+    it("should reject metadata with invalid geoJSON property", () => {
+      const metadataWithInvalidGeoJSON = {
+        ...validMetadata,
+        properties: [
+          {
+            trait_type: "geoJSON",
+            type: "wrong/type",
+            src: "invalid://QmExample",
+            name: "location.wrong",
+          },
+        ],
+      };
+
+      const result = validator.validate(metadataWithInvalidGeoJSON);
+      expect(result.isValid).to.be.false;
+      expect(result.errors).to.have.length(3); // MIME type, URL, and file extension errors
+    });
+
+    it("should collect all property validation errors", () => {
+      const metadataWithMultipleInvalidProperties = {
+        ...validMetadata,
+        properties: [
+          {
+            trait_type: "category",
+            // missing value
+          },
+          {
+            trait_type: "geoJSON",
+            type: "wrong/type",
+            src: "invalid://QmExample",
+            name: "location.wrong",
+          },
+        ],
+      };
+
+      const result = validator.validate(metadataWithMultipleInvalidProperties);
+      expect(result.isValid).to.be.false;
+      expect(result.errors.length).to.be.greaterThan(3); // Schema error plus GeoJSON errors
+    });
+
+    it("should handle empty properties array", () => {
+      const metadataWithEmptyProperties = {
+        ...validMetadata,
+        properties: [],
+      };
+
+      const result = validator.validate(metadataWithEmptyProperties);
+      expect(result.isValid).to.be.true;
+    });
   });
 
-  it("should validate nested claim data", () => {
-    const invalidMetadata = {
-      ...validMetadata,
-      hypercert: {
-        ...validClaimData,
-        impact_scope: undefined,
-      },
-    };
+  describe("Combined Validation", () => {
+    it("should validate metadata with both valid properties and claim data", () => {
+      const completeMetadata = {
+        ...validMetadata,
+        properties: [
+          {
+            trait_type: "category",
+            value: "education",
+          },
+          {
+            trait_type: "geoJSON",
+            type: "applications/geo+json",
+            src: "ipfs://QmExample",
+            name: "location.geojson",
+          },
+        ],
+      };
 
-    const result = validator.validate(invalidMetadata);
+      const result = validator.validate(completeMetadata);
+      expect(result.isValid).to.be.true;
+      expect(result.data).to.deep.equal(completeMetadata);
+    });
 
-    expect(result.isValid).to.be.false;
-    expect(result.errors[0].field).to.equal("/hypercert");
-    // or if we want to check the specific error message:
-    expect(result.errors[0].message).to.include("impact_scope");
+    it("should collect errors from both metadata and property validation", () => {
+      const invalidMetadata = {
+        description: "Test Description", // missing required name
+        image: "ipfs://test",
+        properties: [
+          {
+            trait_type: "geoJSON",
+            type: "wrong/type",
+            src: "invalid://QmExample",
+            name: "location.wrong",
+          },
+        ],
+      };
+
+      const result = validator.validate(invalidMetadata);
+
+      console.log(result.errors);
+
+      expect(result.isValid).to.be.false;
+      expect(result.errors).to.have.length.greaterThan(3); // Schema errors plus property errors
+    });
   });
 });
 
diff --git a/test/validator/validators/PropertyValidator.test.ts b/test/validator/validators/PropertyValidator.test.ts
