@featurevisor/core 2.16.0 → 2.18.0

package/src/linter/mutationNotation.spec.ts

@@ -257,6 +257,17 @@ describe("mutationNotation.ts", () => {
       expect(result).toBeNull();
     });
 
+    it("resolves unknown object key via additionalProperties", () => {
+      const result = resolveSchemaAtPath(
+        {
+          type: "object",
+          additionalProperties: { type: "string" },
+        },
+        [{ key: "dynamicKey" }],
+      );
+      expect(result).toEqual({ type: "string" });
+    });
+
     it("returns null when stepping into non-object", () => {
       const result = resolveSchemaAtPath(objectSchema, [{ key: "width" }, { key: "foo" }]);
       expect(result).toBeNull();
@@ -446,6 +457,18 @@ describe("mutationNotation.ts", () => {
         expect(r.error).toContain("path does not exist");
       });
 
+      it("valid when path uses additionalProperties", () => {
+        const schemas: Record<string, Schema> = {
+          labels: {
+            type: "object",
+            additionalProperties: { type: "string" },
+          },
+        };
+        const r = validateMutationKey("labels.headline", schemas);
+        expect(r.valid).toBe(true);
+        expect(r.valueSchema).toEqual({ type: "string" });
+      });
+
       it("invalid when target schema is oneOf", () => {
         const schemas: Record<string, Schema> = {
           x: {

package/src/linter/mutationNotation.ts

@@ -88,9 +88,14 @@ export function resolveSchemaAtPath(
     if (seg.key) {
       if (current.type !== "object") return null;
       const props = current.properties;
-      if (!props || typeof props !== "object") return null;
-      const next = props[seg.key];
-      if (next === undefined) return null;
+      const additional = current.additionalProperties;
+      const next = props && typeof props === "object" ? props[seg.key] : undefined;
+      if (next === undefined) {
+        if (!additional || typeof additional !== "object") return null;
+        current = resolveSchemaRef(additional, schemasByKey);
+        if (!current) return null;
+        continue;
+      }
       current = resolveSchemaRef(next, schemasByKey);
       if (!current) return null;
     }
@@ -135,9 +140,14 @@ function getContainerSchemaAtPath(
     } else {
       if (current.type !== "object") return null;
       const props = current.properties;
-      if (!props || typeof props !== "object") return null;
-      const next = props[seg.key];
-      if (next === undefined) return null;
+      const additional = current.additionalProperties;
+      const next = props && typeof props === "object" ? props[seg.key] : undefined;
+      if (next === undefined) {
+        if (!additional || typeof additional !== "object") return null;
+        current = resolveSchemaRef(additional, schemasByKey);
+        if (!current) return null;
+        continue;
+      }
       current = resolveSchemaRef(next, schemasByKey);
     }
     if (!current) return null;
@@ -147,7 +157,8 @@ function getContainerSchemaAtPath(
   if ("index" in lastSegment || "selector" in lastSegment) {
     return { containerSchema: parentSchema, lastSegment, parentSchema };
   }
-  const propSchema = parentSchema.properties?.[lastSegment.key];
+  const propSchema =
+    parentSchema.properties?.[lastSegment.key] ?? parentSchema.additionalProperties;
   const resolvedProp =
     propSchema && typeof propSchema === "object"
       ? resolveSchemaRef(propSchema, schemasByKey)

package/src/linter/schema.spec.ts

@@ -142,6 +142,20 @@ describe("schema.ts :: refineEnumMatchesType", () => {
     expect(issues[0].path).toEqual(["oneOf", 1, "enum", 1]);
   });
 
+  it("recurses into additionalProperties", () => {
+    const { issues, ctx } = createRefinementCtx();
+    refineEnumMatchesType(
+      {
+        type: "object",
+        additionalProperties: { type: "string", enum: ["a", 1] },
+      },
+      [],
+      ctx,
+    );
+    expect(issues).toHaveLength(1);
+    expect(issues[0].path).toEqual(["additionalProperties", "enum", 1]);
+  });
+
   it("does nothing when schema is null or not an object", () => {
     const { issues: i1, ctx: c1 } = createRefinementCtx();
     refineEnumMatchesType(null as any, [], c1);
@@ -215,6 +229,20 @@ describe("schema.ts :: refineMinimumMaximum", () => {
     expect(issues).toHaveLength(1);
     expect(issues[0].path).toEqual(["items", "minimum"]);
   });
+
+  it("recurses into additionalProperties", () => {
+    const { issues, ctx } = createRefinementCtx();
+    refineMinimumMaximum(
+      {
+        type: "object",
+        additionalProperties: { type: "integer", minimum: 10, maximum: 5 },
+      },
+      [],
+      ctx,
+    );
+    expect(issues).toHaveLength(1);
+    expect(issues[0].path).toEqual(["additionalProperties", "minimum"]);
+  });
 });
 
 describe("schema.ts :: refineStringLengthPattern", () => {
@@ -288,6 +316,20 @@ describe("schema.ts :: refineStringLengthPattern", () => {
     expect(issues).toHaveLength(1);
     expect(issues[0].path).toEqual(["properties", "code", "minLength"]);
   });
+
+  it("recurses into additionalProperties", () => {
+    const { issues, ctx } = createRefinementCtx();
+    refineStringLengthPattern(
+      {
+        type: "object",
+        additionalProperties: { type: "string", minLength: 10, maxLength: 5 },
+      },
+      [],
+      ctx,
+    );
+    expect(issues).toHaveLength(1);
+    expect(issues[0].path).toEqual(["additionalProperties", "minLength"]);
+  });
 });
 
 describe("schema.ts :: refineArrayItems", () => {
@@ -357,6 +399,25 @@ describe("schema.ts :: refineArrayItems", () => {
     expect(issues).toHaveLength(1);
     expect(issues[0].path).toEqual(["items", "minItems"]);
   });
+
+  it("recurses into additionalProperties", () => {
+    const { issues, ctx } = createRefinementCtx();
+    refineArrayItems(
+      {
+        type: "object",
+        additionalProperties: {
+          type: "array",
+          minItems: 5,
+          maxItems: 2,
+          items: { type: "string" },
+        },
+      },
+      [],
+      ctx,
+    );
+    expect(issues).toHaveLength(1);
+    expect(issues[0].path).toEqual(["additionalProperties", "minItems"]);
+  });
 });
 
 describe("schema.ts :: getSchemaZodSchema", () => {
@@ -491,6 +552,17 @@ describe("schema.ts :: getSchemaZodSchema", () => {
     expect(result.success).toBe(true);
   });
 
+  it("accepts object schema with additionalProperties", () => {
+    const Schema = getSchemaZodSchema([]);
+    const result = Schema.safeParse({
+      type: "object",
+      additionalProperties: {
+        type: "string",
+      },
+    });
+    expect(result.success).toBe(true);
+  });
+
   it("accepts array schema with items that reference another schema", () => {
     const Schema = getSchemaZodSchema(["link"]);
     const result = Schema.safeParse({

package/src/linter/schema.ts

@@ -35,6 +35,7 @@ type SchemaLike = {
   uniqueItems?: boolean;
   items?: unknown;
   properties?: Record<string, unknown>;
+  additionalProperties?: unknown;
   oneOf?: unknown[];
 };
 
@@ -74,6 +75,13 @@ export function refineEnumMatchesType(
       );
     }
   }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    refineEnumMatchesType(
+      schema.additionalProperties as SchemaLike,
+      [...pathPrefix, "additionalProperties"],
+      ctx,
+    );
+  }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     schema.oneOf.forEach((branch, i) => {
       if (branch && typeof branch === "object") {
@@ -157,6 +165,13 @@ export function refineMinimumMaximum(
       );
     }
   }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    refineMinimumMaximum(
+      schema.additionalProperties as SchemaLike,
+      [...pathPrefix, "additionalProperties"],
+      ctx,
+    );
+  }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     schema.oneOf.forEach((branch, i) => {
       if (branch && typeof branch === "object") {
@@ -277,6 +292,13 @@ export function refineStringLengthPattern(
       );
     }
   }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    refineStringLengthPattern(
+      schema.additionalProperties as SchemaLike,
+      [...pathPrefix, "additionalProperties"],
+      ctx,
+    );
+  }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     schema.oneOf.forEach((branch, i) => {
       if (branch && typeof branch === "object") {
@@ -376,6 +398,13 @@ export function refineArrayItems(
       refineArrayItems(schema.properties[k] as SchemaLike, [...pathPrefix, "properties", k], ctx);
     }
   }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+    refineArrayItems(
+      schema.additionalProperties as SchemaLike,
+      [...pathPrefix, "additionalProperties"],
+      ctx,
+    );
+  }
   if (schema.oneOf && Array.isArray(schema.oneOf)) {
     schema.oneOf.forEach((branch, i) => {
       if (branch && typeof branch === "object") {
@@ -428,6 +457,7 @@ export function getSchemaZodSchema(schemaKeys: SchemaKey[] = []) {
         uniqueItems: z.boolean().optional(),
         required: z.array(z.string()).optional(),
         properties: z.record(z.string(), schemaZodSchema).optional(),
+        additionalProperties: schemaZodSchema.optional(),
         // Annotations: default?: Value; examples?: Value[];
 
         schema: z