openapi-typesafe-migrate 0.0.0 → 1.0.0-rc.1

package/dist/cli/main.mjs

@@ -0,0 +1,1096 @@
+import { mkdirSync, appendFileSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import ts from '@typescript/typescript6';
+import { parseArgs } from 'node:util';
+
+class JsonLinesLogger {
+  #options;
+  constructor(options) {
+    this.#options = options;
+    mkdirSync(dirname(options.path), { recursive: true });
+  }
+  info(event, fields = {}) {
+    this.#append("info", event, fields);
+  }
+  warn(event, fields = {}) {
+    this.#append("warn", event, fields);
+  }
+  #append(level, event, fields) {
+    const time = this.#options.now().toISOString();
+    appendFileSync(this.#options.path, `${JSON.stringify({ time, level, event, ...fields })}
+`);
+  }
+}
+function createJsonLinesLogger(options) {
+  return new JsonLinesLogger(options);
+}
+
+const SKIPPED_DIRECTORIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".svelte-kit",
+  ".turbo",
+  "coverage"
+]);
+async function listTree(root, relative) {
+  const entries = await readdir(join(root, relative), { withFileTypes: true });
+  const nested = await Promise.all(
+    entries.map((entry) => {
+      const path = relative === "" ? entry.name : `${relative}/${entry.name}`;
+      if (entry.isDirectory()) {
+        return SKIPPED_DIRECTORIES.has(entry.name) ? [] : listTree(root, path);
+      }
+      return entry.isFile() ? [path] : [];
+    })
+  );
+  return nested.flat();
+}
+class NodeProjectFiles {
+  #root;
+  constructor(root) {
+    this.#root = root;
+  }
+  listFiles() {
+    return listTree(this.#root, "");
+  }
+  read(path) {
+    return readFile(join(this.#root, path), "utf8");
+  }
+  write(path, text) {
+    return writeFile(join(this.#root, path), text, "utf8");
+  }
+}
+function createNodeProjectFiles(root) {
+  return new NodeProjectFiles(root);
+}
+
+function unchanged(text) {
+  return { text, changes: [], manualSteps: [] };
+}
+function lineAt(text, offset) {
+  let line = 1;
+  for (let index = text.indexOf("\n"); index !== -1 && index < offset; ) {
+    line++;
+    index = text.indexOf("\n", index + 1);
+  }
+  return line;
+}
+
+const GENERATOR_MODULES = /* @__PURE__ */ new Set(["openapi-typesafe", "openapi-typescript"]);
+const TYPESCRIPT_MODULES = /* @__PURE__ */ new Set(["typescript", "@typescript/typescript6"]);
+function namedImports(clause, into) {
+  const bindings = clause.namedBindings;
+  if (bindings === void 0 || !ts.isNamedImports(bindings)) {
+    return;
+  }
+  for (const element of bindings.elements) {
+    into.set(element.name.text, (element.propertyName ?? element.name).text);
+  }
+}
+function addTypescriptImport(clause, names) {
+  if (clause.name !== void 0) {
+    names.typescriptModules.add(clause.name.text);
+  }
+  const bindings = clause.namedBindings;
+  if (bindings !== void 0 && ts.isNamespaceImport(bindings)) {
+    names.typescriptModules.add(bindings.name.text);
+  }
+  namedImports(clause, names.typescriptImports);
+}
+function addGeneratorImport(clause, names) {
+  if (clause.name !== void 0) {
+    names.generatorFunctions.add(clause.name.text);
+  }
+  namedImports(clause, names.helperImports);
+}
+function addImport(statement, names) {
+  const clause = statement.importClause;
+  if (clause === void 0 || !ts.isStringLiteral(statement.moduleSpecifier)) {
+    return;
+  }
+  const specifier = statement.moduleSpecifier.text;
+  if (TYPESCRIPT_MODULES.has(specifier)) {
+    addTypescriptImport(clause, names);
+  } else if (GENERATOR_MODULES.has(specifier)) {
+    addGeneratorImport(clause, names);
+  }
+}
+function addConstants(statement, names) {
+  if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) {
+    return;
+  }
+  for (const declaration of statement.declarationList.declarations) {
+    const initializer = declaration.initializer;
+    if (!ts.isIdentifier(declaration.name) || initializer === void 0) {
+      continue;
+    }
+    names.constants.set(declaration.name.text, initializer);
+    if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) {
+      names.functions.set(declaration.name.text, initializer);
+    }
+  }
+}
+function collectFileNames(file) {
+  const names = {
+    typescriptModules: /* @__PURE__ */ new Set(),
+    typescriptImports: /* @__PURE__ */ new Map(),
+    helperImports: /* @__PURE__ */ new Map(),
+    constants: /* @__PURE__ */ new Map(),
+    generatorFunctions: /* @__PURE__ */ new Set(),
+    functions: /* @__PURE__ */ new Map()
+  };
+  for (const statement of file.statements) {
+    if (ts.isImportDeclaration(statement)) {
+      addImport(statement, names);
+    } else if (ts.isVariableStatement(statement)) {
+      addConstants(statement, names);
+    } else if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
+      names.functions.set(statement.name.text, statement);
+    }
+  }
+  return names;
+}
+
+const KEYWORDS = /* @__PURE__ */ new Map([
+  ["AnyKeyword", "any"],
+  ["BigIntKeyword", "bigint"],
+  ["BooleanKeyword", "boolean"],
+  ["NeverKeyword", "never"],
+  ["NumberKeyword", "number"],
+  ["ObjectKeyword", "object"],
+  ["StringKeyword", "string"],
+  ["SymbolKeyword", "symbol"],
+  ["UndefinedKeyword", "undefined"],
+  ["UnknownKeyword", "unknown"],
+  ["VoidKeyword", "void"]
+]);
+const HELPER_CONSTANTS = /* @__PURE__ */ new Map([
+  ["BOOLEAN", "boolean"],
+  ["FALSE", "false"],
+  ["NEVER", "never"],
+  ["NULL", "null"],
+  ["NUMBER", "number"],
+  ["STRING", "string"],
+  ["TRUE", "true"],
+  ["UNDEFINED", "undefined"],
+  ["UNKNOWN", "unknown"]
+]);
+const TYPE_NAME_RE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/;
+const plain = (text) => ({ text, operator: null });
+function factoryMethod(callee, names) {
+  if (!ts.isPropertyAccessExpression(callee)) {
+    return void 0;
+  }
+  const target = callee.expression;
+  const isFactory = ts.isIdentifier(target) ? names.typescriptImports.get(target.text) === "factory" : ts.isPropertyAccessExpression(target) && target.name.text === "factory" && ts.isIdentifier(target.expression) && names.typescriptModules.has(target.expression.text);
+  return isFactory ? callee.name.text : void 0;
+}
+function syntaxKindMember(expression, names) {
+  if (!ts.isPropertyAccessExpression(expression)) {
+    return void 0;
+  }
+  const target = expression.expression;
+  const isSyntaxKind = ts.isIdentifier(target) ? names.typescriptImports.get(target.text) === "SyntaxKind" : ts.isPropertyAccessExpression(target) && target.name.text === "SyntaxKind" && ts.isIdentifier(target.expression) && names.typescriptModules.has(target.expression.text);
+  return isSyntaxKind ? expression.name.text : void 0;
+}
+function typeName(argument, names) {
+  if (argument === void 0) {
+    return void 0;
+  }
+  if (ts.isStringLiteralLike(argument)) {
+    return TYPE_NAME_RE.test(argument.text) ? argument.text : void 0;
+  }
+  if (ts.isCallExpression(argument) && factoryMethod(argument.expression, names) === "createIdentifier") {
+    return typeName(argument.arguments[0], names);
+  }
+  return void 0;
+}
+function literalText(argument, names) {
+  if (argument === void 0 || !ts.isCallExpression(argument)) {
+    return void 0;
+  }
+  const method = factoryMethod(argument.expression, names);
+  const [value] = argument.arguments;
+  switch (method) {
+    case "createNull":
+      return "null";
+    case "createTrue":
+      return "true";
+    case "createFalse":
+      return "false";
+    case "createStringLiteral":
+      return value !== void 0 && ts.isStringLiteralLike(value) ? JSON.stringify(value.text) : void 0;
+    case "createNumericLiteral":
+      return value !== void 0 && (ts.isNumericLiteral(value) || ts.isStringLiteralLike(value)) ? String(Number(value.text)) : void 0;
+    default:
+      return void 0;
+  }
+}
+function joined(elements, operator, names) {
+  if (elements === void 0 || !ts.isArrayLiteralExpression(elements) || elements.elements.length === 0) {
+    return void 0;
+  }
+  const parts = elements.elements.map((element) => typeTextOf(element, names));
+  if (parts.some((part) => part === void 0)) {
+    return void 0;
+  }
+  const texts = parts.map(
+    (part) => operator === "&" && part.operator === "|" ? `(${part.text})` : part.text
+  );
+  return { text: texts.join(` ${operator} `), operator: texts.length > 1 ? operator : null };
+}
+function factoryCallText(call, method, names) {
+  const [first, second] = call.arguments;
+  switch (method) {
+    case "createTypeReferenceNode": {
+      const name = second === void 0 ? typeName(first, names) : void 0;
+      return name === void 0 ? void 0 : plain(name);
+    }
+    case "createKeywordTypeNode": {
+      const keyword = first === void 0 ? void 0 : KEYWORDS.get(syntaxKindMember(first, names) ?? "");
+      return keyword === void 0 ? void 0 : plain(keyword);
+    }
+    case "createLiteralTypeNode": {
+      const literal = literalText(first, names);
+      return literal === void 0 ? void 0 : plain(literal);
+    }
+    case "createUnionTypeNode":
+      return joined(first, "|", names);
+    case "createIntersectionTypeNode":
+      return joined(first, "&", names);
+    case "createArrayTypeNode": {
+      const element = first === void 0 ? void 0 : typeTextOf(first, names);
+      return element === void 0 ? void 0 : plain(element.operator ? `(${element.text})[]` : `${element.text}[]`);
+    }
+    default:
+      return void 0;
+  }
+}
+function helperCallText(call, names) {
+  if (!ts.isIdentifier(call.expression)) {
+    return void 0;
+  }
+  const helper = names.helperImports.get(call.expression.text);
+  if (helper === "tsUnion") {
+    return joined(call.arguments[0], "|", names);
+  }
+  return helper === "tsIntersection" ? joined(call.arguments[0], "&", names) : void 0;
+}
+function identifierText(identifier, names) {
+  const helper = names.helperImports.get(identifier.text);
+  const constant = helper === void 0 ? void 0 : HELPER_CONSTANTS.get(helper);
+  if (constant !== void 0) {
+    return plain(constant);
+  }
+  const initializer = names.constants.get(identifier.text);
+  return initializer === void 0 ? void 0 : typeTextOf(initializer, names);
+}
+function typeTextOf(expression, names) {
+  if (ts.isParenthesizedExpression(expression)) {
+    return typeTextOf(expression.expression, names);
+  }
+  if (ts.isIdentifier(expression)) {
+    return identifierText(expression, names);
+  }
+  if (!ts.isCallExpression(expression)) {
+    return void 0;
+  }
+  const method = factoryMethod(expression.expression, names);
+  return method === void 0 ? helperCallText(expression, names) : factoryCallText(expression, method, names);
+}
+
+function returnedExpressions(body) {
+  if (!ts.isBlock(body)) {
+    return [body];
+  }
+  const returned = [];
+  const visit = (node) => {
+    if (ts.isFunctionLike(node) || ts.isClassLike(node)) {
+      return;
+    }
+    if (ts.isReturnStatement(node)) {
+      returned.push(node.expression);
+    }
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(body, visit);
+  return returned;
+}
+const isUndefined = (expression) => ts.isIdentifier(expression) && expression.text === "undefined" || ts.isVoidExpression(expression);
+function typeTextEdit(expression, names) {
+  const typeText = typeTextOf(expression, names);
+  if (typeText === void 0) {
+    return void 0;
+  }
+  const start = expression.getStart();
+  return [{ start, end: expression.getEnd(), text: JSON.stringify(typeText.text) }];
+}
+function resultObjectEdits(object, names) {
+  const schema = object.properties.find(
+    (property) => property.name !== void 0 && ts.isIdentifier(property.name) && property.name.text === "schema"
+  );
+  const isPlain = object.properties.every(ts.isPropertyAssignment);
+  if (schema === void 0 || !isPlain || !ts.isPropertyAssignment(schema)) {
+    return void 0;
+  }
+  return typeTextEdit(schema.initializer, names);
+}
+function returnEdits(expression, names) {
+  if (expression === void 0 || isUndefined(expression)) {
+    return [];
+  }
+  if (ts.isParenthesizedExpression(expression)) {
+    return returnEdits(expression.expression, names);
+  }
+  if (ts.isConditionalExpression(expression)) {
+    const whenTrue = returnEdits(expression.whenTrue, names);
+    const whenFalse = returnEdits(expression.whenFalse, names);
+    return whenTrue === void 0 || whenFalse === void 0 ? void 0 : [...whenTrue, ...whenFalse];
+  }
+  if (ts.isObjectLiteralExpression(expression)) {
+    return resultObjectEdits(expression, names);
+  }
+  return typeTextEdit(expression, names);
+}
+
+const TRANSFORM = "transform";
+const LEGACY_ONLY_CALLBACKS = ["postTransform", "transformProperty"];
+const IR_CALLBACKS_OPTION = "irCallbacks";
+const SCRIPT_KINDS = /* @__PURE__ */ new Map([
+  [".ts", ts.ScriptKind.TS],
+  [".mts", ts.ScriptKind.TS],
+  [".cts", ts.ScriptKind.TS],
+  [".tsx", ts.ScriptKind.TSX],
+  [".js", ts.ScriptKind.JS],
+  [".mjs", ts.ScriptKind.JS],
+  [".cjs", ts.ScriptKind.JS],
+  [".jsx", ts.ScriptKind.JSX]
+]);
+function scriptKindOf(path) {
+  return SCRIPT_KINDS.get(path.slice(path.lastIndexOf(".")));
+}
+function propertyNamed(options, name) {
+  return options.properties.find((property) => {
+    const key = property.name;
+    return key !== void 0 && (ts.isIdentifier(key) || ts.isStringLiteral(key)) && key.text === name;
+  });
+}
+function callbackFunction(property, names) {
+  if (ts.isMethodDeclaration(property)) {
+    return property;
+  }
+  if (!ts.isPropertyAssignment(property)) {
+    return void 0;
+  }
+  const value = property.initializer;
+  if (ts.isIdentifier(value)) {
+    return names.functions.get(value.text);
+  }
+  return ts.isArrowFunction(value) || ts.isFunctionExpression(value) ? value : void 0;
+}
+function isSharedFunction(property, text) {
+  if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.initializer)) {
+    return false;
+  }
+  const name = property.initializer.text.replaceAll("$", "\\$");
+  const uses = text.match(new RegExp(`(?<![\\w$])${name}(?![\\w$])`, "g")) ?? [];
+  return uses.length > 2;
+}
+function returnTypeEdits(callback, text) {
+  const type = callback.type;
+  if (type === void 0) {
+    return [];
+  }
+  const colon = text.lastIndexOf(":", type.getStart());
+  return [{ start: colon, end: type.getEnd(), text: "" }];
+}
+function transformEdits(property, names, text) {
+  const callback = callbackFunction(property, names);
+  if (callback?.body === void 0) {
+    return "not-a-function";
+  }
+  if (isSharedFunction(property, text)) {
+    return "shared-function";
+  }
+  const edits = returnTypeEdits(callback, text);
+  for (const returned of returnedExpressions(callback.body)) {
+    const returnEditList = returnEdits(returned, names);
+    if (returnEditList === void 0) {
+      return "unknown-return";
+    }
+    edits.push(...returnEditList);
+  }
+  return edits;
+}
+function irCallbacksOption(text, transformStart) {
+  const lineStart = text.lastIndexOf("\n", transformStart - 1) + 1;
+  const before = text.slice(lineStart, transformStart);
+  const option = `${IR_CALLBACKS_OPTION}: true,`;
+  return /^\s*$/.test(before) ? `${option}
+${before}` : `${option} `;
+}
+function keepReason(options) {
+  const hasOther = LEGACY_ONLY_CALLBACKS.some((name) => propertyNamed(options, name) !== void 0);
+  return hasOther ? "other-callbacks" : void 0;
+}
+function legacyCallbackSteps(options, text) {
+  return LEGACY_ONLY_CALLBACKS.flatMap((callback) => {
+    const property = propertyNamed(options, callback);
+    return property === void 0 ? [] : [{ kind: "legacy-callback", line: lineAt(text, property.getStart()), callback }];
+  });
+}
+function migrateOptions(options, text, names) {
+  if (propertyNamed(options, IR_CALLBACKS_OPTION) !== void 0) {
+    return { edits: [], changes: [], manualSteps: [] };
+  }
+  const findings = {
+    edits: [],
+    changes: [],
+    manualSteps: legacyCallbackSteps(options, text)
+  };
+  const transform = propertyNamed(options, TRANSFORM);
+  if (transform === void 0) {
+    return findings;
+  }
+  const start = transform.getStart();
+  const line = lineAt(text, start);
+  const result = keepReason(options) ?? transformEdits(transform, names, text);
+  if (typeof result === "string") {
+    findings.manualSteps.push({ kind: "transform-not-rewritten", line, reason: result });
+    return findings;
+  }
+  findings.edits.push({ start, end: start, text: irCallbacksOption(text, start) }, ...result);
+  findings.changes.push({ kind: "transform-rewritten", line });
+  return findings;
+}
+function generatorOptions(node, names) {
+  if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) {
+    return void 0;
+  }
+  const options = node.arguments[1];
+  const isGenerator = names.generatorFunctions.has(node.expression.text);
+  return isGenerator && options !== void 0 && ts.isObjectLiteralExpression(options) ? options : void 0;
+}
+function applyEdits(text, edits) {
+  return [...edits].sort((left, right) => right.start - left.start).reduce(
+    (result, edit) => result.slice(0, edit.start) + edit.text + result.slice(edit.end),
+    text
+  );
+}
+function findCallFindings(file, text, names) {
+  const all = { edits: [], changes: [], manualSteps: [] };
+  const visit = (node) => {
+    const options = generatorOptions(node, names);
+    if (options !== void 0) {
+      const found = migrateOptions(options, text, names);
+      all.edits.push(...found.edits);
+      all.changes.push(...found.changes);
+      all.manualSteps.push(...found.manualSteps);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(file);
+  return all;
+}
+class TypescriptCallbackRewriter {
+  rewrite(text, path) {
+    const scriptKind = scriptKindOf(path);
+    if (scriptKind === void 0) {
+      return unchanged(text);
+    }
+    const file = ts.createSourceFile(path, text, ts.ScriptTarget.Latest, true, scriptKind);
+    const names = collectFileNames(file);
+    if (names.generatorFunctions.size === 0) {
+      return unchanged(text);
+    }
+    const { edits, changes, manualSteps } = findCallFindings(file, text, names);
+    return { text: applyEdits(text, edits), changes, manualSteps };
+  }
+}
+function createTypescriptCallbackRewriter() {
+  return new TypescriptCallbackRewriter();
+}
+
+const PACKAGE_RENAMES = /* @__PURE__ */ new Map([
+  ["openapi-typescript", "openapi-typesafe"],
+  ["openapi-fetch", "openapi-typesafe-fetch"],
+  ["openapi-react-query", "openapi-typesafe-react-query"],
+  ["openapi-typescript-helpers", "openapi-typesafe-helpers"]
+]);
+const GENERATOR_COMMAND = "openapi-typescript";
+const MIGRATED_GENERATOR_COMMAND = "openapi-typesafe";
+const FLAG_RENAMES = /* @__PURE__ */ new Map([
+  ["--immutable-types", "--immutable"],
+  ["-it", "--immutable"],
+  ["--support-array-length", "--array-length"],
+  ["--redoc", "--redocly"],
+  ["-ap", "--additional-properties"]
+]);
+const DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies"
+];
+const OVERRIDE_FIELDS = ["overrides", "resolutions", "pnpm"];
+
+const COMMAND_RE = new RegExp(`(?<=^|[\\s"'\`;&|(])${GENERATOR_COMMAND}(?=$|[\\s"'\`;&|)])`, "g");
+const VERSIONED_COMMAND_RE = new RegExp(`(?<=^|[\\s"'\`;&|(])${GENERATOR_COMMAND}@`);
+const MIGRATED_COMMAND_RE = new RegExp(
+  `(?<=^|[\\s"'\`;&|(])${MIGRATED_GENERATOR_COMMAND}(?=$|[\\s"'\`;&|)])`
+);
+const FLAG_RE = new RegExp(`(?<=\\s)(${[...FLAG_RENAMES.keys()].join("|")})(?=$|[\\s=])`, "g");
+function renameFlags(text, location, changes) {
+  if (!MIGRATED_COMMAND_RE.test(text)) {
+    return text;
+  }
+  return text.replace(FLAG_RE, (flag) => {
+    const renamed = FLAG_RENAMES.get(flag);
+    changes.push({ kind: "flag-renamed", location, from: flag, to: renamed });
+    return renamed;
+  });
+}
+function migrateCommand(text, location) {
+  const changes = [];
+  const manualSteps = [];
+  if (VERSIONED_COMMAND_RE.test(text)) {
+    manualSteps.push({ kind: "versioned-command", location });
+  }
+  const renamed = text.replace(COMMAND_RE, () => {
+    changes.push({ kind: "command-renamed", location });
+    return MIGRATED_GENERATOR_COMMAND;
+  });
+  return { text: renameFlags(renamed, location, changes), changes, manualSteps };
+}
+function migrateCommandLines(text, file) {
+  const changes = [];
+  const manualSteps = [];
+  const lines = text.split("\n").map((line, index) => {
+    const migrated = migrateCommand(line, `${file}:${index + 1}`);
+    changes.push(...migrated.changes);
+    manualSteps.push(...migrated.manualSteps);
+    return migrated.text;
+  });
+  return { text: lines.join("\n"), changes, manualSteps };
+}
+
+const PARENT_SEPARATOR = ">";
+const PATH_SEPARATOR = "/";
+const SCOPE_PREFIX = "@";
+function overrideTarget(key) {
+  const child = key.split(PARENT_SEPARATOR).at(-1) ?? key;
+  const segments = child.split(PATH_SEPARATOR);
+  const isScoped = segments.length > 1 && segments.at(-2)?.startsWith(SCOPE_PREFIX) === true;
+  const name = isScoped ? segments.slice(-2).join(PATH_SEPARATOR) : segments.at(-1) ?? child;
+  const versionAt = name.indexOf(SCOPE_PREFIX, 1);
+  return versionAt === -1 ? name : name.slice(0, versionAt);
+}
+function keysOf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return [];
+  }
+  return Object.entries(value).flatMap(([key, nested]) => [key, ...keysOf(nested)]);
+}
+function overriddenPackages(value) {
+  const targets = keysOf(value).map(overrideTarget);
+  return [...new Set(targets.filter((target) => PACKAGE_RENAMES.has(target)))];
+}
+
+const VERSION_STYLE_RE = /^([\^~]|>=)?\d/;
+const KEPT_PROTOCOLS = ["catalog:", "workspace:"];
+function migrateVersionSpec(spec, version) {
+  if (KEPT_PROTOCOLS.some((protocol) => spec.startsWith(protocol))) {
+    return { kind: "kept", spec, isReported: false };
+  }
+  const style = VERSION_STYLE_RE.exec(spec);
+  if (style === null) {
+    return { kind: "kept", spec, isReported: true };
+  }
+  const prefix = style[1] === ">=" ? "^" : style[1] ?? "";
+  return { kind: "replaced", spec: `${prefix}${version}` };
+}
+
+const INDENT_RE = /^[ \t]+(?=")/m;
+const DEFAULT_INDENT = "  ";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatLike(original, manifest) {
+  const indent = INDENT_RE.exec(original)?.[0] ?? DEFAULT_INDENT;
+  const ending = original.endsWith("\n") ? "\n" : "";
+  return `${JSON.stringify(manifest, null, indent)}${ending}`;
+}
+function renameDependencies(field, dependencies, version, findings) {
+  return Object.fromEntries(
+    Object.entries(dependencies).map(([name, spec]) => {
+      const renamed = PACKAGE_RENAMES.get(name);
+      if (renamed === void 0 || typeof spec !== "string") {
+        return [name, spec];
+      }
+      const decision = migrateVersionSpec(spec, version);
+      findings.changes.push({
+        kind: "dependency-renamed",
+        field,
+        from: name,
+        to: renamed,
+        spec: decision.spec
+      });
+      if (decision.kind === "kept" && decision.isReported) {
+        findings.manualSteps.push({ kind: "spec-kept", name: renamed, spec });
+      }
+      if (field === "peerDependencies") {
+        findings.manualSteps.push({ kind: "peer-dependency-renamed", name: renamed });
+      }
+      return [renamed, decision.spec];
+    })
+  );
+}
+function migrateScripts(scripts, findings) {
+  return Object.fromEntries(
+    Object.entries(scripts).map(([name, script]) => {
+      if (typeof script !== "string") {
+        return [name, script];
+      }
+      const migrated = migrateCommand(script, `scripts.${name}`);
+      findings.changes.push(...migrated.changes);
+      findings.manualSteps.push(...migrated.manualSteps);
+      return [name, migrated.text];
+    })
+  );
+}
+function reportOverrides(manifest, findings) {
+  for (const field of OVERRIDE_FIELDS) {
+    for (const name of overriddenPackages(manifest[field])) {
+      findings.manualSteps.push({ kind: "override-names-package", field, name });
+    }
+  }
+}
+function migrateFields(manifest, version, findings) {
+  const migrated = { ...manifest };
+  for (const field of DEPENDENCY_FIELDS) {
+    const dependencies = manifest[field];
+    if (isObject(dependencies)) {
+      migrated[field] = renameDependencies(field, dependencies, version, findings);
+    }
+  }
+  if (isObject(manifest.scripts)) {
+    migrated.scripts = migrateScripts(manifest.scripts, findings);
+  }
+  reportOverrides(manifest, findings);
+  return migrated;
+}
+function migratePackageManifest(text, version) {
+  let manifest;
+  try {
+    manifest = JSON.parse(text);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    return { ...unchanged(text), manualSteps: [{ kind: "manifest-unreadable", reason }] };
+  }
+  if (!isObject(manifest)) {
+    return unchanged(text);
+  }
+  const findings = { changes: [], manualSteps: [] };
+  const migrated = migrateFields(manifest, version, findings);
+  const isChanged = findings.changes.length > 0;
+  return { text: isChanged ? formatLike(text, migrated) : text, ...findings };
+}
+
+const SPECIFIER_RE = new RegExp(
+  `(["'\`])(${[...PACKAGE_RENAMES.keys()].join("|")})(/[^"'\`\\s]*)?\\1`,
+  "g"
+);
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".cts",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro"
+]);
+function migrateModuleSpecifiers(text) {
+  const changes = [];
+  const manualSteps = [];
+  let migrated = "";
+  let copiedUpTo = 0;
+  for (const match of text.matchAll(SPECIFIER_RE)) {
+    const [whole, quote, name, subpath] = match;
+    const line = lineAt(text, match.index);
+    const to = `${PACKAGE_RENAMES.get(name)}${subpath ?? ""}`;
+    changes.push({ kind: "specifier-renamed", line, from: whole.slice(1, -1), to });
+    if (subpath !== void 0) {
+      manualSteps.push({ kind: "deep-import", line, specifier: to });
+    }
+    migrated += `${text.slice(copiedUpTo, match.index)}${quote}${to}${quote}`;
+    copiedUpTo = match.index + whole.length;
+  }
+  return { text: migrated + text.slice(copiedUpTo), changes, manualSteps };
+}
+
+const ENTRY_RE = /^(\s+)(["']?)([\w@./-]+)\2:\s*(["']?)([^"'#\s]+)\4(.*)$/;
+const TOP_LEVEL_KEY_RE = /^([\w-]+):/;
+const KEY_RE = /^\s+(["']?)(.+?)\1:(?:\s|$)/;
+const CATALOG_SECTIONS = /* @__PURE__ */ new Set(["catalog", "catalogs"]);
+const REPORTED_SECTIONS = /* @__PURE__ */ new Set(["overrides", "patchedDependencies"]);
+function migrateEntry(line, version) {
+  const entry = ENTRY_RE.exec(line);
+  const renamed = entry === null ? void 0 : PACKAGE_RENAMES.get(entry[3]);
+  if (entry === null || renamed === void 0) {
+    return { line };
+  }
+  const [, indent, keyQuote, name, specQuote, spec, rest] = entry;
+  const decision = migrateVersionSpec(spec, version);
+  const key = `${keyQuote}${renamed}${keyQuote}`;
+  const migrated = `${indent}${key}: ${specQuote}${decision.spec}${specQuote}${rest}`;
+  const change = { kind: "catalog-entry-renamed", from: name, to: renamed };
+  if (decision.kind === "kept" && decision.isReported) {
+    return {
+      line: migrated,
+      change,
+      manualStep: { kind: "spec-kept", name: renamed, spec }
+    };
+  }
+  return { line: migrated, change };
+}
+function reportEntry(line, field) {
+  const key = KEY_RE.exec(line)?.[2];
+  return key === void 0 ? [] : overriddenPackages({ [key]: null }).map((name) => ({
+    kind: "override-names-package",
+    field,
+    name
+  }));
+}
+function migrateWorkspaceCatalogs(text, version) {
+  const changes = [];
+  const manualSteps = [];
+  let section;
+  const lines = text.split("\n").map((line) => {
+    const topLevelKey = TOP_LEVEL_KEY_RE.exec(line)?.[1];
+    if (topLevelKey !== void 0) {
+      section = topLevelKey;
+      return line;
+    }
+    if (section !== void 0 && REPORTED_SECTIONS.has(section)) {
+      manualSteps.push(...reportEntry(line, section));
+      return line;
+    }
+    if (section === void 0 || !CATALOG_SECTIONS.has(section)) {
+      return line;
+    }
+    const result = migrateEntry(line, version);
+    changes.push(...result.change ? [result.change] : []);
+    manualSteps.push(...result.manualStep ? [result.manualStep] : []);
+    return result.line;
+  });
+  return changes.length === 0 ? { ...unchanged(text), manualSteps } : { text: lines.join("\n"), changes, manualSteps };
+}
+
+const SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".sh", ".bash", ".zsh", ".yml", ".yaml"]);
+const SCRIPT_NAMES = /* @__PURE__ */ new Set(["Makefile", "justfile", "Dockerfile"]);
+const WORKSPACE_FILE = "pnpm-workspace.yaml";
+const MANIFEST_FILE = "package.json";
+const LOCK_FILES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "yarn.lock", "bun.lock"]);
+function baseName(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function extensionOf(path) {
+  const name = baseName(path);
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 ? "" : name.slice(dot);
+}
+function chain(first, next) {
+  const second = next(first.text);
+  const changes = [...first.changes, ...second.changes];
+  const manualSteps = [...first.manualSteps, ...second.manualSteps];
+  return { text: second.text, changes, manualSteps };
+}
+const FILE_KINDS = [
+  {
+    matches: (path) => baseName(path) === MANIFEST_FILE,
+    migrate: (text, _path, context) => migratePackageManifest(text, context.version)
+  },
+  {
+    matches: (path) => baseName(path) === WORKSPACE_FILE,
+    migrate: (text, _path, context) => migrateWorkspaceCatalogs(text, context.version)
+  },
+  {
+    matches: (path) => SOURCE_EXTENSIONS.has(extensionOf(path)),
+    migrate: (text, path, context) => chain(migrateModuleSpecifiers(text), (renamed) => context.rewriter.rewrite(renamed, path))
+  },
+  {
+    matches: (path) => SCRIPT_EXTENSIONS.has(extensionOf(path)) || SCRIPT_NAMES.has(baseName(path)),
+    migrate: (text, path) => migrateCommandLines(text, path)
+  }
+];
+function fileMigrationFor(path) {
+  if (LOCK_FILES.has(baseName(path))) {
+    return void 0;
+  }
+  return FILE_KINDS.find((kind) => kind.matches(path))?.migrate;
+}
+
+async function migrateFile(path, dependencies, input) {
+  const migrate = fileMigrationFor(path);
+  if (migrate === void 0) {
+    return void 0;
+  }
+  const text = await dependencies.files.read(path);
+  const context = { version: input.version, rewriter: dependencies.rewriter };
+  const migration = migrate(text, path, context);
+  const isChanged = migration.text !== text;
+  if (isChanged && input.isWrite) {
+    await dependencies.files.write(path, migration.text);
+  }
+  const { changes, manualSteps } = migration;
+  if (isChanged || manualSteps.length > 0) {
+    dependencies.logger.info("file_migrated", { path, isChanged, changes, manualSteps });
+  }
+  return { path, isChanged, changes, manualSteps };
+}
+async function migrateProject(dependencies, input) {
+  const paths = (await dependencies.files.listFiles()).sort();
+  dependencies.logger.info("migration_started", { fileCount: paths.length, ...input });
+  const reports = [];
+  for (const path of paths) {
+    const report = await migrateFile(path, dependencies, input);
+    if (report !== void 0 && (report.isChanged || report.manualSteps.length > 0)) {
+      reports.push(report);
+    }
+  }
+  dependencies.logger.info("migration_finished", { changedFiles: reports.length });
+  return reports;
+}
+
+function assertNever(value) {
+  throw new Error(`Unexpected variant: ${JSON.stringify(value)}`);
+}
+
+const IR_CALLBACKS_GUIDE = "https://github.com/openapi-typesafe/openapi-typesafe/blob/main/docs/node.md#ir-callbacks";
+function changeMessage(change) {
+  switch (change.kind) {
+    case "dependency-renamed":
+      return `${change.field}: ${change.from} \u2192 ${change.to}@${change.spec}`;
+    case "catalog-entry-renamed":
+      return `catalog: ${change.from} \u2192 ${change.to}`;
+    case "command-renamed":
+      return `${change.location}: openapi-typescript \u2192 openapi-typesafe`;
+    case "flag-renamed":
+      return `${change.location}: ${change.from} \u2192 ${change.to}`;
+    case "specifier-renamed":
+      return `line ${change.line}: "${change.from}" \u2192 "${change.to}"`;
+    case "transform-rewritten":
+      return `line ${change.line}: transform returns type text; irCallbacks: true added`;
+    default:
+      return assertNever(change);
+  }
+}
+const KEEP_REASONS = {
+  "other-callbacks": "postTransform or transformProperty are set too, and they need TypeScript nodes",
+  "not-a-function": "it is not an inline function or a function of this file",
+  "shared-function": "the function it names is used elsewhere too",
+  "unknown-return": "a return value is not a plain ts.factory type"
+};
+const PEER_NOTE = "users of this package must switch too (a breaking change for them)";
+const PINNED_NOTE = "change it to openapi-typesafe@<version>";
+const DEEP_IMPORT_NOTE = "imports a file inside the package; check that it exists";
+const KEPT_NOTE = `it works, with a deprecation warning. See ${IR_CALLBACKS_GUIDE}`;
+const LEGACY_CALLBACK_NOTE = `receives TypeScript nodes (deprecated). See ${IR_CALLBACKS_GUIDE}`;
+function manualStepMessage(step) {
+  switch (step.kind) {
+    case "manifest-unreadable":
+      return `package.json is not valid JSON (${step.reason}); migrate it by hand`;
+    case "peer-dependency-renamed":
+      return `${step.name} is a peer dependency: ${PEER_NOTE}`;
+    case "spec-kept":
+      return `${step.name} kept the spec "${step.spec}": point it at an openapi-typesafe version`;
+    case "override-names-package":
+      return `"${step.field}" names ${step.name}: update or remove that override`;
+    case "versioned-command":
+      return `${step.location} runs a pinned openapi-typescript@<version>: ${PINNED_NOTE}`;
+    case "deep-import":
+      return `line ${step.line}: "${step.specifier}" ${DEEP_IMPORT_NOTE}`;
+    case "transform-not-rewritten":
+      return `line ${step.line}: transform kept (${KEEP_REASONS[step.reason]}); ${KEPT_NOTE}`;
+    case "legacy-callback":
+      return `line ${step.line}: ${step.callback} ${LEGACY_CALLBACK_NOTE}`;
+    default:
+      return assertNever(step);
+  }
+}
+const NEXT_STEPS = [
+  "Install: run your package manager's install, so the lockfile has the new packages.",
+  "Regenerate your types and commit them once: the file header names openapi-typesafe now, so `--check` fails until you do.",
+  "Run your type check and tests."
+];
+const DRY_RUN_NOTE = "Dry run: nothing was written. Run again with --write to apply.";
+const WRITTEN_NOTE = "Files were written.";
+const NOTHING_FOUND = "Nothing to migrate: no openapi-typescript, openapi-fetch, openapi-react-query or openapi-typescript-helpers found.";
+
+function changesSection(reports) {
+  const changed = reports.filter((report) => report.changes.length > 0);
+  if (changed.length === 0) {
+    return [];
+  }
+  return [
+    "Changes:",
+    ...changed.flatMap((report) => [
+      `  ${report.path}`,
+      ...report.changes.map((change) => `    ${changeMessage(change)}`)
+    ]),
+    ""
+  ];
+}
+function manualStepsSection(reports) {
+  const steps = reports.flatMap(
+    (report) => report.manualSteps.map((step) => `  ${report.path}: ${manualStepMessage(step)}`)
+  );
+  return steps.length === 0 ? [] : ["Manual steps:", ...steps, ""];
+}
+function renderReport(reports, isWrite) {
+  if (reports.length === 0) {
+    return `${NOTHING_FOUND}
+`;
+  }
+  const lines = [
+    ...changesSection(reports),
+    ...manualStepsSection(reports),
+    "Next steps:",
+    ...NEXT_STEPS.map((step, index) => `  ${index + 1}. ${step}`),
+    "",
+    isWrite ? WRITTEN_NOTE : DRY_RUN_NOTE
+  ];
+  return `${lines.join("\n")}
+`;
+}
+
+const OPTIONS = {
+  write: { type: "boolean" },
+  root: { type: "string" },
+  log: { type: "string" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "v" }
+};
+function parseCliArguments(argv) {
+  const { values } = parseArgs({ args: [...argv], options: OPTIONS, strict: true });
+  if (values.help === true) {
+    return { kind: "help" };
+  }
+  if (values.version === true) {
+    return { kind: "version" };
+  }
+  return {
+    kind: "migrate",
+    isWrite: values.write === true,
+    root: values.root,
+    logPath: values.log
+  };
+}
+
+const HELP_TEXT = `Usage
+  openapi-typesafe-migrate [options]
+
+Move a project from openapi-typescript, openapi-fetch, openapi-react-query and
+openapi-typescript-helpers to the openapi-typesafe packages. Without --write it only reports.
+
+Options
+  --write        Write the changes (default: dry run)
+  --root <dir>   The project directory (default: the current directory)
+  --log <file>   The JSON Lines log file (default: a new file in the temporary directory)
+  --help, -h     Show this help
+  --version, -v  Show the version
+
+Exit codes
+  0  Done
+  1  The migration failed (the message and the log say why)
+  2  Unknown option or argument
+`;
+const usageError = (message) => `${message}
+Run openapi-typesafe-migrate --help for the options.
+`;
+const logNote = (path) => `Log: ${path}
+`;
+
+const EXIT_CODES = { success: 0, failure: 1, usage: 2 };
+function parseRequest(argv, dependencies) {
+  try {
+    return parseCliArguments(argv);
+  } catch (error) {
+    if (error instanceof TypeError) {
+      dependencies.writeStderr(usageError(error.message));
+      return void 0;
+    }
+    throw error;
+  }
+}
+async function runMigration(request, dependencies) {
+  const root = dependencies.resolvePath(dependencies.cwd, request.root ?? ".");
+  const { logger, path } = dependencies.createLogger(request.logPath);
+  try {
+    const files = dependencies.createFiles(root);
+    const input = { version: dependencies.version, isWrite: request.isWrite };
+    const reports = await migrateProject({ files, rewriter: dependencies.rewriter, logger }, input);
+    dependencies.writeStdout(renderReport(reports, request.isWrite));
+    return EXIT_CODES.success;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn("migration_failed", { root, message });
+    dependencies.writeStderr(`${message}
+`);
+    return EXIT_CODES.failure;
+  } finally {
+    dependencies.writeStdout(logNote(path));
+  }
+}
+async function runCli(argv, dependencies) {
+  const request = parseRequest(argv, dependencies);
+  if (request === void 0) {
+    return EXIT_CODES.usage;
+  }
+  if (request.kind === "help") {
+    dependencies.writeStdout(HELP_TEXT);
+    return EXIT_CODES.success;
+  }
+  if (request.kind === "version") {
+    dependencies.writeStdout(`${dependencies.version}
+`);
+    return EXIT_CODES.success;
+  }
+  return runMigration(request, dependencies);
+}
+
+const PACKAGE_JSON = new URL("../../package.json", import.meta.url);
+const LOG_DIRECTORY = "openapi-typesafe-migrate";
+function readVersion() {
+  const packageJson = JSON.parse(readFileSync(PACKAGE_JSON, "utf8"));
+  return packageJson.version;
+}
+const now = () => /* @__PURE__ */ new Date();
+function createLogger(path) {
+  const logPath = path === void 0 ? join(tmpdir(), LOG_DIRECTORY, `${now().toISOString().replaceAll(":", "-")}.jsonl`) : resolve(path);
+  return { logger: createJsonLinesLogger({ path: logPath, now }), path: logPath };
+}
+const dependencies = {
+  version: readVersion(),
+  cwd: process.cwd(),
+  writeStdout: (text) => process.stdout.write(text),
+  writeStderr: (text) => process.stderr.write(text),
+  createFiles: createNodeProjectFiles,
+  createLogger,
+  rewriter: createTypescriptCallbackRewriter(),
+  resolvePath: resolve
+};
+runCli(process.argv.slice(2), dependencies).then((exitCode) => {
+  process.exitCode = exitCode;
+});
+//# sourceMappingURL=main.mjs.map