@featurevisor/core 2.17.0 → 2.18.0

package/src/generate-code/typescript.ts

@@ -48,6 +48,63 @@ function formatObjectKey(key: string): string {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
 }
 
+function buildObjectTypeFromSchema(
+  schema: Schema,
+  schemasByKey: Record<string, Schema>,
+  schemaTypeNames?: Record<string, string>,
+): string {
+  const props = schema.properties;
+  const additional = schema.additionalProperties;
+  const hasProps = props && typeof props === "object" && Object.keys(props).length > 0;
+  const hasAdditional = additional && typeof additional === "object";
+
+  if (hasProps && hasAdditional) {
+    const requiredSet = new Set(schema.required || []);
+    const propEntries = Object.entries(props as Record<string, Schema>).map(([k, v]) => {
+      const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
+      const optional = !requiredSet.has(k);
+      return optional
+        ? `${formatObjectKey(k)}?: ${propType}`
+        : `${formatObjectKey(k)}: ${propType}`;
+    });
+    const propUnion = Object.entries(props as Record<string, Schema>)
+      .map(([, v]) => schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames))
+      .join(" | ");
+    const additionalType = schemaToTypeScriptType(
+      additional as Schema,
+      schemasByKey,
+      schemaTypeNames,
+    );
+    const indexType = [additionalType, propUnion].filter(Boolean).join(" | ");
+    return `{ ${propEntries.join("; ")}; [key: string]: ${indexType} }`;
+  }
+
+  if (hasProps) {
+    const requiredSet = new Set(schema.required || []);
+    const entries = Object.entries(props as Record<string, Schema>)
+      .map(([k, v]) => {
+        const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
+        const optional = !requiredSet.has(k);
+        return optional
+          ? `${formatObjectKey(k)}?: ${propType}`
+          : `${formatObjectKey(k)}: ${propType}`;
+      })
+      .join("; ");
+    return `{ ${entries} }`;
+  }
+
+  if (hasAdditional) {
+    const additionalType = schemaToTypeScriptType(
+      additional as Schema,
+      schemasByKey,
+      schemaTypeNames,
+    );
+    return `Record<string, ${additionalType}>`;
+  }
+
+  return "Record<string, unknown>";
+}
+
 function formatTypeImport(typeNames: string[], fromPath: string): string {
   if (typeNames.length === 0) {
     return "";
@@ -132,19 +189,7 @@ function schemaToTypeScriptType(
       }
       return "string[]";
     case "object": {
-      const props = resolved.properties;
-      if (props && typeof props === "object" && Object.keys(props).length > 0) {
-        const requiredSet = new Set(resolved.required || []);
-        const entries = Object.entries(props)
-          .map(([k, v]) => {
-            const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
-            const optional = !requiredSet.has(k);
-            return optional ? `${k}?: ${propType}` : `${k}: ${propType}`;
-          })
-          .join("; ");
-        return `{ ${entries} }`;
-      }
-      return "Record<string, unknown>";
+      return buildObjectTypeFromSchema(resolved, schemasByKey, schemaTypeNames);
     }
     default:
       return "unknown";
@@ -265,13 +310,17 @@ function generateVariableTypeDeclarations(
 
   if (type === "object") {
     const resolvedEffective =
-      effective && "properties" in effective
+      effective && ("properties" in effective || "additionalProperties" in effective)
         ? (resolveSchema(effective as Schema, schemasByKey) as Schema)
         : undefined;
     const props = resolvedEffective?.properties;
-    if (props && typeof props === "object" && Object.keys(props).length > 0) {
+    const additional = resolvedEffective?.additionalProperties;
+    if (
+      (props && typeof props === "object" && Object.keys(props).length > 0) ||
+      (additional && typeof additional === "object")
+    ) {
       const requiredSet = new Set(resolvedEffective?.required || []);
-      const entries = Object.entries(props)
+      const entries = Object.entries(props ?? {})
         .map(([k, v]) => {
           const propType = schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames);
           if (schemaTypeNames)
@@ -280,11 +329,29 @@ function generateVariableTypeDeclarations(
             });
           const optional = !requiredSet.has(k);
           return optional
-            ? `${INDENT_NS_BODY}${k}?: ${propType};`
-            : `${INDENT_NS_BODY}${k}: ${propType};`;
+            ? `${INDENT_NS_BODY}${formatObjectKey(k)}?: ${propType};`
+            : `${INDENT_NS_BODY}${formatObjectKey(k)}: ${propType};`;
         })
-        .join("\n");
-      declarations.push(`${INDENT_NS}export interface ${typeName} {\n${entries}\n${INDENT_NS}}`);
+        .filter(Boolean);
+      if (additional && typeof additional === "object") {
+        const additionalType = schemaToTypeScriptType(
+          additional as Schema,
+          schemasByKey,
+          schemaTypeNames,
+        );
+        if (schemaTypeNames)
+          Object.values(schemaTypeNames).forEach((n) => {
+            if (additionalType.includes(n)) addSchemaUsed(n);
+          });
+        const propUnion = Object.entries(props ?? {})
+          .map(([, v]) => schemaToTypeScriptType(v as Schema, schemasByKey, schemaTypeNames))
+          .join(" | ");
+        const indexType = [additionalType, propUnion].filter(Boolean).join(" | ");
+        entries.push(`${INDENT_NS_BODY}[key: string]: ${indexType};`);
+      }
+      declarations.push(
+        `${INDENT_NS}export interface ${typeName} {\n${entries.join("\n")}\n${INDENT_NS}}`,
+      );
       return { declarations, returnTypeName: typeName, genericArg: typeName, schemaTypesUsed };
     }
     declarations.push(`${INDENT_NS}export type ${typeName} = Record<string, unknown>;`);

package/src/linter/featureSchema.spec.ts

@@ -852,6 +852,89 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
       );
     });
 
+    it("accepts object variable with additionalProperties only and arbitrary keys", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            labels: {
+              type: "object",
+              additionalProperties: { type: "string" },
+              defaultValue: { title: "Welcome", subtitle: "Hello" },
+            },
+          },
+        }),
+      );
+    });
+
+    it("accepts object variable with properties and additionalProperties together", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            metadata: {
+              type: "object",
+              properties: {
+                fixed: { type: "integer" },
+              },
+              additionalProperties: { type: "string" },
+              required: ["fixed"],
+              defaultValue: { fixed: 1, dynamicKey: "value" },
+            },
+          },
+        }),
+      );
+    });
+
+    it("rejects object variable when unknown key is present and additionalProperties is not defined", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            settings: {
+              type: "object",
+              properties: {
+                theme: { type: "string" },
+              },
+              defaultValue: { theme: "light", subtitle: "hello" },
+            },
+          },
+        }),
+        "Unknown property",
+      );
+    });
+
+    it("accepts object variable with additionalProperties that references reusable schema", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            linksByLocale: {
+              type: "object",
+              additionalProperties: { schema: "link" },
+              defaultValue: {
+                en: { title: "Home", url: "/" },
+                de: { title: "Start", url: "/de" },
+              },
+            },
+          },
+        }),
+      );
+    });
+
+    it("rejects object variable when additionalProperties value does not match schema", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            linksByLocale: {
+              type: "object",
+              additionalProperties: { schema: "link" },
+              defaultValue: {
+                en: { title: "Home" },
+              },
+            },
+          },
+        }),
+        "Missing required property",
+      );
+    });
+
     it("rejects inline object variable when defaultValue is missing required property", () => {
       expectParseFailure(
         baseFeature({
@@ -1417,5 +1500,40 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
         },
       );
     });
+
+    it("additionalProperties type mismatch: error path includes dynamic object key", () => {
+      expectErrorSurfaces(
+        baseFeature({
+          variablesSchema: {
+            labels: {
+              type: "object",
+              additionalProperties: { type: "string" },
+              defaultValue: {
+                title: 123,
+              },
+            },
+          },
+        }),
+        {
+          pathContains: ["variablesSchema", "labels", "defaultValue", "title"],
+          messageContains: "type string",
+        },
+      );
+    });
+
+    it("rejects variable schema with schema reference mixed with inline additionalProperties", () => {
+      expectParseFailure(
+        baseFeature({
+          variablesSchema: {
+            myLink: {
+              schema: "link",
+              additionalProperties: { type: "string" },
+              defaultValue: { title: "Home", url: "/" },
+            },
+          },
+        }),
+        "additionalProperties",
+      );
+    });
   });
 });

package/src/linter/featureSchema.ts

@@ -51,6 +51,7 @@ function resolveVariableSchema(
     type?: string;
     items?: unknown;
     properties?: unknown;
+    additionalProperties?: unknown;
     required?: string[];
     enum?: unknown[];
     const?: unknown;
@@ -69,6 +70,7 @@ function resolveVariableSchema(
   type?: string;
   items?: unknown;
   properties?: unknown;
+  additionalProperties?: unknown;
   required?: string[];
   enum?: unknown[];
   const?: unknown;
@@ -89,6 +91,7 @@ function resolveVariableSchema(
     type?: string;
     items?: unknown;
     properties?: unknown;
+    additionalProperties?: unknown;
     required?: string[];
     enum?: unknown[];
     const?: unknown;
@@ -133,6 +136,7 @@ function valueMatchesSchema(
     enum?: unknown[];
     oneOf?: unknown[];
     properties?: Record<string, unknown>;
+    additionalProperties?: unknown;
     required?: string[];
     items?: unknown;
     minimum?: number;
@@ -195,8 +199,16 @@ function valueMatchesSchema(
   if (type === "object") {
     if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
     const props = resolved.properties;
-    if (!props || typeof props !== "object") return true;
+    const additional = resolved.additionalProperties;
     const obj = value as Record<string, unknown>;
+    if ((!props || typeof props !== "object") && (!additional || typeof additional !== "object")) {
+      return true;
+    }
+    if (!props || typeof props !== "object") {
+      return Object.keys(obj).every((key) =>
+        valueMatchesSchema(additional as { [k: string]: unknown }, obj[key], schemasByKey),
+      );
+    }
     const required = new Set(resolved.required || []);
     for (const key of required) {
       if (!Object.prototype.hasOwnProperty.call(obj, key)) return false;
@@ -205,9 +217,15 @@ function valueMatchesSchema(
     }
     for (const key of Object.keys(obj)) {
       const propSchema = props[key];
-      if (!propSchema) return false;
-      if (!valueMatchesSchema(propSchema as { [k: string]: unknown }, obj[key], schemasByKey))
+      if (propSchema) {
+        if (!valueMatchesSchema(propSchema as { [k: string]: unknown }, obj[key], schemasByKey))
+          return false;
+      } else if (additional && typeof additional === "object") {
+        if (!valueMatchesSchema(additional as { [k: string]: unknown }, obj[key], schemasByKey))
+          return false;
+      } else {
         return false;
+      }
     }
     return true;
   }
@@ -259,6 +277,7 @@ function valueDeepEqual(a: unknown, b: unknown): boolean {
 type SchemaLikeForRequired = {
   type?: string;
   properties?: Record<string, unknown>;
+  additionalProperties?: unknown;
   required?: string[];
   items?: unknown;
   schema?: string;
@@ -325,6 +344,19 @@ function refineRequiredKeysInSchema(
       }
     }
   }
+  const additionalProperties = (current as { additionalProperties?: unknown }).additionalProperties;
+  if (
+    additionalProperties &&
+    typeof additionalProperties === "object" &&
+    !Array.isArray(additionalProperties)
+  ) {
+    refineRequiredKeysInSchema(
+      additionalProperties as SchemaLikeForRequired,
+      [...pathPrefix, "additionalProperties"],
+      ctx,
+      schemasByKey,
+    );
+  }
 
   if (items && typeof items === "object" && !Array.isArray(items)) {
     refineRequiredKeysInSchema(
@@ -453,6 +485,7 @@ function refineVariableValueObject(
   projectConfig: ProjectConfig,
   variableSchema: {
     properties?: Record<string, unknown>;
+    additionalProperties?: unknown;
     required?: string[];
     type: string;
   },
@@ -464,6 +497,7 @@ function refineVariableValueObject(
 ): void {
   const label = getVariableLabel(variableSchema, variableKey, path);
   const schemaProperties = variableSchema.properties;
+  const additionalProperties = variableSchema.additionalProperties;
 
   if (schemaProperties && typeof schemaProperties === "object") {
     const requiredKeys =
@@ -485,7 +519,17 @@ function refineVariableValueObject(
 
     for (const key of Object.keys(variableValue)) {
       const propSchema = schemaProperties[key];
-      if (!propSchema) {
+      if (!propSchema && additionalProperties && typeof additionalProperties === "object") {
+        superRefineVariableValue(
+          projectConfig,
+          additionalProperties as Parameters<typeof superRefineVariableValue>[1],
+          variableValue[key],
+          [...path, key],
+          ctx,
+          key,
+          schemasByKey,
+        );
+      } else if (!propSchema) {
         ctx.addIssue({
           code: z.ZodIssueCode.custom,
           message: `Unknown property "${key}" in variable "${label}" (not in schema)`,
@@ -503,6 +547,18 @@ function refineVariableValueObject(
         );
       }
     }
+  } else if (additionalProperties && typeof additionalProperties === "object") {
+    for (const key of Object.keys(variableValue)) {
+      superRefineVariableValue(
+        projectConfig,
+        additionalProperties as Parameters<typeof superRefineVariableValue>[1],
+        variableValue[key],
+        [...path, key],
+        ctx,
+        key,
+        schemasByKey,
+      );
+    }
   } else {
     for (const key of Object.keys(variableValue)) {
       const propValue = variableValue[key];
@@ -1280,6 +1336,7 @@ export function getFeatureZodSchema(
               type: z.union([z.literal("json"), propertyTypeEnum]).optional(),
               items: schemaZodSchema.optional(),
               properties: z.record(schemaZodSchema).optional(),
+              additionalProperties: schemaZodSchema.optional(),
               required: z.array(z.string()).optional(),
               enum: z.array(variableValueZodSchema).optional(),
               const: variableValueZodSchema.optional(),
@@ -1315,7 +1372,7 @@ export function getFeatureZodSchema(
                 ctx.addIssue({
                   code: z.ZodIssueCode.custom,
                   message:
-                    "Variable schema cannot have both `schema` (reference) and inline properties (`type`, `oneOf`, `properties`, `required`, `items`). Use one or the other.",
+                    "Variable schema cannot have both `schema` (reference) and inline properties (`type`, `oneOf`, `properties`, `additionalProperties`, `required`, `items`). Use one or the other.",
                   path: [],
                 });
                 return;
@@ -1324,6 +1381,8 @@ export function getFeatureZodSchema(
                 const hasInlineStructure =
                   ("type" in variableSchema && variableSchema.type != null) ||
                   ("properties" in variableSchema && variableSchema.properties != null) ||
+                  ("additionalProperties" in variableSchema &&
+                    variableSchema.additionalProperties != null) ||
                   ("required" in variableSchema && variableSchema.required != null) ||
                   ("items" in variableSchema && variableSchema.items != null) ||
                   ("oneOf" in variableSchema && variableSchema.oneOf != null);
@@ -1340,7 +1399,7 @@ export function getFeatureZodSchema(
                   ctx.addIssue({
                     code: z.ZodIssueCode.custom,
                     message:
-                      "When `schema` is set, do not set `type`, `oneOf`, `properties`, `required`, or `items`.",
+                      "When `schema` is set, do not set `type`, `oneOf`, `properties`, `additionalProperties`, `required`, or `items`.",
                     path: [],
                   });
                 }

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({