@featurevisor/core 2.17.0 → 2.19.0

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;
     }
@@ -127,27 +132,56 @@ function getContainerSchemaAtPath(
   const lastSegment = pathSegments[pathSegments.length - 1];
   for (const seg of pathWithoutLast) {
     if (isOneOfSchema(current)) return null;
+    if (seg.key) {
+      if (current.type !== "object") return null;
+      const props = current.properties;
+      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 ("index" in seg || "selector" in seg) {
-      if (current.type !== "array") return null;
+      if (current?.type !== "array") return null;
       const itemSchema = current.items;
       if (!itemSchema || typeof itemSchema !== "object") return null;
       current = resolveSchemaRef(itemSchema, schemasByKey);
-    } 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;
-      current = resolveSchemaRef(next, schemasByKey);
     }
     if (!current) return null;
   }
   if (!current) return null;
   const parentSchema = current;
   if ("index" in lastSegment || "selector" in lastSegment) {
-    return { containerSchema: parentSchema, lastSegment, parentSchema };
+    let arraySchema: Schema | null = parentSchema;
+    if (lastSegment.key) {
+      if (arraySchema.type !== "object") return null;
+      const props = arraySchema.properties;
+      const additional = arraySchema.additionalProperties;
+      const next = props && typeof props === "object" ? props[lastSegment.key] : undefined;
+      if (next === undefined) {
+        if (!additional || typeof additional !== "object") return null;
+        arraySchema = resolveSchemaRef(additional, schemasByKey);
+      } else {
+        arraySchema = resolveSchemaRef(next, schemasByKey);
+      }
+      if (!arraySchema) return null;
+    }
+    const normalizedLastSegment =
+      "index" in lastSegment
+        ? ({ key: "", index: lastSegment.index } as PathSegment)
+        : ({ key: "", selector: lastSegment.selector } as PathSegment);
+    return {
+      containerSchema: arraySchema,
+      lastSegment: normalizedLastSegment,
+      parentSchema: arraySchema,
+    };
   }
-  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