@featurevisor/core 2.8.0 → 2.10.0

package/src/generate-code/typescript.ts

@@ -1,10 +1,10 @@
 import * as fs from "fs";
 import * as path from "path";
 
-import type { Attribute } from "@featurevisor/types";
+import type { Attribute, PropertySchema, VariableSchema } from "@featurevisor/types";
 import { Dependencies } from "../dependencies";
 
-function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
+function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string): string {
   switch (featurevisorType) {
     case "boolean":
       return "boolean";
@@ -19,14 +19,141 @@ function convertFeaturevisorTypeToTypeScriptType(featurevisorType: string) {
     case "array":
       return "string[]";
     case "object":
-      return "any"; // @NOTE: do a flat dictionary
+      return "Record<string, unknown>";
     case "json":
-      return "any";
+      return "unknown";
     default:
       throw new Error(`Unknown type: ${featurevisorType}`);
   }
 }
 
+/**
+ * Converts a PropertySchema (items or properties entry) to a TypeScript type string.
+ * Handles nested object/array with structured items and properties.
+ */
+function propertySchemaToTypeScriptType(schema: PropertySchema): string {
+  const type = schema.type;
+  if (!type) {
+    return "unknown";
+  }
+  switch (type) {
+    case "boolean":
+      return "boolean";
+    case "string":
+      return "string";
+    case "integer":
+    case "double":
+      return "number";
+    case "array":
+      if (schema.items) {
+        return `(${propertySchemaToTypeScriptType(schema.items)})[]`;
+      }
+      return "string[]";
+    case "object": {
+      const props = schema.properties;
+      if (props && typeof props === "object" && Object.keys(props).length > 0) {
+        const requiredSet = new Set(schema.required || []);
+        const entries = Object.entries(props)
+          .map(([k, v]) => {
+            const propType = propertySchemaToTypeScriptType(v);
+            const optional = requiredSet.size > 0 && !requiredSet.has(k);
+            return optional ? `${k}?: ${propType}` : `${k}: ${propType}`;
+          })
+          .join("; ");
+        return `{ ${entries} }`;
+      }
+      return "Record<string, unknown>";
+    }
+    default:
+      return "unknown";
+  }
+}
+
+/**
+ * Generates TypeScript type/interface declarations and metadata for a variable.
+ * Returns declarations to emit (interface or type alias) plus the type name and generic to use in the getter.
+ */
+function generateVariableTypeDeclarations(
+  variableKey: string,
+  variableSchema: VariableSchema,
+): { declarations: string[]; returnTypeName: string; genericArg: string } {
+  const typeName = getPascalCase(variableKey) + "Variable";
+  const itemTypeName = getPascalCase(variableKey) + "VariableItem";
+  const type = variableSchema.type;
+  const declarations: string[] = [];
+
+  if (type === "json") {
+    return { declarations: [], returnTypeName: "T", genericArg: "T" };
+  }
+
+  if (type === "object") {
+    const props = variableSchema.properties;
+    if (props && typeof props === "object" && Object.keys(props).length > 0) {
+      const requiredSet = new Set((variableSchema.required as string[]) || []);
+      const entries = Object.entries(props)
+        .map(([k, v]) => {
+          const propType = propertySchemaToTypeScriptType(v as PropertySchema);
+          const optional = requiredSet.size > 0 && !requiredSet.has(k);
+          return optional
+            ? `${INDENT_NS_BODY}${k}?: ${propType};`
+            : `${INDENT_NS_BODY}${k}: ${propType};`;
+        })
+        .join("\n");
+      declarations.push(`${INDENT_NS}export interface ${typeName} {\n${entries}\n${INDENT_NS}}`);
+      return { declarations, returnTypeName: typeName, genericArg: typeName };
+    }
+    declarations.push(`${INDENT_NS}export type ${typeName} = Record<string, unknown>;`);
+    return { declarations, returnTypeName: typeName, genericArg: typeName };
+  }
+
+  if (type === "array") {
+    if (variableSchema.items) {
+      const items = variableSchema.items as PropertySchema;
+      if (items.type === "object" && items.properties && Object.keys(items.properties).length > 0) {
+        const requiredSet = new Set(items.required || []);
+        const entries = Object.entries(items.properties)
+          .map(([k, v]) => {
+            const propType = propertySchemaToTypeScriptType(v);
+            const optional = requiredSet.size > 0 && !requiredSet.has(k);
+            return optional
+              ? `${INDENT_NS_BODY}${k}?: ${propType};`
+              : `${INDENT_NS_BODY}${k}: ${propType};`;
+          })
+          .join("\n");
+        declarations.push(
+          `${INDENT_NS}export interface ${itemTypeName} {\n${entries}\n${INDENT_NS}}`,
+        );
+        // getVariableArray<T> returns T[] | null, so generic is item type
+        return {
+          declarations,
+          returnTypeName: `${itemTypeName}[]`,
+          genericArg: itemTypeName,
+        };
+      }
+      // array of primitive (e.g. string): emit item type only, use item[] in methods
+      const itemType = propertySchemaToTypeScriptType(items);
+      declarations.push(`${INDENT_NS}export type ${itemTypeName} = ${itemType};`);
+      return {
+        declarations,
+        returnTypeName: `${itemTypeName}[]`,
+        genericArg: itemTypeName,
+      };
+    }
+    // array without items (default string[]): emit item type only
+    declarations.push(`${INDENT_NS}export type ${itemTypeName} = string;`);
+    return {
+      declarations,
+      returnTypeName: `${itemTypeName}[]`,
+      genericArg: itemTypeName,
+    };
+  }
+
+  // primitive: boolean, string, integer, double
+  const primitiveType = convertFeaturevisorTypeToTypeScriptType(type);
+  declarations.push(`${INDENT_NS}export type ${typeName} = ${primitiveType};`);
+  return { declarations, returnTypeName: typeName, genericArg: typeName };
+}
+
 function getPascalCase(str) {
   // Remove special characters and split the string into an array of words
   const words = str.replace(/[^a-zA-Z0-9]/g, " ").split(" ");
@@ -47,6 +174,10 @@ function getRelativePath(from, to) {
   return relativePath;
 }
 
+// Indentation for generated namespace content (2 spaces per level)
+const INDENT_NS = "  ";
+const INDENT_NS_BODY = "    ";
+
 const instanceSnippet = `
 import { FeaturevisorInstance } from "@featurevisor/sdk";
 
@@ -125,33 +256,52 @@ ${attributeProperties}
     const namespaceValue = getPascalCase(featureKey) + "Feature";
     featureNamespaces.push(namespaceValue);
 
+    let variableTypeDeclarations = "";
     let variableMethods = "";
 
     if (parsedFeature.variablesSchema) {
       const variableKeys = Object.keys(parsedFeature.variablesSchema);
+      const allDeclarations: string[] = [];
 
       for (const variableKey of variableKeys) {
         const variableSchema = parsedFeature.variablesSchema[variableKey];
         const variableType = variableSchema.type;
+        const { declarations, returnTypeName, genericArg } = generateVariableTypeDeclarations(
+          variableKey,
+          variableSchema,
+        );
+        allDeclarations.push(...declarations);
 
         const internalMethodName = `getVariable${
           variableType === "json" ? "JSON" : getPascalCase(variableType)
         }`;
 
-        if (variableType === "json" || variableType === "object") {
+        const hasGeneric =
+          variableType === "json" || variableType === "array" || variableType === "object";
+        if (variableType === "json") {
+          variableMethods += `
+
+${INDENT_NS}export function get${getPascalCase(variableKey)}<T = unknown>(context: Context = {}): T | null {
+${INDENT_NS_BODY}return getInstance().${internalMethodName}<T>(key, "${variableKey}", context);
+${INDENT_NS}}`;
+        } else if (hasGeneric) {
           variableMethods += `
 
-  export function get${getPascalCase(variableKey)}<T>(context: Context = {}) {
-    return getInstance().${internalMethodName}<T>(key, "${variableKey}", context);
-  }`;
+${INDENT_NS}export function get${getPascalCase(variableKey)}(context: Context = {}): ${returnTypeName} | null {
+${INDENT_NS_BODY}return getInstance().${internalMethodName}<${genericArg}>(key, "${variableKey}", context);
+${INDENT_NS}}`;
         } else {
           variableMethods += `
 
-  export function get${getPascalCase(variableKey)}(context: Context = {}) {
-    return getInstance().${internalMethodName}(key, "${variableKey}", context);
-  }`;
+${INDENT_NS}export function get${getPascalCase(variableKey)}(context: Context = {}): ${returnTypeName} | null {
+${INDENT_NS_BODY}return getInstance().${internalMethodName}(key, "${variableKey}", context);
+${INDENT_NS}}`;
         }
       }
+
+      if (allDeclarations.length > 0) {
+        variableTypeDeclarations = "\n\n" + allDeclarations.join("\n\n");
+      }
     }
 
     const featureContent = `
@@ -159,15 +309,15 @@ import { Context } from "./Context";
 import { getInstance } from "./instance";
 
 export namespace ${namespaceValue} {
-  export const key = "${featureKey}";
+${INDENT_NS}export const key = "${featureKey}";${variableTypeDeclarations}
 
-  export function isEnabled(context: Context = {}) {
-    return getInstance().isEnabled(key, context);
-  }
+${INDENT_NS}export function isEnabled(context: Context = {}) {
+${INDENT_NS_BODY}return getInstance().isEnabled(key, context);
+${INDENT_NS}}
 
-  export function getVariation(context: Context = {}) {
-    return getInstance().getVariation(key, context);
-  }${variableMethods}
+${INDENT_NS}export function getVariation(context: Context = {}) {
+${INDENT_NS_BODY}return getInstance().getVariation(key, context);
+${INDENT_NS}}${variableMethods}
 }
 `.trimStart();