@featurevisor/core 2.20.0 → 2.22.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@featurevisor/core",
-  "version": "2.20.0",
+  "version": "2.22.1",
   "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.20.0",
-    "@featurevisor/site": "2.20.0",
-    "@featurevisor/types": "2.20.0",
+    "@featurevisor/sdk": "2.21.0",
+    "@featurevisor/site": "2.22.1",
+    "@featurevisor/types": "2.21.0",
     "axios": "^1.3.4",
     "tar": "^7.5.7",
     "yaml": "^1.10.2",
     "yargs": "^17.7.2",
     "zod": "^3.22.4"
   },
-  "gitHead": "414ad2fdbb4520bf302dca781cdc8011abe312c4"
+  "gitHead": "e5b94a013197e1dfc94667470194db5cea7b4014"
 }

package/src/generate-code/typescript.spec.ts

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+import { getProjectConfig } from "../config/projectConfig";
+import { Datasource } from "../datasource";
+import { generateTypeScriptCodeForProject } from "./typescript";
+
+function createTempProjectFromExample1() {
+  const fixturePath = path.resolve(__dirname, "../../../../examples/example-1");
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "featurevisor-codegen-"));
+
+  fs.cpSync(fixturePath, tempRoot, { recursive: true });
+
+  return tempRoot;
+}
+
+describe("generate-code/typescript", () => {
+  let tempProjectPath: string;
+  let outputPath: string;
+
+  beforeEach(() => {
+    tempProjectPath = createTempProjectFromExample1();
+    outputPath = path.join(tempProjectPath, "generated");
+    fs.mkdirSync(outputPath, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(tempProjectPath, "attributes", "account.yml"),
+      [
+        "description: Account",
+        "type: object",
+        "required:",
+        "  - plan",
+        "properties:",
+        "  plan:",
+        "    type: string",
+        "    enum:",
+        "      - free",
+        "      - pro",
+        "  locale:",
+        "    type: string",
+      ].join("\n"),
+      "utf8",
+    );
+
+    fs.writeFileSync(
+      path.join(tempProjectPath, "attributes", "permissions.yml"),
+      [
+        "description: Permissions",
+        "type: array",
+        "items:",
+        "  type: string",
+        "  enum:",
+        "    - read",
+        "    - write",
+        "    - admin",
+      ].join("\n"),
+      "utf8",
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempProjectPath, { recursive: true, force: true });
+  });
+
+  it("generates schema-aware context types for attributes", async () => {
+    const projectConfig = getProjectConfig(tempProjectPath);
+    const datasource = new Datasource(projectConfig, tempProjectPath);
+
+    await generateTypeScriptCodeForProject(
+      {
+        rootDirectoryPath: tempProjectPath,
+        projectConfig,
+        datasource,
+        options: {},
+      } as any,
+      outputPath,
+      {},
+    );
+
+    const attributesContent = fs.readFileSync(path.join(outputPath, "attributes.ts"), "utf8");
+    const contextContent = fs.readFileSync(path.join(outputPath, "context.ts"), "utf8");
+    const indexContent = fs.readFileSync(path.join(outputPath, "index.ts"), "utf8");
+
+    expect(attributesContent).toContain(
+      'export type AccountAttribute = { plan: "free" | "pro"; locale?: string };',
+    );
+    expect(attributesContent).toContain(
+      'export type PermissionsAttribute = ("read" | "write" | "admin")[];',
+    );
+    expect(attributesContent).toContain("export type VersionAttribute = string | number;");
+    expect(attributesContent).toContain(
+      "export type BrowserAttribute = { name?: string; version?: string };",
+    );
+
+    expect(contextContent).toContain("import type {");
+    expect(contextContent).toContain("AccountAttribute,");
+    expect(contextContent).toContain("PermissionsAttribute,");
+    expect(contextContent).toContain("VersionAttribute,");
+    expect(contextContent).toContain('} from "./attributes";');
+    expect(contextContent).toContain("account?: AccountAttribute;");
+    expect(contextContent).toContain("permissions?: PermissionsAttribute;");
+    expect(contextContent).toContain("version?: VersionAttribute;");
+    expect(contextContent).toContain("browser?: BrowserAttribute;");
+
+    expect(indexContent).toContain('export * from "./attributes";');
+  });
+});

package/src/generate-code/typescript.ts

@@ -28,6 +28,8 @@ function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string): stri
       return "number";
     case "date":
       return "Date | string";
+    case "semver":
+      return "string";
     case "array":
       return "string[]";
     case "object":
@@ -170,7 +172,7 @@ function schemaToTypeScriptType(
     resolved.enum && Array.isArray(resolved.enum) && resolved.enum.length > 0
       ? enumToUnionType(resolved.enum)
       : null;
-  const type = resolved.type;
+  const type = resolved.type as string | undefined;
   if (!type) {
     return literalFromConst ?? unionFromEnum ?? "unknown";
   }
@@ -178,7 +180,10 @@ function schemaToTypeScriptType(
     case "boolean":
       return literalFromConst ?? unionFromEnum ?? "boolean";
     case "string":
+    case "semver":
       return literalFromConst ?? unionFromEnum ?? "string";
+    case "date":
+      return literalFromConst ?? unionFromEnum ?? "Date | string";
     case "integer":
     case "double":
       return literalFromConst ?? unionFromEnum ?? "number";
@@ -554,6 +559,29 @@ function generateSchemasFileContent(
   return lines.join("\n") + "\n";
 }
 
+function generateAttributesFileContent(
+  attributes: Array<Attribute & { key: string; typescriptType: string }>,
+  schemaTypeNames: Record<string, string>,
+): string {
+  const schemaTypesUsed = new Set<string>();
+
+  for (const attribute of attributes) {
+    Object.values(schemaTypeNames).forEach((typeName) => {
+      if (attribute.typescriptType.includes(typeName)) {
+        schemaTypesUsed.add(typeName);
+      }
+    });
+  }
+
+  const importLine = formatTypeImport(Array.from(schemaTypesUsed).sort(), "./schemas");
+  const lines = attributes.map((attribute) => {
+    const typeName = `${getPascalCase(attribute.key)}Attribute`;
+    return `export type ${typeName} = ${attribute.typescriptType};`;
+  });
+
+  return `${importLine}${lines.join("\n")}\n`;
+}
+
 // Indentation for generated namespace content (2 spaces per level)
 const INDENT_NS = "  ";
 const INDENT_NS_BODY = "    ";
@@ -588,6 +616,32 @@ export async function generateTypeScriptCodeForProject(
 
   console.log("\nGenerating TypeScript code...\n");
 
+  // Load schemas for resolving variable schema references
+  const schemaListKeys = await datasource.listSchemas();
+  const schemasByKey: Record<string, Schema> = {};
+  for (const key of schemaListKeys) {
+    try {
+      schemasByKey[key] = await datasource.readSchema(key);
+    } catch {
+      // Schema file may be invalid; skip for code gen
+    }
+  }
+  const schemaKeys = Object.keys(schemasByKey);
+  const hasSchemasFile = schemaKeys.length > 0;
+  if (hasSchemasFile) {
+    const schemasContent = generateSchemasFileContent(schemaKeys, schemasByKey);
+    const schemasFilePath = path.join(outputPath, "schemas.ts");
+    fs.writeFileSync(schemasFilePath, schemasContent);
+    console.log(
+      `Schemas type file written at: ${getRelativePath(rootDirectoryPath, schemasFilePath)}`,
+    );
+  }
+
+  const schemaTypeNames: Record<string, string> = {};
+  for (const k of schemaKeys) {
+    schemaTypeNames[k] = getPascalCase(k) + "Schema";
+  }
+
   // instance
   const instanceFilePath = path.join(outputPath, "instance.ts");
   fs.writeFileSync(instanceFilePath, instanceSnippet);
@@ -595,7 +649,8 @@ export async function generateTypeScriptCodeForProject(
 
   // attributes
   const attributeFiles = await datasource.listAttributes();
-  const attributes: (Attribute & { typescriptType })[] = [];
+  const attributes: (Attribute & { typescriptType: string })[] = [];
+  const attributeTypeNames: Record<string, string> = {};
 
   for (const attributeKey of attributeFiles) {
     const parsedAttribute = await datasource.readAttribute(attributeKey);
@@ -604,24 +659,40 @@ export async function generateTypeScriptCodeForProject(
       continue;
     }
 
+    const typescriptType = schemaToTypeScriptType(
+      parsedAttribute as Schema,
+      schemasByKey,
+      hasSchemasFile ? schemaTypeNames : undefined,
+    );
+
     attributes.push({
-      archived: parsedAttribute.archived,
+      ...parsedAttribute,
       key: attributeKey,
-      type: parsedAttribute.type,
-      typescriptType: convertFeaturevisorTypeToTypeScriptType(parsedAttribute.type),
+      typescriptType,
     });
+    attributeTypeNames[attributeKey] = `${getPascalCase(attributeKey)}Attribute`;
   }
 
+  const attributesFileContent = generateAttributesFileContent(
+    attributes as Array<Attribute & { key: string; typescriptType: string }>,
+    hasSchemasFile ? schemaTypeNames : {},
+  );
+  const attributesFilePath = path.join(outputPath, "attributes.ts");
+  fs.writeFileSync(attributesFilePath, attributesFileContent);
+  console.log(
+    `Attributes type file written at: ${getRelativePath(rootDirectoryPath, attributesFilePath)}`,
+  );
+
   // context
+  const contextImport = formatTypeImport(Object.values(attributeTypeNames).sort(), "./attributes");
   const attributeProperties = attributes
     .map((attribute) => {
-      return `  ${attribute.key}?: ${attribute.typescriptType};`;
+      return `  ${formatObjectKey(attribute.key)}?: ${attributeTypeNames[attribute.key]};`;
     })
     .join("\n");
   const contextContent = `
 import type { AttributeKey, AttributeValue } from "@featurevisor/sdk";
-
-export interface Context {
+${contextImport}export interface Context {
 ${attributeProperties}
   [key: AttributeKey]: AttributeValue;
 }
@@ -636,32 +707,6 @@ ${attributeProperties}
   // features
   const featureFiles = await datasource.listFeatures();
 
-  // Load schemas for resolving variable schema references
-  const schemaListKeys = await datasource.listSchemas();
-  const schemasByKey: Record<string, Schema> = {};
-  for (const key of schemaListKeys) {
-    try {
-      schemasByKey[key] = await datasource.readSchema(key);
-    } catch {
-      // Schema file may be invalid; skip for code gen
-    }
-  }
-  const schemaKeys = Object.keys(schemasByKey);
-  const hasSchemasFile = schemaKeys.length > 0;
-  if (hasSchemasFile) {
-    const schemasContent = generateSchemasFileContent(schemaKeys, schemasByKey);
-    const schemasFilePath = path.join(outputPath, "schemas.ts");
-    fs.writeFileSync(schemasFilePath, schemasContent);
-    console.log(
-      `Schemas type file written at: ${getRelativePath(rootDirectoryPath, schemasFilePath)}`,
-    );
-  }
-
-  const schemaTypeNames: Record<string, string> = {};
-  for (const k of schemaKeys) {
-    schemaTypeNames[k] = getPascalCase(k) + "Schema";
-  }
-
   const parsedFeatures: {
     featureKey: string;
     parsedFeature: ParsedFeature;
@@ -911,6 +956,7 @@ export function useVariable<F extends FeatureKey, V extends VariableKey<F>>(
   // index
   const indexContent =
     [
+      `export * from "./attributes";`,
       `export * from "./context";`,
       `export * from "./instance";`,
       ...(hasSchemasFile ? [`export * from "./schemas";`] : []),

package/src/linter/attributeSchema.spec.ts

@@ -0,0 +1,342 @@
+import { z } from "zod";
+
+import { getAttributeZodSchema } from "./attributeSchema";
+
+function parseAttribute(input: unknown): z.SafeParseReturnType<unknown, unknown> {
+  return getAttributeZodSchema().safeParse(input);
+}
+
+function expectAttributeSuccess(input: unknown): void {
+  const result = parseAttribute(input);
+  expect(result.success).toBe(true);
+  if (!result.success) {
+    const error = (result as z.SafeParseError<unknown>).error;
+    const msg = error.issues.map((issue) => issue.message).join("; ");
+    throw new Error(`Expected attribute to pass: ${msg}`);
+  }
+}
+
+function expectAttributeFailure(input: unknown, messageSubstring?: string): z.ZodError {
+  const result = parseAttribute(input);
+  expect(result.success).toBe(false);
+  if (result.success) {
+    throw new Error("Expected attribute to fail");
+  }
+
+  const error = (result as z.SafeParseError<unknown>).error;
+
+  if (messageSubstring) {
+    const messages = error.issues.map((issue) => issue.message).join(" ");
+    expect(messages).toContain(messageSubstring);
+  }
+
+  return error;
+}
+
+describe("attributeSchema.ts :: getAttributeZodSchema", () => {
+  it("accepts flat object attributes without additional schema details", () => {
+    expectAttributeSuccess({
+      description: "Traits",
+      type: "object",
+    });
+  });
+
+  it("accepts flat object properties and typed arrays", () => {
+    expectAttributeSuccess({
+      description: "Account",
+      type: "object",
+      required: ["plan"],
+      properties: {
+        plan: {
+          type: "string",
+          enum: ["free", "pro"],
+        },
+        locale: {
+          type: "string",
+        },
+        permissions: {
+          type: "array",
+          items: {
+            type: "string",
+            enum: ["read", "write", "admin"],
+          },
+        },
+      },
+    });
+  });
+
+  it("accepts array attributes without items when they stay flat", () => {
+    expectAttributeSuccess({
+      description: "Tags",
+      type: "array",
+    });
+  });
+
+  it("accepts string-array enums on array attributes", () => {
+    expectAttributeSuccess({
+      description: "Permissions",
+      type: "array",
+      items: {
+        type: "string",
+      },
+      enum: [["read"], ["write", "admin"]],
+    });
+  });
+
+  it("accepts top-level oneOf attributes without type", () => {
+    expectAttributeSuccess({
+      description: "Version number of the app",
+      oneOf: [{ type: "string" }, { type: "double" }],
+    });
+  });
+
+  it("accepts top-level oneOf attributes with branch-specific enums", () => {
+    expectAttributeSuccess({
+      description: "Plan or score",
+      oneOf: [
+        { type: "string", enum: ["free", "pro"] },
+        { type: "double", minimum: 0 },
+      ],
+    });
+  });
+
+  it("requires items when array schema adds extra constraints", () => {
+    expectAttributeFailure(
+      {
+        description: "Permissions",
+        type: "array",
+        enum: [["read"], ["write"]],
+      },
+      "`items` is required",
+    );
+  });
+
+  it("rejects attributes without top-level type or oneOf", () => {
+    expectAttributeFailure(
+      {
+        description: "Country",
+      },
+      "either `type` or `oneOf`",
+    );
+  });
+
+  it("rejects attributes with both top-level type and oneOf", () => {
+    expectAttributeFailure(
+      {
+        description: "Version number of the app",
+        type: "string",
+        oneOf: [{ type: "string" }, { type: "double" }],
+      },
+      "cannot have both `type` and `oneOf`",
+    );
+  });
+
+  it("rejects top-level oneOf attributes when a branch enum does not match its type", () => {
+    expectAttributeFailure(
+      {
+        description: "Plan or score",
+        oneOf: [{ type: "string", enum: ["free", 1] }, { type: "double" }],
+      },
+      'does not match type "string"',
+    );
+  });
+
+  it("rejects nested object properties inside object attributes", () => {
+    expectAttributeFailure(
+      {
+        description: "Account",
+        type: "object",
+        properties: {
+          metadata: {
+            type: "object",
+            properties: {
+              locale: {
+                type: "string",
+              },
+            },
+          },
+        },
+      },
+      "must stay flat",
+    );
+  });
+
+  it("rejects object additionalProperties that allow nested objects", () => {
+    expectAttributeFailure(
+      {
+        description: "Labels",
+        type: "object",
+        additionalProperties: {
+          type: "object",
+          properties: {
+            locale: {
+              type: "string",
+            },
+          },
+        },
+      },
+      "must stay flat",
+    );
+  });
+
+  it("rejects object properties whose oneOf allows nested objects", () => {
+    expectAttributeFailure(
+      {
+        description: "Account",
+        type: "object",
+        properties: {
+          metadata: {
+            oneOf: [
+              { type: "string" },
+              {
+                type: "object",
+                properties: {
+                  locale: {
+                    type: "string",
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+      "must stay flat",
+    );
+  });
+
+  it("rejects object additionalProperties whose oneOf allows nested objects", () => {
+    expectAttributeFailure(
+      {
+        description: "Labels",
+        type: "object",
+        additionalProperties: {
+          oneOf: [
+            { type: "string" },
+            {
+              type: "object",
+              properties: {
+                locale: {
+                  type: "string",
+                },
+              },
+            },
+          ],
+        },
+      },
+      "must stay flat",
+    );
+  });
+
+  it("rejects non-string item types for array attributes", () => {
+    expectAttributeFailure(
+      {
+        description: "Scores",
+        type: "array",
+        items: {
+          type: "integer",
+        },
+      },
+      "items.type",
+    );
+  });
+
+  it("rejects non-string enum values for array attributes", () => {
+    expectAttributeFailure(
+      {
+        description: "Scores",
+        type: "array",
+        enum: [[1, 2]],
+      },
+      "array of strings",
+    );
+  });
+
+  it("rejects non-string const values for array attributes", () => {
+    expectAttributeFailure(
+      {
+        description: "Scores",
+        type: "array",
+        items: {
+          type: "string",
+        },
+        const: [1, 2],
+      },
+      "array of strings",
+    );
+  });
+
+  it("rejects required keys that are not declared in properties", () => {
+    expectAttributeFailure(
+      {
+        description: "Account",
+        type: "object",
+        required: ["plan", "tier"],
+        properties: {
+          plan: {
+            type: "string",
+          },
+        },
+      },
+      "Unknown required field",
+    );
+  });
+
+  it("accepts required keys on flat object attributes without declared properties", () => {
+    expectAttributeSuccess({
+      description: "Traits",
+      type: "object",
+      required: ["plan"],
+    });
+  });
+
+  it("rejects enum values that do not match semver/date string-like types", () => {
+    expectAttributeFailure(
+      {
+        description: "Browser version",
+        type: "semver",
+        enum: ["1.0.0", 2],
+      },
+      'does not match type "semver"',
+    );
+  });
+
+  it("rejects minimum values greater than maximum for numeric attributes", () => {
+    expectAttributeFailure(
+      {
+        description: "Score",
+        type: "double",
+        minimum: 10,
+        maximum: 5,
+      },
+      "minimum",
+    );
+  });
+
+  it("rejects minLength values greater than maxLength for string attributes", () => {
+    expectAttributeFailure(
+      {
+        description: "Country",
+        type: "string",
+        minLength: 5,
+        maxLength: 2,
+      },
+      "minLength",
+    );
+  });
+
+  it("rejects invalid string patterns nested under object properties", () => {
+    expectAttributeFailure(
+      {
+        description: "Profile",
+        type: "object",
+        properties: {
+          email: {
+            type: "string",
+            pattern: "[",
+          },
+        },
+      },
+      "valid ECMA-262",
+    );
+  });
+});