@typeorm/codemod 1.0.1 → 1.0.3-nightly.20261009

package/dist/transforms/ast-helpers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renameMemberMethod = exports.removeImportSpecifiers = exports.removeObjectProperties = exports.forEachDecoratorObjectArg = exports.expandLocalNamesForImports = exports.TYPEORM_COLUMN_DECORATORS = exports.forEachIdentifierParam = exports.getLocalNamesForImport = exports.fileImportsFrom = exports.isIdentifier = exports.setStringValue = exports.getStringValue = void 0;
+exports.isRepositoryReceiver = exports.collectRepositoryBindings = exports.TYPEORM_DATASOURCE_TYPES = exports.TYPEORM_REPOSITORY_TYPES = exports.getTypeReferenceRootName = exports.renameMemberMethod = exports.renameReExportSpecifiers = exports.removeReExportSpecifiers = exports.removeImportSpecifiers = exports.removeObjectPropertiesWhere = exports.removeObjectProperties = exports.unwrapTsExpression = exports.isFindMethodCallArgument = exports.isObjectFromEntriesCall = exports.TYPEORM_FIND_OPTIONS_METHODS = exports.forEachColumnMetadataOptionsArg = exports.getObjectPropertyKeyName = exports.forEachDecoratorObjectArg = exports.expandLocalNamesForImports = exports.TYPEORM_COLUMN_DECORATORS = exports.forEachIdentifierParam = exports.getNamespaceLocalNames = exports.getLocalNamesForImport = exports.fileImportsFrom = exports.isIdentifier = exports.setStringValue = exports.getStringValue = void 0;
 /**
  * Extracts a string value from a StringLiteral or Literal node.
  * Returns null if the node is not a string literal.
@@ -30,11 +30,12 @@ exports.setStringValue = setStringValue;
 const isIdentifier = (node) => node.type === "Identifier";
 exports.isIdentifier = isIdentifier;
 /**
- * Checks whether the file contains an import from the given module. Matches
- * both the exact module name (`"typeorm"`) and any sub-path (`"typeorm/..."`),
- * and recognizes ESM `import`, TypeScript `import = require(...)`, and
- * CommonJS `require(...)` forms so that `.js`/`.jsx` callers still pass the
- * scope guard.
+ * Checks whether the file references the given module as an import or a
+ * re-export source. Matches the exact module name (`"typeorm"`) and any
+ * sub-path (`"typeorm/..."`), and recognizes ESM `import`, ESM
+ * `export { X } from "..."` / `export * from "..."`, TypeScript
+ * `import = require(...)`, and CommonJS `require(...)` forms so barrel
+ * files and `.js`/`.jsx` callers still pass the scope guard.
  */
 const fileImportsFrom = (root, j, moduleName) => {
     const prefix = `${moduleName}/`;
@@ -46,6 +47,19 @@ const fileImportsFrom = (root, j, moduleName) => {
         .some((path) => matchesModule(path.node.source.value))) {
         return true;
     }
+    // ESM: export { X } from "typeorm[/subpath]" / export * from "..."
+    // Barrel files that only re-export TypeORM APIs have no import at all,
+    // but their re-export source still counts as a reference to the module.
+    if (root
+        .find(j.ExportNamedDeclaration)
+        .some((path) => matchesModule(path.node.source?.value))) {
+        return true;
+    }
+    if (root
+        .find(j.ExportAllDeclaration)
+        .some((path) => matchesModule(path.node.source?.value))) {
+        return true;
+    }
     // TS: import ... = require("typeorm[/subpath]")
     if (root.find(j.TSImportEqualsDeclaration).some((path) => {
         const ref = path.node.moduleReference;
@@ -73,31 +87,69 @@ exports.fileImportsFrom = fileImportsFrom;
  *   import { RelationCount as RC } from "typeorm"   → { "RC" }
  *   const { RelationCount } = require("typeorm")    → { "RelationCount" }
  *   const { RelationCount: RC } = require("typeorm")→ { "RC" }
+ *
+ * Matches both the exact module name and any sub-path — e.g. when moduleName
+ * is `"typeorm"`, imports from `"typeorm/metadata/ColumnMetadata"` are also
+ * recognised. TypeORM users reach internal types through deep imports, and
+ * the codemod must rewrite them regardless of import shape.
+ *
+ * CommonJS `require` destructures are collected from module scope only; an
+ * inside-function `require` would sit in an inner scope where the call-site
+ * shadow guards reject rewrites, so collecting it would silently mislead
+ * callers. See the inline comment on the CJS branch for details.
+ *
+ * @param opts.valueOnly When true, skip ESM type-only imports — both the
+ *   declaration-level `import type { X }` and the per-specifier
+ *   `import { type X }` form. Use this when the local is going to appear as
+ *   a *value* in the rewritten code (e.g. callee of `new X(...)` or
+ *   `X.method()`); a type-only import creates no runtime binding and must
+ *   not influence value-level matching. CommonJS `require` destructures and
+ *   TS `import = require` forms always produce value bindings so they are
+ *   included regardless.
  */
-const getLocalNamesForImport = (root, j, moduleName, importedName) => {
+const getLocalNamesForImport = (root, j, moduleName, importedName, opts = {}) => {
     const localNames = new Set();
-    // ESM: `import { X [as Y] } from "moduleName"`
-    root.find(j.ImportDeclaration, {
-        source: { value: moduleName },
-    }).forEach((importPath) => {
+    const { valueOnly = false } = opts;
+    const prefix = `${moduleName}/`;
+    const matchesModule = (source) => typeof source === "string" &&
+        (source === moduleName || source.startsWith(prefix));
+    // ESM: `import { X [as Y] } from "moduleName[/subpath]"`
+    root.find(j.ImportDeclaration).forEach((importPath) => {
+        if (!matchesModule(importPath.node.source.value))
+            return;
+        const declKind = importPath.node.importKind;
+        if (valueOnly && declKind === "type")
+            return;
         for (const spec of importPath.node.specifiers ?? []) {
             if (spec.type !== "ImportSpecifier" ||
                 spec.imported.type !== "Identifier" ||
                 spec.imported.name !== importedName) {
                 continue;
             }
+            const specKind = spec.importKind;
+            if (valueOnly && specKind === "type")
+                continue;
             const local = spec.local ?? spec.imported;
             if (local.type === "Identifier") {
                 localNames.add(local.name);
             }
         }
     });
-    // CommonJS: `const { X [: Y] } = require("moduleName")`
+    // CommonJS: `const { X [: Y] } = require("moduleName[/subpath]")`
+    // Only top-level requires are collected. An inside-function require
+    // creates a binding at non-module scope, and the call-site scope guard
+    // in `forEachColumnMetadataOptionsArg` rejects callees whose declaration
+    // lives in any inner scope (shadow guard). Collecting inner-scope
+    // requires here would make the collector and the guard disagree — the
+    // name would be in `classLocalNames` but the rewrite would never fire.
+    // Users with inside-function requires can hoist them to module scope.
     root.find(j.CallExpression, {
         callee: { type: "Identifier", name: "require" },
     }).forEach((callPath) => {
         const [arg] = callPath.node.arguments;
-        if (!arg || (0, exports.getStringValue)(arg) !== moduleName)
+        if (!arg || !matchesModule((0, exports.getStringValue)(arg)))
+            return;
+        if (callPath.scope?.isGlobal !== true)
             return;
         const parent = callPath.parent.node;
         if (parent.type !== "VariableDeclarator")
@@ -132,6 +184,80 @@ const getLocalNamesForImport = (root, j, moduleName, importedName) => {
     return localNames;
 };
 exports.getLocalNamesForImport = getLocalNamesForImport;
+/**
+ * Collects local namespace bindings for a module. Covers:
+ *
+ *   import * as typeorm from "typeorm"           → "typeorm"
+ *   const typeorm = require("typeorm")           → "typeorm"
+ *   import typeorm = require("typeorm")          → "typeorm"
+ *
+ * Useful when a transform needs to recognise `typeorm.Foo` member-expression
+ * references alongside named `Foo` imports handled by `getLocalNamesForImport`.
+ *
+ * CJS namespace `require` bindings are collected from module scope only,
+ * matching the module-scope guard that `getLocalNamesForImport` applies for
+ * destructured requires — same reasoning, see the CJS branch comment there.
+ *
+ * @param opts.valueOnly When true, skip ESM type-only namespace imports
+ *   (`import type * as ns from "..."`). Use this when the local name is
+ *   going to appear as a *value* in the rewritten code (e.g. callee of
+ *   `new ns.X(...)`); a type-only import creates no runtime binding. CJS
+ *   `require` and TS `import = require` forms are always value bindings and
+ *   remain included regardless.
+ */
+const getNamespaceLocalNames = (root, j, moduleName, opts = {}) => {
+    const localNames = new Set();
+    const { valueOnly = false } = opts;
+    const prefix = `${moduleName}/`;
+    const matchesModule = (source) => typeof source === "string" &&
+        (source === moduleName || source.startsWith(prefix));
+    // ESM: `import * as ns from "moduleName[/subpath]"`
+    root.find(j.ImportDeclaration).forEach((importPath) => {
+        if (!matchesModule(importPath.node.source.value))
+            return;
+        const declKind = importPath.node.importKind;
+        if (valueOnly && declKind === "type")
+            return;
+        for (const spec of importPath.node.specifiers ?? []) {
+            if (spec.type === "ImportNamespaceSpecifier" &&
+                spec.local?.type === "Identifier") {
+                localNames.add(spec.local.name);
+            }
+        }
+    });
+    // TypeScript: `import ns = require("moduleName[/subpath]")`
+    root.find(j.TSImportEqualsDeclaration).forEach((importPath) => {
+        const ref = importPath.node.moduleReference;
+        if (ref.type !== "TSExternalModuleReference")
+            return;
+        if (!matchesModule((0, exports.getStringValue)(ref.expression)))
+            return;
+        if (importPath.node.id?.type === "Identifier") {
+            localNames.add(importPath.node.id.name);
+        }
+    });
+    // CommonJS: `const ns = require("moduleName[/subpath]")`
+    // Top-level only — see the note in `getLocalNamesForImport` for why the
+    // collector and the call-site scope guard must agree on module scope.
+    root.find(j.CallExpression, {
+        callee: { type: "Identifier", name: "require" },
+    }).forEach((callPath) => {
+        const [arg] = callPath.node.arguments;
+        if (!arg || !matchesModule((0, exports.getStringValue)(arg)))
+            return;
+        if (callPath.scope?.isGlobal !== true)
+            return;
+        const parent = callPath.parent.node;
+        if (parent.type !== "VariableDeclarator" ||
+            parent.id.type !== "Identifier") {
+            return;
+        }
+        const name = parent.id.name;
+        localNames.add(name);
+    });
+    return localNames;
+};
+exports.getNamespaceLocalNames = getNamespaceLocalNames;
 /**
  * Calls `callback` for each Identifier parameter found in function-like
  * nodes (functions, methods, arrows) and TSParameterProperty nodes.
@@ -173,11 +299,16 @@ exports.TYPEORM_COLUMN_DECORATORS = new Set([
  * the file — covers ESM aliases (`import { Column as C }`) and CJS aliases
  * (`const { Column: C } = require(...)`). Returns a union set suitable for
  * alias-aware identifier matching.
+ *
+ * @param opts.valueOnly Forwarded to `getLocalNamesForImport` — see there
+ *   for semantics. Use when the expanded names will be matched against
+ *   value-level usages (callees, method receivers) rather than type
+ *   annotations.
  */
-const expandLocalNamesForImports = (root, j, moduleName, importedNames) => {
+const expandLocalNamesForImports = (root, j, moduleName, importedNames, opts = {}) => {
     const expanded = new Set();
     for (const name of importedNames) {
-        for (const local of (0, exports.getLocalNamesForImport)(root, j, moduleName, name)) {
+        for (const local of (0, exports.getLocalNamesForImport)(root, j, moduleName, name, opts)) {
             expanded.add(local);
         }
     }
@@ -216,25 +347,258 @@ const forEachDecoratorObjectArg = (root, j, callback, decoratorNames) => {
     });
 };
 exports.forEachDecoratorObjectArg = forEachDecoratorObjectArg;
+/**
+ * Returns the key name for an `ObjectProperty` / `Property` node. Handles
+ * both identifier keys (`name`) and string-literal keys (`"name"`), including
+ * the computed-string form (`['name']: …`) whose runtime key is still
+ * statically knowable. Returns null for dynamic computed keys (`[someVar]`,
+ * `[expr]`), numeric keys, and for node types that don't carry a key at all
+ * (spread elements, etc.).
+ */
+const getObjectPropertyKeyName = (prop) => {
+    if (prop.type !== "Property" && prop.type !== "ObjectProperty")
+        return null;
+    // Computed keys whose expression is a string literal (`['foo']`) are
+    // equivalent at runtime to the plain-identifier form (`foo`), so match
+    // them. Dynamic computed keys (`[variable]`, `[fn()]`) stay opaque.
+    if (prop.computed)
+        return (0, exports.getStringValue)(prop.key);
+    if (prop.key.type === "Identifier")
+        return prop.key.name;
+    return (0, exports.getStringValue)(prop.key);
+};
+exports.getObjectPropertyKeyName = getObjectPropertyKeyName;
+/**
+ * Walks `new ColumnMetadata({ args: { options: {...} } })` constructor calls
+ * and invokes `callback` with the inner `options` ObjectExpression. Mirrors
+ * `forEachDecoratorObjectArg` but for the ColumnMetadata class constructor:
+ * its `args.options` object is typed `ColumnOptions`, so transforms that
+ * rewrite `ColumnOptions` fields (`readonly` → `update`, `width`/`zerofill`
+ * removal) must also cover this path. Rare in user code but shows up in
+ * multi-tenant / metadata-manipulation patterns.
+ *
+ * Recognised import / binding shapes, all via
+ * `expandLocalNamesForImports` / `getNamespaceLocalNames`:
+ *
+ *   import { ColumnMetadata } from "typeorm"
+ *   import { ColumnMetadata as CM } from "typeorm"
+ *   import { ColumnMetadata } from "typeorm/metadata/ColumnMetadata"   // sub-path
+ *   import * as typeorm from "typeorm"                                  // namespace
+ *   import typeorm = require("typeorm")                                 // TS import-equals
+ *   const { ColumnMetadata } = require("typeorm")                       // CJS destructure
+ *   const typeorm = require("typeorm")                                  // CJS namespace
+ *
+ * Type-only imports (declaration-level `import type { X }` and per-specifier
+ * `import { type X }`, same for `import type * as`) are filtered via
+ * `valueOnly: true` — `new X(...)` needs a runtime binding, and a type-only
+ * import creates none.
+ *
+ * Name-level matches are further gated by a scope check: the callee
+ * identifier must resolve to the module-level import binding and not a
+ * shadowing declaration in an inner scope (function parameter, nested
+ * `const`/`let`/`var`, class declaration, catch binding).
+ */
+const forEachColumnMetadataOptionsArg = (root, j, target, callback) => {
+    const classLocalNames = (0, exports.expandLocalNamesForImports)(root, j, target.moduleName, new Set([target.className]), { valueOnly: true });
+    const namespaceLocalNames = (0, exports.getNamespaceLocalNames)(root, j, target.moduleName, { valueOnly: true });
+    if (classLocalNames.size === 0 && namespaceLocalNames.size === 0)
+        return;
+    const resolvesToModuleScope = (path, name) => {
+        let scope = path.scope;
+        while (scope) {
+            if (scope.isGlobal === true || !scope.parent)
+                return true;
+            if (scope.declares(name))
+                return false;
+            scope = scope.parent;
+        }
+        return true;
+    };
+    const matchesCallee = (callee, path) => {
+        if (callee.type === "Identifier") {
+            if (!classLocalNames.has(callee.name))
+                return false;
+            return resolvesToModuleScope(path, callee.name);
+        }
+        if ((callee.type === "MemberExpression" ||
+            callee.type === "OptionalMemberExpression") &&
+            callee.computed !== true) {
+            const obj = callee.object;
+            const prop = callee.property;
+            if ((0, exports.isIdentifier)(obj) &&
+                (0, exports.isIdentifier)(prop) &&
+                prop.name === target.className) {
+                if (!namespaceLocalNames.has(obj.name))
+                    return false;
+                return resolvesToModuleScope(path, obj.name);
+            }
+        }
+        return false;
+    };
+    // Returns the property value as an ObjectExpression if the property with
+    // the given key exists and its value is an ObjectExpression (after peeling
+    // TS wrappers like `as` / `satisfies` / `!` / parens). Uses `findLast` so
+    // duplicate keys match JS object-literal semantics (last occurrence wins).
+    const findObjectPropertyValue = (obj, keyName) => {
+        const prop = obj.properties.findLast((p) => (0, exports.getObjectPropertyKeyName)(p) === keyName);
+        if (!prop ||
+            (prop.type !== "Property" && prop.type !== "ObjectProperty")) {
+            return null;
+        }
+        const value = (0, exports.unwrapTsExpression)(prop.value);
+        return value.type === "ObjectExpression" ? value : null;
+    };
+    root.find(j.NewExpression).forEach((path) => {
+        if (!matchesCallee(path.node.callee, path))
+            return;
+        const [firstArg] = path.node.arguments;
+        const arg = firstArg ? (0, exports.unwrapTsExpression)(firstArg) : undefined;
+        if (arg?.type !== "ObjectExpression")
+            return;
+        const argsValue = findObjectPropertyValue(arg, "args");
+        if (!argsValue)
+            return;
+        const optionsValue = findObjectPropertyValue(argsValue, "options");
+        if (!optionsValue)
+            return;
+        callback(optionsValue, path);
+    });
+};
+exports.forEachColumnMetadataOptionsArg = forEachColumnMetadataOptionsArg;
+/**
+ * TypeORM `Repository` / `EntityManager` methods that accept a FindOptions
+ * object (with `select`/`relations`/`where`/…). Used to scope the
+ * `select: [...]` / `relations: [...]` → object-form transforms to
+ * arguments passed into these methods. Deliberately excludes the
+ * `*By` variants (`findBy`, `findOneBy`, `findOneByOrFail`,
+ * `findAndCountBy`, `countBy`, `existsBy`) — those accept a plain WHERE
+ * object, so rewriting a top-level `select` or `relations` key there would
+ * mangle matches against entity fields of those names.
+ *
+ * The method-name check (rather than a file-level typeorm import gate)
+ * lets the transforms fire in NestJS-style service files that only pull
+ * TypeORM types via a wrapper module.
+ */
+exports.TYPEORM_FIND_OPTIONS_METHODS = new Set([
+    "find",
+    "findAndCount",
+    "findOne",
+    "findOneOrFail",
+    "count",
+    "exists",
+]);
+/**
+ * Returns true when `node` is a call of shape `Object.fromEntries(...)`.
+ * Used by the find-option transforms to stay idempotent — a second pass
+ * must not wrap an already-wrapped dynamic value in another `fromEntries`.
+ */
+const isObjectFromEntriesCall = (node) => {
+    if (node.type !== "CallExpression")
+        return false;
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    const m = callee;
+    return (m.object.type === "Identifier" &&
+        m.object.name === "Object" &&
+        m.property.type === "Identifier" &&
+        m.property.name === "fromEntries");
+};
+exports.isObjectFromEntriesCall = isObjectFromEntriesCall;
+/**
+ * Returns true when the given `ObjectProperty` lives inside an object that
+ * is an argument to one of the TYPEORM_FIND_OPTIONS_METHODS. Matches both
+ *   `repo.find({ select: [...] })` (object is the single argument) and
+ *   `manager.find(Entity, { select: [...] })` (object is the second arg).
+ */
+const isFindMethodCallArgument = (propPath) => {
+    const objExprPath = propPath.parent;
+    if (objExprPath?.node.type !== "ObjectExpression") {
+        return false;
+    }
+    // Walk up through TS expression wrappers (`{ select: [...] } as T`,
+    // `satisfies Opts`, parens) before expecting a CallExpression. Without
+    // this, `repo.find({ select: [...] } as FindOptions)` is missed.
+    let ancestor = objExprPath.parent;
+    while (ancestor) {
+        const t = ancestor.node.type;
+        if (t === "TSAsExpression" ||
+            t === "TSSatisfiesExpression" ||
+            t === "TSTypeAssertion" ||
+            t === "TSNonNullExpression" ||
+            t === "ParenthesizedExpression") {
+            ancestor = ancestor.parent;
+            continue;
+        }
+        break;
+    }
+    if (!ancestor)
+        return false;
+    const callNode = ancestor.node;
+    if (callNode.type !== "CallExpression" &&
+        callNode.type !== "OptionalCallExpression") {
+        return false;
+    }
+    const callee = callNode.callee;
+    if (callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression") {
+        return false;
+    }
+    const prop = callee.property;
+    if (prop.type !== "Identifier")
+        return false;
+    return exports.TYPEORM_FIND_OPTIONS_METHODS.has(prop.name);
+};
+exports.isFindMethodCallArgument = isFindMethodCallArgument;
+/**
+ * Peels TypeScript expression wrappers and parenthesized expressions around
+ * a value so callers see the underlying node. Handles `as X` / `x!` /
+ * `x satisfies X` / `<X>x` / `(x)`. Used by transforms that inspect values
+ * which users may annotate with type assertions — e.g.
+ * `type: "expo" as const`, `type: ("mongodb")`,
+ * `{ logPath: "x" } as Options`.
+ *
+ * Generic over the node type so callers can keep their original narrowing
+ * — in practice the returned node is the same type as the input (with TS
+ * wrapper variants peeled off).
+ */
+const unwrapTsExpression = (node) => {
+    let current = node;
+    while (current.type === "TSAsExpression" ||
+        current.type === "TSNonNullExpression" ||
+        current.type === "TSSatisfiesExpression" ||
+        current.type === "TSTypeAssertion" ||
+        current.type === "ParenthesizedExpression") {
+        const inner = current.expression;
+        if (!inner)
+            break;
+        current = inner;
+    }
+    return current;
+};
+exports.unwrapTsExpression = unwrapTsExpression;
 /**
  * Removes properties matching the given key names from an ObjectExpression.
  * Matches both identifier keys (`name`) and string-literal keys (`"name"`).
  * Returns true if any properties were removed.
  */
-const removeObjectProperties = (obj, propertyNames) => {
+const removeObjectProperties = (obj, propertyNames) => (0, exports.removeObjectPropertiesWhere)(obj, (prop) => {
+    const key = (0, exports.getObjectPropertyKeyName)(prop);
+    return key !== null && propertyNames.has(key);
+});
+exports.removeObjectProperties = removeObjectProperties;
+/**
+ * Removes every property from `obj` that satisfies `predicate`. Returns true
+ * if any property was removed. Use this over `removeObjectProperties` when
+ * removal needs to inspect the property value (not just the key name) —
+ * e.g. "remove `driver` only when its value is `require("expo-sqlite")`".
+ */
+const removeObjectPropertiesWhere = (obj, predicate) => {
     const original = obj.properties.length;
-    obj.properties = obj.properties.filter((prop) => {
-        if (prop.type !== "Property" && prop.type !== "ObjectProperty") {
-            return true;
-        }
-        const keyName = prop.key.type === "Identifier"
-            ? prop.key.name
-            : (0, exports.getStringValue)(prop.key);
-        return keyName === null ? true : !propertyNames.has(keyName);
-    });
+    obj.properties = obj.properties.filter((prop) => !predicate(prop));
     return obj.properties.length !== original;
 };
-exports.removeObjectProperties = removeObjectProperties;
+exports.removeObjectPropertiesWhere = removeObjectPropertiesWhere;
 /**
  * Finds imports from a module, removes the specified named import specifiers,
  * and removes the entire import declaration if no specifiers remain.
@@ -264,6 +628,77 @@ const removeImportSpecifiers = (root, j, moduleName, specifierNames) => {
     return removed;
 };
 exports.removeImportSpecifiers = removeImportSpecifiers;
+// Returns true for `"moduleName"` and any sub-path like `"moduleName/..."`.
+// Used so re-export helpers can match `export { X } from "typeorm"` as well
+// as `export { SapConnectionOptions } from "typeorm/driver/sap/SapConnectionOptions"`.
+const matchesModuleOrSubPath = (source, moduleName) => typeof source === "string" &&
+    (source === moduleName || source.startsWith(`${moduleName}/`));
+/**
+ * Finds re-exports from a module (`export { X } from "module"`) and removes
+ * the named specifiers listed in `specifierNames`. Also matches sub-path
+ * re-exports (`export { X } from "module/sub/path"`). Removes the entire
+ * `ExportNamedDeclaration` if no specifiers remain. Returns true if any
+ * specifiers were removed.
+ */
+const removeReExportSpecifiers = (root, j, moduleName, specifierNames) => {
+    let removed = false;
+    root.find(j.ExportNamedDeclaration).forEach((exportPath) => {
+        const source = exportPath.node.source?.value;
+        if (!matchesModuleOrSubPath(source, moduleName))
+            return;
+        const remaining = exportPath.node.specifiers?.filter((spec) => {
+            if (spec.type === "ExportSpecifier" &&
+                spec.local?.type === "Identifier" &&
+                specifierNames.has(spec.local.name)) {
+                removed = true;
+                return false;
+            }
+            return true;
+        });
+        if (remaining?.length === 0) {
+            j(exportPath).remove();
+        }
+        else if (remaining) {
+            exportPath.node.specifiers = remaining;
+        }
+    });
+    return removed;
+};
+exports.removeReExportSpecifiers = removeReExportSpecifiers;
+/**
+ * Finds re-exports from a module (`export { X } from "module"`) and renames
+ * specifiers according to the `renames` map. Also matches sub-path
+ * re-exports (`export { X } from "module/sub/path"`). When the re-export has
+ * an alias (`export { X as Y }`), only the local name is renamed so
+ * downstream consumers continue to see the same exported name. Returns true
+ * if any specifiers were renamed.
+ */
+const renameReExportSpecifiers = (root, j, moduleName, renames) => {
+    let renamed = false;
+    root.find(j.ExportNamedDeclaration).forEach((exportPath) => {
+        const source = exportPath.node.source?.value;
+        if (!matchesModuleOrSubPath(source, moduleName))
+            return;
+        exportPath.node.specifiers?.forEach((spec) => {
+            if (spec.type !== "ExportSpecifier" ||
+                spec.local?.type !== "Identifier") {
+                return;
+            }
+            const newName = renames[spec.local.name];
+            if (!newName)
+                return;
+            const wasAlias = spec.exported.type === "Identifier" &&
+                spec.exported.name !== spec.local.name;
+            spec.local.name = newName;
+            if (!wasAlias && spec.exported.type === "Identifier") {
+                spec.exported.name = newName;
+            }
+            renamed = true;
+        });
+    });
+    return renamed;
+};
+exports.renameReExportSpecifiers = renameReExportSpecifiers;
 /**
  * Finds CallExpression nodes with a MemberExpression callee where the
  * property matches `oldName`, and renames the property to `newName`.
@@ -286,4 +721,363 @@ const renameMemberMethod = (root, j, oldName, newName) => {
     return renamed;
 };
 exports.renameMemberMethod = renameMemberMethod;
+/**
+ * Walks a TypeScript type-annotation node and returns the root identifier
+ * name — e.g. `Repository<User>` → `"Repository"`, `Repository<User> | null`
+ * → `"Repository"`, `typeof Repository` → `"Repository"`. Returns null when
+ * the annotation doesn't root on a TSTypeReference with an Identifier name.
+ *
+ * When `typeormNamespaceNames` is passed, qualified references like
+ * `ns.Repository<User>` are only returned if `ns` is one of the provided
+ * namespace locals — otherwise the qualified reference is rejected so that
+ * unrelated namespaces (`Foo.Repository<T>` from some-other-lib) are not
+ * mistaken for TypeORM types. Without the parameter, any qualifier is
+ * accepted, which matches legacy callers that don't care about provenance.
+ */
+// Walks the members of a union/intersection type and prefers the first
+// TypeORM-family name (so `FooBar | Repository<T>` or `null | Repository<T>`
+// classify correctly). Falls back to the first non-null root name to keep
+// pre-existing behavior for callers that don't care about TypeORM gating.
+const findUnionOrIntersectionRoot = (types, typeormNamespaceNames) => {
+    let firstName = null;
+    for (const member of types) {
+        const name = (0, exports.getTypeReferenceRootName)(member, typeormNamespaceNames);
+        if (!name)
+            continue;
+        if (exports.TYPEORM_REPOSITORY_TYPES.has(name) ||
+            exports.TYPEORM_DATASOURCE_TYPES.has(name)) {
+            return name;
+        }
+        firstName ??= name;
+    }
+    return firstName;
+};
+// Returns the rightmost segment of a `TSQualifiedName` (`a.b.c` in type
+// position) — always an `Identifier` in valid TS, since the nesting lives
+// on `.left`. When `typeormNamespaceNames` is provided, the leftmost segment
+// is checked against the set of typeorm namespace locals and the rightmost
+// name is only returned if the qualifier matches — so `typeorm.Repository`
+// resolves to `"Repository"` while `other.Repository` returns null, avoiding
+// false-positive classification of identically-named types from other
+// modules. Without the parameter, any qualifier is accepted (legacy
+// behaviour for callers that only look at the rightmost segment).
+const getQualifiedNameRightmost = (node, typeormNamespaceNames) => {
+    const n = node;
+    if (n.right.type !== "Identifier")
+        return null;
+    if (typeormNamespaceNames !== undefined) {
+        // Walk down `.left` to the leftmost identifier (qualifier root).
+        let leftmost = n.left;
+        while (leftmost.type === "TSQualifiedName") {
+            leftmost = leftmost.left;
+        }
+        if (leftmost.type !== "Identifier")
+            return null;
+        if (!typeormNamespaceNames.has(leftmost.name))
+            return null;
+    }
+    return n.right.name;
+};
+const getTypeReferenceRootName = (node, typeormNamespaceNames) => {
+    if (!node)
+        return null;
+    if (node.type === "TSTypeReference") {
+        const n = node;
+        if (n.typeName.type === "Identifier") {
+            return n.typeName.name;
+        }
+        // `typeorm.Repository<User>` — TSTypeReference wraps a TSQualifiedName
+        // (namespace-import access). Without this branch,
+        // `import * as typeorm from "typeorm"` callers would be missed.
+        if (n.typeName.type === "TSQualifiedName") {
+            return getQualifiedNameRightmost(n.typeName, typeormNamespaceNames);
+        }
+    }
+    // `const X: typeof Repository` — TSTypeQuery wraps the referenced
+    // identifier in `exprName`. Without this branch, type-of annotations on
+    // typeorm-family types wouldn't register as repository bindings.
+    if (node.type === "TSTypeQuery") {
+        const n = node;
+        if (n.exprName.type === "Identifier") {
+            return n.exprName.name;
+        }
+        if (n.exprName.type === "TSQualifiedName") {
+            return getQualifiedNameRightmost(n.exprName, typeormNamespaceNames);
+        }
+    }
+    if (node.type === "TSTypeAnnotation") {
+        const n = node;
+        return (0, exports.getTypeReferenceRootName)(n.typeAnnotation, typeormNamespaceNames);
+    }
+    if (node.type === "TSUnionType" || node.type === "TSIntersectionType") {
+        return findUnionOrIntersectionRoot(node.types, typeormNamespaceNames);
+    }
+    return null;
+};
+exports.getTypeReferenceRootName = getTypeReferenceRootName;
+/**
+ * TypeORM Repository-family type names used to detect bindings that hold a
+ * Repository/EntityManager instance, so transforms can scope method renames
+ * (`.findByIds`, `.findOneById`, `.exist`, `.stats`) to those receivers.
+ */
+exports.TYPEORM_REPOSITORY_TYPES = new Set([
+    "Repository",
+    "TreeRepository",
+    "MongoRepository",
+    "EntityRepository",
+    "AbstractRepository",
+    "EntityManager",
+    "MongoEntityManager",
+    "SqljsEntityManager",
+]);
+/**
+ * Call shapes whose return value is a Repository/EntityManager:
+ *   `.getRepository(...)`, `.getMongoRepository(...)`, `.getTreeRepository(...)`,
+ *   `.getCustomRepository(...)`, `.manager` (property access, see caller).
+ */
+const REPOSITORY_RETURNING_METHODS = new Set([
+    "getRepository",
+    "getMongoRepository",
+    "getTreeRepository",
+    "getCustomRepository",
+]);
+// Returns true when `node` is a call expression whose callee ends in one of
+// the Repository-returning method names (e.g. `ds.getRepository(User)`).
+const isRepositoryReturningCall = (node) => {
+    if (node.type !== "CallExpression" &&
+        node.type !== "OptionalCallExpression")
+        return false;
+    const call = node;
+    const callee = call.callee;
+    if (callee.type !== "MemberExpression" &&
+        callee.type !== "OptionalMemberExpression")
+        return false;
+    const member = callee;
+    if (member.property.type === "Identifier") {
+        return REPOSITORY_RETURNING_METHODS.has(member.property.name);
+    }
+    if (member.computed) {
+        const name = (0, exports.getStringValue)(member.property);
+        return name !== null && REPOSITORY_RETURNING_METHODS.has(name);
+    }
+    return false;
+};
+/**
+ * TypeORM DataSource-family type names, recognized on local bindings so
+ * `dataSource.manager.X()` can be classified as a Repository receiver via
+ * the `.manager` accessor chain.
+ */
+exports.TYPEORM_DATASOURCE_TYPES = new Set([
+    "DataSource",
+    "Connection",
+]);
+// Classifies a type name into one of the tracked receiver buckets, or
+// returns null when the type isn't a TypeORM receiver we care about.
+const classifyRepositoryTypeName = (typeName, bindings, forThisMember) => {
+    if (exports.TYPEORM_REPOSITORY_TYPES.has(typeName)) {
+        return forThisMember ? bindings.classProps : bindings.locals;
+    }
+    if (exports.TYPEORM_DATASOURCE_TYPES.has(typeName)) {
+        return forThisMember
+            ? bindings.dataSourceClassProps
+            : bindings.dataSourceLocals;
+    }
+    return null;
+};
+// Records a typed identifier (variable / parameter) into the appropriate
+// binding bucket based on its TypeScript annotation.
+const recordTypedIdentifier = (id, annotation, bindings, typeormNamespaceNames) => {
+    if (id.type !== "Identifier")
+        return;
+    const typeName = (0, exports.getTypeReferenceRootName)(annotation, typeormNamespaceNames);
+    if (!typeName)
+        return;
+    const bucket = classifyRepositoryTypeName(typeName, bindings, false);
+    bucket?.add(id.name);
+};
+// Resolves the underlying `Identifier` inside a function parameter — peeling
+// `AssignmentPattern` (default params) and `TSParameterProperty` (constructor
+// parameter properties). `isParameterProperty` is true only for
+// TSParameterProperty, so callers can additionally record it as a
+// `this.<name>` class member.
+const unwrapParameterIdentifier = (param) => {
+    if (param.type === "Identifier") {
+        return {
+            id: param,
+            annotation: param.typeAnnotation ?? null,
+            isParameterProperty: false,
+        };
+    }
+    if (param.type !== "AssignmentPattern" &&
+        param.type !== "TSParameterProperty") {
+        return null;
+    }
+    const inner = param.left ??
+        param.parameter;
+    if (inner?.type !== "Identifier")
+        return null;
+    return {
+        id: inner,
+        annotation: inner.typeAnnotation ?? null,
+        isParameterProperty: param.type === "TSParameterProperty",
+    };
+};
+// Scans VariableDeclarators for typed identifiers and initializers that
+// return a Repository via `.getRepository()`-family calls.
+const collectDeclaratorBindings = (root, j, bindings, typeormNamespaceNames) => {
+    root.find(j.VariableDeclarator).forEach((p) => {
+        const id = p.node.id;
+        if (id.type !== "Identifier")
+            return;
+        recordTypedIdentifier(id, id.typeAnnotation ?? null, bindings, typeormNamespaceNames);
+        const init = p.node.init;
+        if (init && isRepositoryReturningCall(init)) {
+            bindings.locals.add(id.name);
+        }
+    });
+    root.find(j.AssignmentExpression).forEach((p) => {
+        const left = p.node.left;
+        if (left.type !== "Identifier")
+            return;
+        if (!isRepositoryReturningCall(p.node.right))
+            return;
+        bindings.locals.add(left.name);
+    });
+};
+// Scans function parameters on every function-like node. TSParameterProperty
+// bindings (`constructor(private repo: Repository<T>)`) are tracked in both
+// `locals` (for accesses inside the constructor body) AND `classProps` (for
+// `this.repo` accesses elsewhere in the class).
+const collectFunctionParamBindings = (root, j, bindings, typeormNamespaceNames) => {
+    const visit = (node) => {
+        for (const param of node.params) {
+            const unwrapped = unwrapParameterIdentifier(param);
+            if (!unwrapped)
+                continue;
+            recordTypedIdentifier(unwrapped.id, unwrapped.annotation, bindings, typeormNamespaceNames);
+            if (unwrapped.isParameterProperty &&
+                unwrapped.id.type === "Identifier") {
+                const typeName = (0, exports.getTypeReferenceRootName)(unwrapped.annotation, typeormNamespaceNames);
+                if (typeName) {
+                    const classBucket = classifyRepositoryTypeName(typeName, bindings, true);
+                    classBucket?.add(unwrapped.id.name);
+                }
+            }
+        }
+    };
+    root.find(j.FunctionDeclaration).forEach((p) => visit(p.node));
+    root.find(j.FunctionExpression).forEach((p) => visit(p.node));
+    root.find(j.ArrowFunctionExpression).forEach((p) => visit(p.node));
+    root.find(j.ClassMethod).forEach((p) => visit(p.node));
+    root.find(j.TSDeclareMethod).forEach((p) => visit(p.node));
+};
+// Scans class properties — `this.<name>` receivers are tracked separately
+// from local identifiers because the access shape is different.
+const collectClassPropertyBindings = (root, j, bindings, typeormNamespaceNames) => {
+    root.find(j.ClassProperty).forEach((p) => {
+        const key = p.node.key;
+        if (key.type !== "Identifier")
+            return;
+        const annotation = p.node.typeAnnotation ?? null;
+        const typeName = (0, exports.getTypeReferenceRootName)(annotation, typeormNamespaceNames);
+        if (!typeName)
+            return;
+        const bucket = classifyRepositoryTypeName(typeName, bindings, true);
+        bucket?.add(key.name);
+    });
+};
+const collectRepositoryBindings = (root, j) => {
+    const bindings = {
+        locals: new Set(),
+        classProps: new Set(),
+        dataSourceLocals: new Set(),
+        dataSourceClassProps: new Set(),
+    };
+    // Qualified type references like `typeorm.Repository<T>` must only be
+    // classified as TypeORM receivers when the qualifier is an actual
+    // namespace-local of `import * as typeorm from "typeorm"` (or the
+    // `import ns = require("typeorm")` variants). Without this gate, a
+    // file containing both a typeorm import and `Foo.Repository<T>` from
+    // some-other-lib would treat `Foo.Repository`-typed bindings as
+    // Repository receivers and mis-rewrite their method calls.
+    const typeormNamespaceNames = (0, exports.getNamespaceLocalNames)(root, j, "typeorm");
+    collectDeclaratorBindings(root, j, bindings, typeormNamespaceNames);
+    collectFunctionParamBindings(root, j, bindings, typeormNamespaceNames);
+    collectClassPropertyBindings(root, j, bindings, typeormNamespaceNames);
+    return bindings;
+};
+exports.collectRepositoryBindings = collectRepositoryBindings;
+/**
+ * Returns true when `receiver` is a MemberExpression-eligible node whose
+ * root identifier is a Repository-bound local or `this.X` where `X` is a
+ * Repository-typed class property. Also accepts fresh inline
+ * `.getRepository(...)` call-expression receivers and DataSource-typed
+ * bindings dereferenced via `.manager` (e.g. `ds.manager.findByIds(...)`).
+ *
+ * When the file contains no Repository-typed bindings at all (no typed
+ * variables, no `.getRepository()` assignments, no Repository class
+ * properties), falls back to permissive matching — the codemod has no
+ * type signal and must trust the historical `fileImportsFrom("typeorm")`
+ * file-level guard. Callers should add negative fixtures to pin the
+ * common false-positive vectors.
+ */
+// Matches `this.<prop>` where `<prop>` is a tracked DataSource class prop.
+const isThisDataSourceProp = (node, dsClassProps) => (node.type === "MemberExpression" ||
+    node.type === "OptionalMemberExpression") &&
+    node.object.type === "ThisExpression" &&
+    node.property.type === "Identifier" &&
+    (dsClassProps?.has(node.property.name) ??
+        false);
+// `<ds>.manager` — DataSource local/class-prop's `.manager` accessor
+// returns an EntityManager, whose find-family methods match Repository's.
+const isDataSourceManagerChain = (member, dsLocals, dsClassProps) => {
+    if (member.property.type !== "Identifier" ||
+        member.property.name !== "manager") {
+        return false;
+    }
+    if (member.object.type === "Identifier" &&
+        (dsLocals?.has(member.object.name) ?? false)) {
+        return true;
+    }
+    return isThisDataSourceProp(member.object, dsClassProps);
+};
+// Classifies MemberExpression / OptionalMemberExpression receivers.
+const classifyMemberReceiver = (receiver, bindings, noBindingsFound) => {
+    const member = receiver;
+    if (isDataSourceManagerChain(member, bindings.dataSourceLocals, bindings.dataSourceClassProps)) {
+        return true;
+    }
+    if (member.object.type === "ThisExpression" &&
+        member.property.type === "Identifier") {
+        if (bindings.classProps.has(member.property.name))
+            return true;
+        return noBindingsFound;
+    }
+    // Chained access like `service.userRepo.findByIds(...)` — accept only
+    // when we have no binding info to disambiguate.
+    return noBindingsFound;
+};
+const isRepositoryReceiver = (receiver, bindings) => {
+    const noBindingsFound = bindings.locals.size === 0 &&
+        bindings.classProps.size === 0 &&
+        (bindings.dataSourceLocals?.size ?? 0) === 0 &&
+        (bindings.dataSourceClassProps?.size ?? 0) === 0;
+    if (receiver.type === "Identifier") {
+        if (bindings.locals.has(receiver.name))
+            return true;
+        return noBindingsFound;
+    }
+    if (receiver.type === "MemberExpression" ||
+        receiver.type === "OptionalMemberExpression") {
+        return classifyMemberReceiver(receiver, bindings, noBindingsFound);
+    }
+    if (receiver.type === "CallExpression" ||
+        receiver.type === "OptionalCallExpression") {
+        if (isRepositoryReturningCall(receiver))
+            return true;
+        return noBindingsFound;
+    }
+    return noBindingsFound;
+};
+exports.isRepositoryReceiver = isRepositoryReceiver;
 //# sourceMappingURL=ast-helpers.js.map