@featurevisor/core 2.16.0 → 2.18.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featurevisor/core",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "description": "Core package of Featurevisor for Node.js usage",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -40,14 +40,14 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@featurevisor/sdk": "2.12.0",
-    "@featurevisor/site": "2.12.0",
-    "@featurevisor/types": "2.12.0",
+    "@featurevisor/sdk": "2.18.0",
+    "@featurevisor/site": "2.18.0",
+    "@featurevisor/types": "2.18.0",
     "axios": "^1.3.4",
     "tar": "^7.5.7",
     "yaml": "^1.10.2",
     "yargs": "^17.7.2",
     "zod": "^3.22.4"
   },
-  "gitHead": "372701b0794f3b818ec9a9ef8d8e0449fb60a321"
+  "gitHead": "469800809b026bb42e1bc7298649d6e49e47992d"
 }

package/src/generate-code/typescript.ts

@@ -39,6 +39,80 @@ function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string): stri
   }
 }
 
+function shouldWrapArrayItemType(typeName: string): boolean {
+  const trimmed = typeName.trim();
+  return trimmed.includes("|") || trimmed.includes("&");
+}
+
+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 "";
+  }
+
+  return `import type {\n${typeNames.map((name) => `  ${name},`).join("\n")}\n} from "${fromPath}";\n\n`;
+}
+
 /**
  * Resolve a schema to its full definition, following schema references (schema: key).
  */
@@ -110,23 +184,12 @@ function schemaToTypeScriptType(
       return literalFromConst ?? unionFromEnum ?? "number";
     case "array":
       if (resolved.items) {
-        return `(${schemaToTypeScriptType(resolved.items, schemasByKey, schemaTypeNames)})[]`;
+        const itemType = schemaToTypeScriptType(resolved.items, schemasByKey, schemaTypeNames);
+        return shouldWrapArrayItemType(itemType) ? `(${itemType})[]` : `${itemType}[]`;
       }
       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";
@@ -247,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)
@@ -262,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>;`);
@@ -534,7 +619,7 @@ export async function generateTypeScriptCodeForProject(
     })
     .join("\n");
   const contextContent = `
-import type { AttributeKey, AttributeValue } from "@featurevisor/types";
+import type { AttributeKey, AttributeValue } from "@featurevisor/sdk";
 
 export interface Context {
 ${attributeProperties}
@@ -542,7 +627,7 @@ ${attributeProperties}
 }
 `.trimStart();
 
-  const contextTypeFilePath = path.join(outputPath, "Context.ts");
+  const contextTypeFilePath = path.join(outputPath, "context.ts");
   fs.writeFileSync(contextTypeFilePath, contextContent);
   console.log(
     `Context type file written at: ${getRelativePath(rootDirectoryPath, contextTypeFilePath)}`,
@@ -565,7 +650,7 @@ ${attributeProperties}
   const hasSchemasFile = schemaKeys.length > 0;
   if (hasSchemasFile) {
     const schemasContent = generateSchemasFileContent(schemaKeys, schemasByKey);
-    const schemasFilePath = path.join(outputPath, "Schemas.ts");
+    const schemasFilePath = path.join(outputPath, "schemas.ts");
     fs.writeFileSync(schemasFilePath, schemasContent);
     console.log(
       `Schemas type file written at: ${getRelativePath(rootDirectoryPath, schemasFilePath)}`,
@@ -674,13 +759,10 @@ ${INDENT_NS}}`;
         }
       }
 
-      const schemasImportLine =
-        featureSchemaTypesUsed.size > 0
-          ? `import type { ${[...featureSchemaTypesUsed].sort().join(", ")} } from "./Schemas";\n\n`
-          : "";
+      const schemasImportLine = formatTypeImport([...featureSchemaTypesUsed].sort(), "./schemas");
 
       const featureContent = `
-import { Context } from "./Context";
+import { Context } from "./context";
 import { getInstance } from "./instance";
 ${schemasImportLine}export namespace ${namespaceValue} {
 ${INDENT_NS}export const key = "${featureKey}";${variableTypeDeclarations}
@@ -724,18 +806,22 @@ ${INDENT_NS}}${variableMethods}
             hasSchemasFile ? schemaTypeNames : undefined,
           );
           schemaTypesUsed.forEach((name) => featuresTypeSchemasUsed.add(name));
-          featureLines.push(`${INDENT_NS_BODY}${JSON.stringify(variableKey)}: ${typeName};`);
+          featureLines.push(`${INDENT_NS_BODY}${formatObjectKey(variableKey)}: ${typeName};`);
         }
       }
 
-      return `${INDENT_NS}${JSON.stringify(featureKey)}: {\n${featureLines.join("\n")}\n${INDENT_NS}};`;
+      if (featureLines.length === 0) {
+        return `${INDENT_NS}${formatObjectKey(featureKey)}: null;`;
+      }
+
+      return `${INDENT_NS}${formatObjectKey(featureKey)}: {\n${featureLines.join("\n")}\n${INDENT_NS}};`;
     })
     .join("\n");
 
-  const featuresSchemasImportLine =
-    featuresTypeSchemasUsed.size > 0
-      ? `import type { ${[...featuresTypeSchemasUsed].sort().join(", ")} } from "./Schemas";\n\n`
-      : "";
+  const featuresSchemasImportLine = formatTypeImport(
+    [...featuresTypeSchemasUsed].sort(),
+    "./schemas",
+  );
 
   const featuresFileContent = `
 ${featuresSchemasImportLine}export type Features = {
@@ -743,24 +829,33 @@ ${featureTypeEntries}
 };
 
 export type FeatureKey = keyof Features;
-export type VariableKey<F extends FeatureKey> = Extract<Exclude<keyof Features[F], "variation">, string>;
-export type VariableType<F extends FeatureKey, V extends VariableKey<F>> = Features[F][V];
-export type Variation<F extends FeatureKey> = Features[F] extends { variation: infer V } ? V : never;
+export type VariableKey<F extends FeatureKey> = Features[F] extends Record<string, unknown>
+  ? Extract<Exclude<keyof Features[F], "variation">, string>
+  : never;
+export type VariableType<F extends FeatureKey, V extends VariableKey<F>> = Features[F] extends Record<string, unknown>
+  ? Features[F][V]
+  : never;
+export type Variation<F extends FeatureKey> = Features[F] extends { variation: infer V }
+  ? V
+  : never;
 `.trimStart();
-  const featuresFilePath = path.join(outputPath, "Features.ts");
+  const featuresFilePath = path.join(outputPath, "features.ts");
   fs.writeFileSync(featuresFilePath, featuresFileContent);
   console.log(`Features file written at: ${getRelativePath(rootDirectoryPath, featuresFilePath)}`);
 
   const functionsFileContent = `
-import { FeatureKey, Variation, VariableKey, VariableType } from "./Features";
-import { Context } from "./Context";
+import { FeatureKey, Variation, VariableKey, VariableType } from "./features";
+import { Context } from "./context";
 import { getInstance } from "./instance";
 
 export function isEnabled(featureKey: FeatureKey, context: Context = {}): boolean {
   return getInstance().isEnabled(featureKey, context);
 }
 
-export function getVariation<F extends FeatureKey>(featureKey: F, context: Context = {}): Variation<F> | null {
+export function getVariation<F extends FeatureKey>(
+  featureKey: F,
+  context: Context = {},
+): Variation<F> | null {
   return getInstance().getVariation(featureKey, context) as Variation<F> | null;
 }
 
@@ -772,7 +867,7 @@ export function getVariable<F extends FeatureKey, V extends VariableKey<F>>(
   return getInstance().getVariable(featureKey, variableKey, context) as VariableType<F, V> | null;
 }
 `.trimStart();
-  const functionsFilePath = path.join(outputPath, "Functions.ts");
+  const functionsFilePath = path.join(outputPath, "functions.ts");
   fs.writeFileSync(functionsFilePath, functionsFileContent);
   console.log(
     `Functions file written at: ${getRelativePath(rootDirectoryPath, functionsFilePath)}`,
@@ -786,14 +881,17 @@ import {
   useVariable as useVariableOriginal,
 } from "@featurevisor/react";
 
-import { FeatureKey, Variation, VariableKey, VariableType } from "./Features";
-import { Context } from "./Context";
+import { FeatureKey, Variation, VariableKey, VariableType } from "./features";
+import { Context } from "./context";
 
 export function useFlag(featureKey: FeatureKey, context: Context = {}): boolean {
   return useFlagOriginal(featureKey, context);
 }
 
-export function useVariation<F extends FeatureKey>(featureKey: F, context: Context = {}): Variation<F> | null {
+export function useVariation<F extends FeatureKey>(
+  featureKey: F,
+  context: Context = {},
+): Variation<F> | null {
   return useVariationOriginal(featureKey, context) as Variation<F> | null;
 }
 
@@ -805,7 +903,7 @@ export function useVariable<F extends FeatureKey, V extends VariableKey<F>>(
   return useVariableOriginal(featureKey, variableKey, context) as VariableType<F, V> | null;
 }
 `.trimStart();
-    const reactFilePath = path.join(outputPath, "React.ts");
+    const reactFilePath = path.join(outputPath, "react.ts");
     fs.writeFileSync(reactFilePath, reactFileContent);
     console.log(`React file written at: ${getRelativePath(rootDirectoryPath, reactFilePath)}`);
   }
@@ -813,12 +911,12 @@ export function useVariable<F extends FeatureKey, V extends VariableKey<F>>(
   // index
   const indexContent =
     [
-      `export * from "./Context";`,
+      `export * from "./context";`,
       `export * from "./instance";`,
-      ...(hasSchemasFile ? [`export * from "./Schemas";`] : []),
-      `export * from "./Features";`,
-      `export * from "./Functions";`,
-      ...(shouldGenerateReact ? [`export * from "./React";`] : []),
+      ...(hasSchemasFile ? [`export * from "./schemas";`] : []),
+      `export * from "./features";`,
+      `export * from "./functions";`,
+      ...(shouldGenerateReact ? [`export * from "./react";`] : []),
       ...featureNamespaces.map((featureNamespace) => {
         return `export * from "./${featureNamespace}";`;
       }),

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: [],
                   });
                 }