flaglint 0.4.0 → 0.5.0

package/dist/chunk-MJLXM6GZ.js

@@ -0,0 +1,263 @@
+#!/usr/bin/env node
+
+// src/migrator/apply.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { parse } from "@typescript-eslint/typescript-estree";
+import micromatch from "micromatch";
+function moduleSpecifierMatchesGlob(specifier, pattern) {
+  const normalizeRelative = (value) => value.replace(/^(?:\.\.?\/)+/, "");
+  const normalizedSpecifier = normalizeRelative(specifier);
+  const normalizedPattern = normalizeRelative(pattern);
+  if (micromatch.isMatch(normalizedSpecifier, normalizedPattern)) return true;
+  if (!normalizedSpecifier.endsWith(".js")) return false;
+  return micromatch.isMatch(normalizedSpecifier.slice(0, -3), normalizedPattern);
+}
+var execFileAsync = promisify(execFile);
+var ApplyError = class extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.kind = kind;
+    this.name = "ApplyError";
+  }
+  kind;
+};
+var OF_SERVER_SDK = "@openfeature/server-sdk";
+function tryParse(code) {
+  for (const jsx of [false, true]) {
+    try {
+      return parse(code, { jsx, comment: false });
+    } catch {
+    }
+  }
+  return null;
+}
+function walkNodes(root, visit) {
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop();
+    visit(node);
+    for (const val of Object.values(node)) {
+      if (Array.isArray(val)) {
+        for (const item of val) {
+          if (item !== null && typeof item === "object" && "type" in item) {
+            stack.push(item);
+          }
+        }
+      } else if (val !== null && typeof val === "object" && "type" in val) {
+        stack.push(val);
+      }
+    }
+  }
+}
+function getOpenFeatureClientBindingName(code, allowedBindings = []) {
+  const ast = tryParse(code);
+  if (!ast) return null;
+  const ofApiNames = /* @__PURE__ */ new Set();
+  for (const stmt of ast.body) {
+    if (stmt.type === "ImportDeclaration" && stmt.source.value === OF_SERVER_SDK) {
+      for (const spec of stmt.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+          if (importedName === "OpenFeature") {
+            ofApiNames.add(spec.local.name);
+          }
+        }
+      }
+      continue;
+    }
+    if (stmt.type === "VariableDeclaration") {
+      for (const decl of stmt.declarations) {
+        const init = decl.init;
+        if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "require" && init.arguments.length === 1 && init.arguments[0]?.type === "Literal" && init.arguments[0].value === OF_SERVER_SDK && decl.id.type === "ObjectPattern") {
+          for (const prop of decl.id.properties) {
+            if (prop.type === "Property" && prop.key.type === "Identifier" && prop.key.name === "OpenFeature" && prop.value.type === "Identifier") {
+              ofApiNames.add(prop.value.name);
+            }
+          }
+        }
+      }
+    }
+  }
+  const candidates = [];
+  walkNodes(ast, (node) => {
+    if (node.type !== "VariableDeclarator") return;
+    const decl = node;
+    if (decl.id.type !== "Identifier") return;
+    if (decl.init?.type !== "CallExpression") return;
+    const call = decl.init;
+    if (call.callee.type !== "MemberExpression") return;
+    const member = call.callee;
+    if (member.computed) return;
+    if (member.object.type !== "Identifier") return;
+    if (!ofApiNames.has(member.object.name)) return;
+    if (member.property.type !== "Identifier") return;
+    if (member.property.name !== "getClient") return;
+    candidates.push(decl.id.name);
+  });
+  if (candidates.length === 1) return candidates[0];
+  if (candidates.length > 1) return null;
+  for (const stmt of ast.body) {
+    if (stmt.type === "ImportDeclaration") {
+      const source = String(stmt.source.value || "");
+      if (!source.startsWith(".")) continue;
+      for (const spec of stmt.specifiers) {
+        if (spec.type === "ImportSpecifier") {
+          const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+          const allowed = allowedBindings.find((b) => b.importName === importedName);
+          if (!allowed) continue;
+          if (!allowed.modulePatterns.some((p) => moduleSpecifierMatchesGlob(source, p))) continue;
+          candidates.push(spec.local.name);
+        }
+        if (spec.type === "ImportDefaultSpecifier") {
+          const local = spec.local.name;
+          const allowed = allowedBindings.find((b) => b.importName === local);
+          if (!allowed) continue;
+          if (!allowed.modulePatterns.some((p) => moduleSpecifierMatchesGlob(source, p))) continue;
+          candidates.push(local);
+        }
+      }
+    }
+    if (stmt.type === "VariableDeclaration") {
+      for (const decl of stmt.declarations) {
+        const init = decl.init;
+        if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "require" && init.arguments.length === 1 && init.arguments[0]?.type === "Literal") {
+          const source = String(init.arguments[0].value || "");
+          if (!source.startsWith(".")) continue;
+          if (decl.id.type === "ObjectPattern") {
+            for (const prop of decl.id.properties) {
+              if (prop.type !== "Property" || prop.key.type !== "Identifier") continue;
+              const importedName = prop.key.name;
+              const local = prop.value.type === "Identifier" ? prop.value.name : null;
+              if (!local) continue;
+              const allowed = allowedBindings.find((b) => b.importName === importedName);
+              if (!allowed) continue;
+              if (!allowed.modulePatterns.some((p) => moduleSpecifierMatchesGlob(source, p))) continue;
+              candidates.push(local);
+            }
+          }
+        }
+      }
+    }
+  }
+  if (candidates.length === 1) return candidates[0];
+  return null;
+}
+function hasOpenFeatureClientBinding(code) {
+  return getOpenFeatureClientBindingName(code) != null;
+}
+var DETAIL_METHODS = /* @__PURE__ */ new Set([
+  "variationDetail",
+  "boolVariationDetail",
+  "stringVariationDetail",
+  "numberVariationDetail",
+  "jsonVariationDetail"
+]);
+function methodForType(valueType) {
+  switch (valueType) {
+    case "boolean":
+      return "getBooleanValue";
+    case "string":
+      return "getStringValue";
+    case "number":
+      return "getNumberValue";
+    case "object":
+      return "getObjectValue";
+    case "unknown":
+      return null;
+  }
+}
+function buildReplacement(item, code, clientBindingName) {
+  if (DETAIL_METHODS.has(item.launchDarklyMethod)) {
+    return {
+      item,
+      reason: "detail methods skipped: OpenFeature detail APIs exist, but LaunchDarkly/OpenFeature detail result parity requires manual review"
+    };
+  }
+  if (!item.safelyAutomatable) {
+    const reason = item.manualReviewReason === "dynamic-key" ? "dynamic key requires manual review" : item.manualReviewReason === "unknown-fallback" ? "unknown fallback type requires manual review" : item.manualReviewReason === "bulk-inventory-call" ? "bulk inventory call has no single-flag codemod" : "manual review required";
+    return { item, reason };
+  }
+  if (item.rangeStart == null || item.rangeEnd == null || !item.callExpression) {
+    return { item, reason: "missing source range for apply" };
+  }
+  const currentText = code.slice(item.rangeStart, item.rangeEnd);
+  if (currentText !== item.callExpression) {
+    return {
+      item,
+      reason: "range content does not match original call \u2014 already transformed or stale analysis; skipping"
+    };
+  }
+  if (!item.flagKeyExpression || !item.fallbackExpression || !item.evaluationContextExpression) {
+    return { item, reason: "missing flag key, fallback, or evaluation context evidence" };
+  }
+  const method = methodForType(item.valueType);
+  if (!method) return { item, reason: "unsupported or unknown value type" };
+  const call = `${clientBindingName}.${method}(${item.flagKeyExpression}, ${item.fallbackExpression}, ${item.evaluationContextExpression})`;
+  return { item, replacement: call };
+}
+function applyReplacements(code, replacements) {
+  let next = code;
+  for (const r of [...replacements].sort((a, b) => b.item.rangeStart - a.item.rangeStart)) {
+    next = next.slice(0, r.item.rangeStart) + r.replacement + next.slice(r.item.rangeEnd);
+  }
+  return next;
+}
+async function defaultIsWorkingTreeDirty() {
+  try {
+    const { stdout } = await execFileAsync("git", ["status", "--porcelain"]);
+    return stdout.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function applyMigration(analysis, source, options = {}) {
+  if (!options.allowDirty) {
+    const checkDirty = options.isWorkingTreeDirty ?? defaultIsWorkingTreeDirty;
+    if (await checkDirty()) {
+      throw new ApplyError(
+        "dirty-tree",
+        "Working tree has uncommitted changes.\nCommit or stash your changes first, or pass --allow-dirty to override.\nReview `flaglint migrate --dry-run` for provider setup guidance before applying."
+      );
+    }
+  }
+  const itemsByFile = /* @__PURE__ */ new Map();
+  for (const item of analysis.inventoryItems) {
+    if (!itemsByFile.has(item.file)) itemsByFile.set(item.file, []);
+    itemsByFile.get(item.file).push(item);
+  }
+  const transformedFiles = [];
+  const skippedFiles = [];
+  let transformed = 0;
+  for (const [file, items] of [...itemsByFile.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    const code = await source.readFile(file);
+    const bindingName = getOpenFeatureClientBindingName(code, options.allowedOpenFeatureClientBindings ?? []);
+    if (!bindingName) {
+      skippedFiles.push({
+        file,
+        reason: "skipped \u2014 OpenFeature client setup required. Review `flaglint migrate --dry-run` provider guidance first."
+      });
+      continue;
+    }
+    const replacements = [];
+    for (const item of items) {
+      const result = buildReplacement(item, code, bindingName);
+      if ("reason" in result) continue;
+      replacements.push(result);
+    }
+    if (replacements.length === 0) continue;
+    const newCode = applyReplacements(code, replacements);
+    if (newCode === code) continue;
+    await source.writeFile(file, newCode);
+    transformedFiles.push(file);
+    transformed += replacements.length;
+  }
+  return { transformed, skipped: skippedFiles.length, transformedFiles, skippedFiles };
+}
+
+export {
+  ApplyError,
+  getOpenFeatureClientBindingName,
+  hasOpenFeatureClientBinding,
+  applyMigration
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flaglint",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "LaunchDarkly Node.js server SDK -> OpenFeature migration.",
   "type": "module",
   "bin": {
@@ -13,7 +13,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=22"
+    "node": ">=20"
   },
   "keywords": [
     "feature-flags",
@@ -39,8 +39,11 @@
     "dev": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "typecheck:agent": "tsc --project tsconfig.agent.json",
+    "pretest": "npm run build",
     "test": "vitest",
+    "pretest:run": "npm run build",
     "test:run": "vitest run",
+    "pretest:coverage": "npm run build",
     "test:coverage": "vitest run --coverage",
     "new-branch": "tsx scripts/new-branch.ts",
     "release:patch": "tsx scripts/release.ts patch",
@@ -53,11 +56,13 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "fast-glob": "^3.3.2",
+    "micromatch": "^4.0.8",
     "ora": "^8.1.0",
     "p-limit": "^7.3.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@types/micromatch": "^4.0.10",
     "@types/node": "^22.0.0",
     "@vitest/coverage-v8": "^4.1.6",
     "clipboardy": "^4.0.0",