@featurevisor/core 2.13.0 → 2.14.0

package/src/builder/mutator.ts

@@ -0,0 +1,237 @@
+import type { VariableSchema, VariableValue } from "@featurevisor/types";
+
+export type PathPart =
+  | { key: string }
+  | { key: string; index: number }
+  | { key: string; selector: { prop: string; value: string } };
+
+export type MutationOperation = "set" | "append" | "prepend" | "after" | "before" | "remove";
+
+export interface ParsedNotation {
+  segments: PathPart[];
+  operation: MutationOperation;
+}
+
+export function parseNotation(notation: string): ParsedNotation {
+  let rest = notation.trim();
+  const operationMatch = rest.match(/:((?:append|prepend|after|before|remove))$/);
+  const operation: MutationOperation = operationMatch
+    ? (operationMatch[1] as MutationOperation)
+    : "set";
+  if (operationMatch) {
+    rest = rest.slice(0, -operationMatch[0].length);
+  }
+
+  const segments: PathPart[] = [];
+  let i = 0;
+  while (i < rest.length) {
+    let key = "";
+    while (i < rest.length && rest[i] !== "." && rest[i] !== "[") {
+      key += rest[i];
+      i++;
+    }
+    key = key.trim();
+    if (key) {
+      if (rest[i] === "[") {
+        i++;
+        const bracketStart = i;
+        while (i < rest.length && rest[i] !== "]") i++;
+        const bracketContent = rest.slice(bracketStart, i);
+        i++;
+        const eq = bracketContent.indexOf("=");
+        if (eq >= 0) {
+          const prop = bracketContent.slice(0, eq).trim();
+          let val = bracketContent.slice(eq + 1).trim();
+          if (val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
+          else if (val.startsWith("'") && val.endsWith("'")) val = val.slice(1, -1);
+          segments.push({ key, selector: { prop, value: val } });
+        } else {
+          const index = parseInt(bracketContent.trim(), 10);
+          segments.push({ key, index });
+        }
+      } else {
+        segments.push({ key });
+      }
+    } else if (rest[i] === "[") {
+      i++;
+      const bracketStart = i;
+      while (i < rest.length && rest[i] !== "]") i++;
+      const bracketContent = rest.slice(bracketStart, i);
+      i++;
+      const eq = bracketContent.indexOf("=");
+      if (eq >= 0) {
+        const prop = bracketContent.slice(0, eq).trim();
+        let val = bracketContent.slice(eq + 1).trim();
+        if (val.startsWith('"') && val.endsWith('"')) val = val.slice(1, -1);
+        else if (val.startsWith("'") && val.endsWith("'")) val = val.slice(1, -1);
+        segments.push({ key: "", selector: { prop, value: val } });
+      } else {
+        const index = parseInt(bracketContent.trim(), 10);
+        segments.push({ key: "", index });
+      }
+    }
+    if (rest[i] === ".") i++;
+  }
+
+  return { segments, operation };
+}
+
+function getAtSegment(obj: VariableValue, seg: PathPart): VariableValue {
+  if (obj === null || obj === undefined) return undefined;
+  const o = obj as Record<string, unknown>;
+  if ("index" in seg) {
+    const arr =
+      seg.key === ""
+        ? Array.isArray(obj)
+          ? obj
+          : undefined
+        : Array.isArray(obj)
+          ? obj
+          : (o[seg.key] as unknown[]);
+    if (!Array.isArray(arr)) return undefined;
+    return arr[seg.index] as VariableValue;
+  }
+  if ("selector" in seg) {
+    const arr =
+      seg.key === ""
+        ? Array.isArray(obj)
+          ? obj
+          : undefined
+        : Array.isArray(obj)
+          ? obj
+          : (o[seg.key] as unknown[]);
+    if (!Array.isArray(arr)) return undefined;
+    const { prop, value } = seg.selector;
+    const found = arr.find((item) => {
+      if (item === null || typeof item !== "object") return false;
+      const v = (item as Record<string, unknown>)[prop];
+      return String(v) === value;
+    });
+    return found as VariableValue;
+  }
+  return o[seg.key] as VariableValue;
+}
+
+function setAtSegment(
+  obj: Record<string, unknown> | unknown[],
+  seg: PathPart,
+  _value: VariableValue,
+  op: MutationOperation,
+  setValue: VariableValue | undefined,
+): void {
+  if ("index" in seg) {
+    const i = seg.index;
+    const arr =
+      seg.key === ""
+        ? Array.isArray(obj)
+          ? obj
+          : undefined
+        : Array.isArray(obj)
+          ? obj
+          : ((obj as Record<string, unknown>)[seg.key] as unknown[]);
+    if (!Array.isArray(arr)) return;
+    if (op === "remove") {
+      arr.splice(i, 1);
+      return;
+    }
+    if (op === "set") {
+      arr[i] = setValue;
+      return;
+    }
+    return;
+  }
+  if ("selector" in seg) {
+    const arr =
+      seg.key === ""
+        ? Array.isArray(obj)
+          ? obj
+          : undefined
+        : Array.isArray(obj)
+          ? obj
+          : ((obj as Record<string, unknown>)[seg.key] as unknown[]);
+    if (!Array.isArray(arr)) return;
+    const { prop, value: selVal } = seg.selector;
+    const numVal = /^\d+$/.test(selVal) ? parseInt(selVal, 10) : null;
+    const idx = arr.findIndex((item) => {
+      if (item === null || typeof item !== "object") return false;
+      const v = (item as Record<string, unknown>)[prop];
+      return String(v) === selVal || (numVal !== null && v === numVal);
+    });
+    if (idx < 0) return;
+    if (op === "remove") {
+      arr.splice(idx, 1);
+      return;
+    }
+    if (op === "after" && setValue !== undefined) {
+      arr.splice(idx + 1, 0, setValue);
+      return;
+    }
+    if (op === "before" && setValue !== undefined) {
+      arr.splice(idx, 0, setValue);
+      return;
+    }
+    return;
+  }
+  const key = seg.key;
+  const o = obj as Record<string, unknown>;
+  if (op === "remove") {
+    delete o[key];
+    return;
+  }
+  if (op === "append" && setValue !== undefined) {
+    const arr = (o[key] ?? []) as unknown[];
+    arr.push(setValue);
+    o[key] = arr;
+    return;
+  }
+  if (op === "prepend" && setValue !== undefined) {
+    const arr = (o[key] ?? []) as unknown[];
+    arr.unshift(setValue);
+    o[key] = arr;
+    return;
+  }
+  if (op === "set") {
+    o[key] = setValue as unknown;
+  }
+}
+
+export function mutate(
+  _schema: VariableSchema,
+  value: VariableValue,
+  notation: string,
+  setValue: VariableValue | undefined,
+): VariableValue {
+  if (value === null || value === undefined) return value;
+  const result = JSON.parse(JSON.stringify(value)) as VariableValue;
+
+  const { segments, operation } = parseNotation(notation);
+  if (segments.length === 0) {
+    if (Array.isArray(result) && setValue !== undefined) {
+      const arr = result as VariableValue[];
+      if (operation === "append") {
+        arr.push(setValue);
+        return result;
+      }
+      if (operation === "prepend") {
+        arr.unshift(setValue);
+        return result;
+      }
+    }
+    return result;
+  }
+
+  const last = segments[segments.length - 1];
+  const parentSegments = segments.slice(0, -1);
+
+  let container: Record<string, unknown> | unknown[] = result as
+    | Record<string, unknown>
+    | unknown[];
+  for (const seg of parentSegments) {
+    const next = getAtSegment(container as VariableValue, seg);
+    if (next === undefined) return result;
+    container = next as Record<string, unknown> | unknown[];
+  }
+
+  setAtSegment(container, last, undefined, operation, setValue);
+  return result;
+}

package/src/linter/featureSchema.spec.ts

@@ -166,6 +166,38 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
       );
     });
 
+    it("rejects variable with schema reference when schema could not be loaded (missing from schemasByKey)", () => {
+      const projectConfig = minimalProjectConfig();
+      const conditionsZodSchema = getConditionsZodSchema(projectConfig, TEST_ATTRIBUTES);
+      const schemaWithEmptySchemasByKey = getFeatureZodSchema(
+        projectConfig,
+        conditionsZodSchema,
+        TEST_ATTRIBUTES,
+        TEST_SEGMENTS,
+        TEST_FEATURES,
+        ["link"],
+        {},
+      );
+      const result = schemaWithEmptySchemasByKey.safeParse(
+        baseFeature({
+          variablesSchema: {
+            myLink: {
+              schema: "link",
+              defaultValue: { title: "Home", url: "/" },
+            },
+          },
+        }),
+      );
+      expect(result.success).toBe(false);
+      if (result.success) return;
+      const messages = (result as z.SafeParseError<unknown>).error.issues
+        .map((i) => (typeof i.message === "string" ? i.message : ""))
+        .join(" ");
+      expect(messages).toContain("could not be loaded");
+      expect(messages).toContain("link");
+      expect(messages).toContain("myLink");
+    });
+
     it("rejects variable with schema reference when defaultValue does not match schema", () => {
       expectParseFailure(
         baseFeature({
@@ -1215,4 +1247,154 @@ describe("featureSchema.ts :: getFeatureZodSchema (variablesSchema and variable
       );
     });
   });
+
+  describe("mutation notation in variables", () => {
+    it("accepts valid dot-notation mutation keys in rules.variables", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: {
+                theme: { type: "string" },
+                width: { type: "integer" },
+              },
+              defaultValue: { theme: "light", width: 100 },
+            },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variables: { "config.theme": "dark", "config.width": 1200 },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+      );
+    });
+
+    it("accepts valid array-index mutation keys in rules.variables", () => {
+      expectParseSuccess(
+        baseFeature({
+          variablesSchema: {
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              defaultValue: ["a", "b"],
+            },
+          },
+          rules: {
+            staging: [
+              { key: "r1", segments: "*", percentage: 100, variables: { "tags[0]": "first" } },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+      );
+    });
+
+    it("rejects mutation key when root variable is not in variablesSchema", () => {
+      expectErrorSurfaces(
+        baseFeature({
+          variablesSchema: {
+            title: { type: "string", defaultValue: "Default" },
+          },
+          rules: {
+            staging: [
+              { key: "r1", segments: "*", percentage: 100, variables: { "unknownVar.foo": "x" } },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        {
+          pathContains: ["rules", "variables", "unknownVar.foo"],
+          messageContains: "not defined in",
+        },
+      );
+    });
+
+    it("rejects invalid path (property not in schema)", () => {
+      expectErrorSurfaces(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: { theme: { type: "string" } },
+              defaultValue: { theme: "light" },
+            },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variables: { "config.unknownProp": "x" },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        { pathContains: ["rules", "variables"], messageContains: "path does not exist" },
+      );
+    });
+
+    it("rejects :append on non-array (object property)", () => {
+      expectErrorSurfaces(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: { theme: { type: "string" } },
+              defaultValue: { theme: "light" },
+            },
+          },
+          rules: {
+            staging: [
+              { key: "r1", segments: "*", percentage: 100, variables: { "config:append": "x" } },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        { pathContains: ["rules", "variables"], messageContains: "only allowed on array" },
+      );
+    });
+
+    it("rejects :remove on required object property", () => {
+      expectErrorSurfaces(
+        baseFeature({
+          variablesSchema: {
+            config: {
+              type: "object",
+              properties: {
+                theme: { type: "string" },
+                compact: { type: "boolean" },
+              },
+              required: ["compact"],
+              defaultValue: { theme: "light", compact: true },
+            },
+          },
+          rules: {
+            staging: [
+              {
+                key: "r1",
+                segments: "*",
+                percentage: 100,
+                variables: { "config.compact:remove": null },
+              },
+            ],
+            production: [{ key: "r1", segments: "*", percentage: 100 }],
+          },
+        }),
+        {
+          pathContains: ["rules", "variables"],
+          messageContains: "Cannot remove required property",
+        },
+      );
+    });
+  });
 });