@typeorm/codemod 1.0.0 → 1.0.2

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.forEachIdentifierParam = 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.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,14 +30,174 @@ exports.setStringValue = setStringValue;
 const isIdentifier = (node) => node.type === "Identifier";
 exports.isIdentifier = isIdentifier;
 /**
- * Checks whether the file contains an import from the given module.
+ * 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) => {
-    return (root.find(j.ImportDeclaration, {
-        source: { value: moduleName },
-    }).length > 0);
+    const prefix = `${moduleName}/`;
+    const matchesModule = (source) => typeof source === "string" &&
+        (source === moduleName || source.startsWith(prefix));
+    // ESM: import ... from "typeorm[/subpath]"
+    if (root
+        .find(j.ImportDeclaration)
+        .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;
+        return (ref.type === "TSExternalModuleReference" &&
+            matchesModule((0, exports.getStringValue)(ref.expression)));
+    })) {
+        return true;
+    }
+    // CommonJS: require("typeorm[/subpath]")
+    return root
+        .find(j.CallExpression, {
+        callee: { type: "Identifier", name: "require" },
+    })
+        .some((path) => {
+        const [arg] = path.node.arguments;
+        return arg !== undefined && matchesModule((0, exports.getStringValue)(arg));
+    });
 };
 exports.fileImportsFrom = fileImportsFrom;
+/**
+ * Returns the set of local identifiers bound to a given named export.
+ * Handles ESM direct/aliased imports and CommonJS destructured requires:
+ *
+ *   import { RelationCount } from "typeorm"         → { "RelationCount" }
+ *   import { RelationCount as RC } from "typeorm"   → { "RC" }
+ *   const { RelationCount } = require("typeorm")    → { "RelationCount" }
+ *   const { RelationCount: RC } = require("typeorm")→ { "RC" }
+ */
+const getLocalNamesForImport = (root, j, moduleName, importedName) => {
+    const localNames = new Set();
+    // ESM: `import { X [as Y] } from "moduleName"`
+    root.find(j.ImportDeclaration, {
+        source: { value: moduleName },
+    }).forEach((importPath) => {
+        for (const spec of importPath.node.specifiers ?? []) {
+            if (spec.type !== "ImportSpecifier" ||
+                spec.imported.type !== "Identifier" ||
+                spec.imported.name !== importedName) {
+                continue;
+            }
+            const local = spec.local ?? spec.imported;
+            if (local.type === "Identifier") {
+                localNames.add(local.name);
+            }
+        }
+    });
+    // CommonJS: `const { X [: Y] } = require("moduleName")`
+    root.find(j.CallExpression, {
+        callee: { type: "Identifier", name: "require" },
+    }).forEach((callPath) => {
+        const [arg] = callPath.node.arguments;
+        if (!arg || (0, exports.getStringValue)(arg) !== moduleName)
+            return;
+        const parent = callPath.parent.node;
+        if (parent.type !== "VariableDeclarator")
+            return;
+        const id = parent.id;
+        if (id.type !== "ObjectPattern")
+            return;
+        for (const prop of id.properties) {
+            if (prop.type !== "Property" && prop.type !== "ObjectProperty") {
+                continue;
+            }
+            if (prop.key.type !== "Identifier" ||
+                prop.key.name !== importedName) {
+                continue;
+            }
+            // Extract the binding name from each destructuring variant:
+            //   { X }              → "X"            (Identifier)
+            //   { X: Y }           → "Y"            (Identifier alias)
+            //   { X = fallback }   → "X"            (AssignmentPattern, shorthand)
+            //   { X: Y = fallback }→ "Y"            (AssignmentPattern, aliased)
+            let localName = prop.key.name;
+            if (prop.value.type === "Identifier") {
+                localName = prop.value.name;
+            }
+            else if (prop.value.type === "AssignmentPattern" &&
+                prop.value.left.type === "Identifier") {
+                localName = prop.value.left.name;
+            }
+            localNames.add(localName);
+        }
+    });
+    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`.
+ */
+const getNamespaceLocalNames = (root, j, moduleName) => {
+    const localNames = new Set();
+    // ESM: `import * as ns from "moduleName"`
+    root.find(j.ImportDeclaration, {
+        source: { value: moduleName },
+    }).forEach((importPath) => {
+        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")`
+    root.find(j.TSImportEqualsDeclaration).forEach((importPath) => {
+        const ref = importPath.node.moduleReference;
+        if (ref.type !== "TSExternalModuleReference")
+            return;
+        if ((0, exports.getStringValue)(ref.expression) !== moduleName)
+            return;
+        if (importPath.node.id?.type === "Identifier") {
+            localNames.add(importPath.node.id.name);
+        }
+    });
+    // CommonJS: `const ns = require("moduleName")`
+    root.find(j.CallExpression, {
+        callee: { type: "Identifier", name: "require" },
+    }).forEach((callPath) => {
+        const [arg] = callPath.node.arguments;
+        if (!arg || (0, exports.getStringValue)(arg) !== moduleName)
+            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.
@@ -57,22 +217,62 @@ const forEachIdentifierParam = (root, j, callback) => {
     });
 };
 exports.forEachIdentifierParam = forEachIdentifierParam;
+/**
+ * TypeORM column-family decorator names. Exposed so decorator-scoped
+ * transforms can narrow their match set and skip unrelated decorators like
+ * Angular's `@Input` or class-validator's `@IsDefined` without relying on a
+ * file-level `fileImportsFrom` guard.
+ */
+exports.TYPEORM_COLUMN_DECORATORS = new Set([
+    "Column",
+    "PrimaryColumn",
+    "PrimaryGeneratedColumn",
+    "VersionColumn",
+    "CreateDateColumn",
+    "UpdateDateColumn",
+    "DeleteDateColumn",
+    "ObjectIdColumn",
+    "ViewColumn",
+]);
+/**
+ * Expands a set of exported names into the local bindings each one has in
+ * 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.
+ */
+const expandLocalNamesForImports = (root, j, moduleName, importedNames) => {
+    const expanded = new Set();
+    for (const name of importedNames) {
+        for (const local of (0, exports.getLocalNamesForImport)(root, j, moduleName, name)) {
+            expanded.add(local);
+        }
+    }
+    return expanded;
+};
+exports.expandLocalNamesForImports = expandLocalNamesForImports;
 /**
  * Traverses ClassProperty decorators and calls `callback` for each
  * ObjectExpression argument found in decorator call expressions.
  *
- * This avoids duplicating the decorator-traversal boilerplate across
- * multiple transforms.
+ * Pass `decoratorNames` to restrict the traversal to a known set of callees
+ * (e.g. TypeORM's column decorators). Without it, every decorator-with-object
+ * on every class property is visited.
  */
-const forEachDecoratorObjectArg = (root, j, callback) => {
+const forEachDecoratorObjectArg = (root, j, callback, decoratorNames) => {
     root.find(j.ClassProperty).forEach((path) => {
-        // ast-types omits `decorators` from ClassProperty — extend it
         const node = path.node;
         if (!node.decorators)
             return;
         for (const decorator of node.decorators) {
             if (decorator.expression.type !== "CallExpression")
                 continue;
+            if (decoratorNames) {
+                const callee = decorator.expression.callee;
+                if (callee.type !== "Identifier" ||
+                    !decoratorNames.has(callee.name)) {
+                    continue;
+                }
+            }
             for (const arg of decorator.expression.arguments) {
                 if (arg.type !== "ObjectExpression")
                     continue;
@@ -82,23 +282,153 @@ const forEachDecoratorObjectArg = (root, j, callback) => {
     });
 };
 exports.forEachDecoratorObjectArg = forEachDecoratorObjectArg;
+/**
+ * Returns the key name for an `ObjectProperty` / `Property` node. Handles
+ * both identifier keys (`name`) and string-literal keys (`"name"`); returns
+ * null for computed, numeric, or otherwise non-string 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;
+    if (prop.key.type === "Identifier")
+        return prop.key.name;
+    return (0, exports.getStringValue)(prop.key);
+};
+exports.getObjectPropertyKeyName = getObjectPropertyKeyName;
+/**
+ * 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`) — 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",
+]);
+/**
+ * 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") &&
-            prop.key.type === "Identifier" &&
-            propertyNames.has(prop.key.name)) {
-            return false;
-        }
-        return true;
-    });
+    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.
@@ -128,6 +458,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`.
@@ -150,4 +551,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