@typeorm/codemod 1.0.1 → 1.0.3-nightly.20261009

package/dist/transforms/v1/connection-to-datasource.js

@@ -7,11 +7,11 @@ exports.fn = exports.connectionToDataSource = exports.description = exports.name
 const node_path_1 = __importDefault(require("node:path"));
 const ast_helpers_1 = require("../ast-helpers");
 /**
- * Unwraps common TypeScript expression wrappers (`as`, `!`, parens) around
- * an identifier and returns the identifier's name. Used so accessor-chain
- * tracking also recognizes `(ds as DataSource).manager`, `ds!.manager`, and
- * `(ds).manager` — patterns jscodeshift would otherwise miss because the
- * surface node is a `TSAsExpression` / `TSNonNullExpression` / paren.
+ * Unwraps common TypeScript expression wrappers around an identifier and
+ * returns the identifier's name. Handles `ds as DataSource`, `ds!`,
+ * `ds satisfies DataSource`, and the angle-bracket cast `<DataSource>ds`;
+ * identifiers reached through these wrappers are tracked alongside bare
+ * identifiers so accessor-chain transforms don't miss them.
  */
 const unwrapIdentifierName = (node) => {
     let current = node;
@@ -28,33 +28,208 @@ const unwrapIdentifierName = (node) => {
         return null;
     }
 };
+// Builds `Extract<DataSourceOptions, { type: "<literal>" }>` as a
+// TSTypeReference node. Parses a synthetic type alias and pulls out its
+// right-hand side so the returned node carries source-location info —
+// recast otherwise splits builder-made nodes across lines because they
+// have no `loc`, and Prettier preserves those line breaks verbatim.
+// Drivers that share a literal with a sibling (mysql / mariadb both on
+// MysqlDataSourceOptions) emit a union so `Extract` matches the
+// declared union-typed `type` field.
+const buildExtractDataSourceOptions = (j, literals) => {
+    const unionLiteral = literals.map((lit) => `"${lit}"`).join(" | ");
+    const source = `type __TypeormCodemodExtract = Extract<DataSourceOptions, { type: ${unionLiteral} }>`;
+    const aliasPath = j(source).find(j.TSTypeAliasDeclaration).paths()[0];
+    return aliasPath.node
+        .typeAnnotation;
+};
+// Ensures `import type { DataSourceOptions } from "typeorm"` is present.
+// Augments an existing `import type` from `"typeorm"` when one exists, or
+// emits a new line after the last import otherwise. Idempotent — a second
+// run finds `DataSourceOptions` already imported and returns.
+const ensureDataSourceOptionsTypeImport = (root, j) => {
+    const typeormImports = root.find(j.ImportDeclaration, {
+        source: { value: "typeorm" },
+    });
+    let hasIt = false;
+    typeormImports.forEach((p) => {
+        p.node.specifiers?.forEach((spec) => {
+            if (spec.type === "ImportSpecifier" &&
+                spec.imported.type === "Identifier" &&
+                spec.imported.name === "DataSourceOptions") {
+                hasIt = true;
+            }
+        });
+    });
+    if (hasIt)
+        return;
+    // Prefer augmenting an existing `import type { ... } from "typeorm"`
+    // — but only when that declaration is a pure named-specifier form.
+    // Pushing an `ImportSpecifier` into a namespace or default-only import
+    // (`import type * as ns` / `import type D`) produces invalid TS.
+    let augmented = false;
+    typeormImports.forEach((p) => {
+        if (augmented)
+            return;
+        if (p.node.importKind !== "type")
+            return;
+        const specifiers = p.node.specifiers ?? [];
+        const onlyNamed = specifiers.every((s) => s.type === "ImportSpecifier");
+        if (!onlyNamed)
+            return;
+        p.node.specifiers?.push(j.importSpecifier(j.identifier("DataSourceOptions")));
+        augmented = true;
+    });
+    if (augmented)
+        return;
+    const newImport = j.importDeclaration([j.importSpecifier(j.identifier("DataSourceOptions"))], j.literal("typeorm"));
+    newImport.importKind = "type";
+    const allImports = root.find(j.ImportDeclaration);
+    if (allImports.length > 0) {
+        allImports.at(-1).insertAfter(newImport);
+    }
+    else {
+        root.find(j.Program).forEach((p) => {
+            p.node.body.unshift(newImport);
+        });
+    }
+};
+// Resolves the inner Identifier of a TSParameterProperty's `.parameter`,
+// handling both the plain `Identifier` and default-valued `AssignmentPattern`
+// forms. Returns null when neither shape applies.
+const resolveTSParameterPropertyIdentifier = (inner) => {
+    if (inner.type === "Identifier")
+        return inner;
+    if (inner.type === "AssignmentPattern" &&
+        inner.left.type === "Identifier") {
+        return inner.left;
+    }
+    return null;
+};
+// Rename `connection` to `dataSource` on every ObjectProperty in `arg`.
+// Returns true when at least one property was renamed. The shorthand
+// `{ connection }` becomes `{ dataSource: connection }` — the variable
+// reference stays intact and the object drops the shorthand flag.
+const renameConnectionKeyToDataSource = (arg) => {
+    let changed = false;
+    for (const prop of arg.properties) {
+        if (prop.type !== "Property" && prop.type !== "ObjectProperty")
+            continue;
+        const p = prop;
+        if (p.key.type !== "Identifier" || p.key.name !== "connection")
+            continue;
+        p.key.name = "dataSource";
+        if (p.shorthand)
+            p.shorthand = false;
+        changed = true;
+    }
+    return changed;
+};
+// Remove every `connection` ObjectProperty from `arg`. Returns true when
+// at least one property was dropped.
+const dropConnectionKey = (arg) => {
+    const before = arg.properties.length;
+    arg.properties = arg.properties.filter((prop) => {
+        if (prop.type !== "Property" && prop.type !== "ObjectProperty") {
+            return true;
+        }
+        const p = prop;
+        return !(p.key.type === "Identifier" && p.key.name === "connection");
+    });
+    return arg.properties.length !== before;
+};
+// Walks every `new X(...)` whose callee is one of the tracked metadata
+// constructors and rewrites the `connection` option key according to the
+// constructor's v1 semantics (rename vs drop).
+const rewriteMetadataConstructors = (root, j, entityMetadataLocalNames, indirectDataSourceLocalNames, hasChanges) => {
+    root.find(j.NewExpression).forEach((path) => {
+        const callee = path.node.callee;
+        if (callee.type !== "Identifier")
+            return;
+        const name = callee.name;
+        const isEntityMetadata = entityMetadataLocalNames.has(name);
+        const isIndirect = indirectDataSourceLocalNames.has(name);
+        if (!isEntityMetadata && !isIndirect)
+            return;
+        const [arg] = path.node.arguments;
+        if (arg?.type !== "ObjectExpression")
+            return;
+        const changed = isEntityMetadata
+            ? renameConnectionKeyToDataSource(arg)
+            : dropConnectionKey(arg);
+        if (changed)
+            hasChanges = true;
+    });
+    return hasChanges;
+};
 exports.name = node_path_1.default.basename(__filename, node_path_1.default.extname(__filename));
 exports.description = "migrate from `Connection` to `DataSource`";
 const connectionToDataSource = (file, api) => {
     const j = api.jscodeshift;
     const root = j(file.source);
+    // File-level scope gate: without a typeorm import anywhere in the file,
+    // occurrences of `Connection` / `DataSource` must belong to an
+    // unrelated library (e.g. mongoose `new Connection().connect()`) and
+    // this transform must not touch them.
+    if (!(0, ast_helpers_1.fileImportsFrom)(root, j, "typeorm"))
+        return undefined;
     let hasChanges = false;
+    // Generic type renames. Driver-specific *ConnectionOptions types are
+    // handled separately via the Extract rewrite below — they're not
+    // top-level exports from `"typeorm"`, so the codemod can't just rename
+    // the identifier and leave a broken import behind.
     const typeRenames = {
         Connection: "DataSource",
         ConnectionOptions: "DataSourceOptions",
         BaseConnectionOptions: "BaseDataSourceOptions",
-        MysqlConnectionOptions: "MysqlDataSourceOptions",
-        MariaDbConnectionOptions: "MariaDbDataSourceOptions",
-        PostgresConnectionOptions: "PostgresDataSourceOptions",
-        CockroachConnectionOptions: "CockroachDataSourceOptions",
-        SqlServerConnectionOptions: "SqlServerDataSourceOptions",
-        OracleConnectionOptions: "OracleDataSourceOptions",
-        SqliteConnectionOptions: "BetterSqlite3DataSourceOptions",
-        BetterSqlite3ConnectionOptions: "BetterSqlite3DataSourceOptions",
-        SapConnectionOptions: "SapDataSourceOptions",
-        MongoConnectionOptions: "MongoDataSourceOptions",
-        CordovaConnectionOptions: "CordovaDataSourceOptions",
-        NativescriptConnectionOptions: "NativescriptDataSourceOptions",
-        ReactNativeConnectionOptions: "ReactNativeDataSourceOptions",
-        ExpoConnectionOptions: "ExpoDataSourceOptions",
-        AuroraMysqlConnectionOptions: "AuroraMysqlDataSourceOptions",
-        AuroraPostgresConnectionOptions: "AuroraPostgresDataSourceOptions",
-        SpannerConnectionOptions: "SpannerDataSourceOptions",
+    };
+    // Maps every driver-specific options type name (both the v0 form ending
+    // in `ConnectionOptions` and the v1 form ending in `DataSourceOptions`)
+    // to the `type` literal(s) the driver carries. Used to rewrite type
+    // references to `Extract<DataSourceOptions, { type: "..." }>` so users
+    // don't need deep-path imports like `typeorm/driver/sap/...` for a
+    // single field annotation.
+    const driverOptionTypeLiterals = {
+        AuroraMysqlConnectionOptions: ["aurora-mysql"],
+        AuroraMysqlDataSourceOptions: ["aurora-mysql"],
+        AuroraPostgresConnectionOptions: ["aurora-postgres"],
+        AuroraPostgresDataSourceOptions: ["aurora-postgres"],
+        BetterSqlite3ConnectionOptions: ["better-sqlite3"],
+        BetterSqlite3DataSourceOptions: ["better-sqlite3"],
+        CapacitorConnectionOptions: ["capacitor"],
+        CapacitorDataSourceOptions: ["capacitor"],
+        CockroachConnectionOptions: ["cockroachdb"],
+        CockroachDataSourceOptions: ["cockroachdb"],
+        CordovaConnectionOptions: ["cordova"],
+        CordovaDataSourceOptions: ["cordova"],
+        ExpoConnectionOptions: ["expo"],
+        ExpoDataSourceOptions: ["expo"],
+        MongoConnectionOptions: ["mongodb"],
+        MongoDataSourceOptions: ["mongodb"],
+        // MySQL options cover both `type: "mysql"` and `type: "mariadb"`.
+        // Using a single literal would make `Extract` return `never`, so we
+        // emit a union `{ type: "mysql" | "mariadb" }` that matches.
+        MysqlConnectionOptions: ["mysql", "mariadb"],
+        MysqlDataSourceOptions: ["mysql", "mariadb"],
+        NativescriptConnectionOptions: ["nativescript"],
+        NativescriptDataSourceOptions: ["nativescript"],
+        OracleConnectionOptions: ["oracle"],
+        OracleDataSourceOptions: ["oracle"],
+        PostgresConnectionOptions: ["postgres"],
+        PostgresDataSourceOptions: ["postgres"],
+        ReactNativeConnectionOptions: ["react-native"],
+        ReactNativeDataSourceOptions: ["react-native"],
+        SapConnectionOptions: ["sap"],
+        SapDataSourceOptions: ["sap"],
+        // The v0 `sqlite` driver was removed; its options type maps to
+        // `better-sqlite3`'s `type` literal in v1.
+        SqliteConnectionOptions: ["better-sqlite3"],
+        SpannerConnectionOptions: ["spanner"],
+        SpannerDataSourceOptions: ["spanner"],
+        SqljsConnectionOptions: ["sqljs"],
+        SqljsDataSourceOptions: ["sqljs"],
+        SqlServerConnectionOptions: ["mssql"],
+        SqlServerDataSourceOptions: ["mssql"],
     };
     const methodRenames = {
         connect: "initialize",
@@ -75,6 +250,20 @@ const connectionToDataSource = (file, api) => {
         "SoftDeleteQueryBuilder",
         "RelationQueryBuilder",
         "EntityMetadata",
+        // Subscriber event types — all extend BaseEvent which deprecated
+        // `connection` in favor of `dataSource`. Covers the usual destructure
+        // pattern in subscriber handlers: `const { connection } = event`.
+        "BaseEvent",
+        "InsertEvent",
+        "UpdateEvent",
+        "RemoveEvent",
+        "SoftRemoveEvent",
+        "RecoverEvent",
+        "LoadEvent",
+        "QueryEvent",
+        "TransactionStartEvent",
+        "TransactionCommitEvent",
+        "TransactionRollbackEvent",
     ]);
     // Metadata types whose v0.3 `.connection` getter was removed entirely in
     // v1 (renamed in #12249). Access now goes through `.entityMetadata.dataSource`
@@ -84,25 +273,16 @@ const connectionToDataSource = (file, api) => {
         "ColumnMetadata",
         "IndexMetadata",
     ]);
-    // Full-path overrides for deep imports where the v1 module also moved
-    // to a different directory. The generic last-segment swap below cannot
-    // handle these because swapping only the filename leaves the old
-    // directory intact (e.g. `typeorm/driver/sqlite/` was removed in v1).
-    const deepPathRewrites = {
-        "typeorm/driver/sqlite/SqliteConnectionOptions": "typeorm/driver/better-sqlite3/BetterSqlite3DataSourceOptions",
-    };
     const localRenames = new Map();
     const typeormPathPrefix = "typeorm/";
     // Returns the rewritten module path for a `typeorm[/...]` import, or the
-    // original when no rewrite applies. Consults `deepPathRewrites` first for
-    // cross-directory moves, then falls back to swapping the last path
-    // segment when it's an exact rename key.
+    // original when no rewrite applies. Swaps the last path segment when
+    // that segment is an exact rename key (e.g. `.../Connection` →
+    // `.../DataSource`). Driver-specific options-type imports are handled
+    // by the Extract rewrite and never reach this helper.
     const rewriteTypeormPath = (source) => {
         if (!source.startsWith(typeormPathPrefix))
             return source;
-        const fullPathRewrite = deepPathRewrites[source];
-        if (fullPathRewrite)
-            return fullPathRewrite;
         const lastSlash = source.lastIndexOf("/");
         // No slash or trailing slash → no segment to rewrite
         if (lastSlash === -1 || lastSlash === source.length - 1)
@@ -131,13 +311,10 @@ const connectionToDataSource = (file, api) => {
             const hasAlias = spec.local?.type === "Identifier" &&
                 spec.local.name !== oldImported;
             spec.imported.name = newImported;
-            if (hasAlias) {
-                // Alias stays; user chose it deliberately. The alias already
-                // refers to the renamed import so usages don't need rewriting.
-            }
-            else {
-                // No alias — propagate the rename to the local binding and
-                // record it for the NewExpression / TSTypeReference loop.
+            // With an alias (`Connection as Foo`), the local binding already
+            // points to the renamed import — usages need no rewriting. Without
+            // one, propagate the rename to the local binding.
+            if (!hasAlias) {
                 const localName = spec.local?.type === "Identifier"
                     ? spec.local.name
                     : oldImported;
@@ -151,7 +328,10 @@ const connectionToDataSource = (file, api) => {
         // Dedupe specifiers that now share the same imported name after the
         // rename — e.g. `import { Connection, DataSource }` would otherwise
         // emit `import { DataSource, DataSource }`. Keep the first occurrence
-        // of each imported name and drop subsequent duplicates.
+        // of each (importKind, imported, local) tuple. Per-specifier
+        // `importKind` ("type" vs unset for value) participates so
+        // `import { DataSource, type DataSource }` keeps both — they are
+        // distinct specifiers TS 4.5+ recognizes.
         if (path.node.specifiers) {
             const seen = new Set();
             path.node.specifiers = path.node.specifiers.filter((spec) => {
@@ -159,7 +339,11 @@ const connectionToDataSource = (file, api) => {
                     spec.imported.type !== "Identifier") {
                     return true;
                 }
-                const key = `${spec.imported.name}::${spec.local?.type === "Identifier" ? spec.local.name : ""}`;
+                const specKind = spec.importKind === "type"
+                    ? "type:"
+                    : "";
+                const localName = spec.local?.type === "Identifier" ? spec.local.name : "";
+                const key = `${specKind}${spec.imported.name}::${localName}`;
                 if (seen.has(key)) {
                     hasChanges = true;
                     return false;
@@ -174,6 +358,136 @@ const connectionToDataSource = (file, api) => {
             hasChanges = true;
         }
     });
+    // Driver-specific options types aren't top-level exports from "typeorm",
+    // and deep-path imports like `"typeorm/driver/sap/SapDataSourceOptions"`
+    // are brittle across refactors. Rewrite every reference to
+    // `Extract<DataSourceOptions, { type: "<driver>" }>` so users only need
+    // the union exported from the index. Handles both v0 (`SapConnectionOptions`)
+    // and v1 (`SapDataSourceOptions`) names, and aliased imports.
+    const driverOptionLocalBindings = new Map();
+    root.find(j.ImportDeclaration).forEach((importPath) => {
+        const importSource = importPath.node.source.value;
+        if (typeof importSource !== "string" ||
+            (importSource !== "typeorm" &&
+                !importSource.startsWith(typeormPathPrefix))) {
+            return;
+        }
+        const specifiers = importPath.node.specifiers ?? [];
+        const kept = specifiers.filter((spec) => {
+            if (spec.type !== "ImportSpecifier" ||
+                spec.imported.type !== "Identifier") {
+                return true;
+            }
+            const literals = driverOptionTypeLiterals[spec.imported.name];
+            if (!literals)
+                return true;
+            const localName = spec.local?.type === "Identifier"
+                ? spec.local.name
+                : spec.imported.name;
+            driverOptionLocalBindings.set(localName, literals);
+            return false;
+        });
+        if (kept.length !== specifiers.length) {
+            importPath.node.specifiers = kept;
+            hasChanges = true;
+            if (kept.length === 0)
+                j(importPath).remove();
+        }
+    });
+    if (driverOptionLocalBindings.size > 0) {
+        // Walk every type reference in the file and replace tracked local
+        // bindings with an inline Extract<DataSourceOptions, { type: ... }>
+        // expression. TS narrowing via the `type` discriminator still picks
+        // the correct driver-specific fields.
+        root.find(j.TSTypeReference).forEach((refPath) => {
+            const typeName = refPath.node.typeName;
+            if (typeName.type !== "Identifier")
+                return;
+            const literals = driverOptionLocalBindings.get(typeName.name);
+            if (!literals)
+                return;
+            j(refPath).replaceWith(buildExtractDataSourceOptions(j, literals));
+            hasChanges = true;
+        });
+        // Emit / augment `import type { DataSourceOptions } from "typeorm"`
+        // so the Extract expressions resolve.
+        ensureDataSourceOptionsTypeImport(root, j);
+    }
+    // Re-export source paths (`export { X } from "typeorm/driver/..."` and
+    // `export * from "typeorm/driver/..."`) follow the same deep-path rewrite
+    // rules as import sources so barrel files that re-export renamed modules
+    // end up pointing at the v1 path.
+    root.find(j.ExportNamedDeclaration).forEach((exportPath) => {
+        const source = exportPath.node.source?.value;
+        if (typeof source !== "string")
+            return;
+        const rewritten = rewriteTypeormPath(source);
+        if (rewritten !== source) {
+            exportPath.node.source.value = rewritten;
+            hasChanges = true;
+        }
+    });
+    root.find(j.ExportAllDeclaration).forEach((exportPath) => {
+        const source = exportPath.node.source.value;
+        if (typeof source !== "string")
+            return;
+        const rewritten = rewriteTypeormPath(source);
+        if (rewritten !== source) {
+            exportPath.node.source.value = rewritten;
+            hasChanges = true;
+        }
+    });
+    // Cross-import dedup: the rewrites above can produce two ImportDeclarations
+    // that now target the same module with the same specifier (e.g. an
+    // existing `import type { BetterSqlite3DataSourceOptions }` plus a
+    // newly-renamed `import type { SqliteConnectionOptions }` from the old
+    // `sqlite/` path). Drop any later declaration whose (source, specifier
+    // set) tuple is already covered by an earlier one.
+    const seenImportKeys = new Map();
+    root.find(j.ImportDeclaration).forEach((importPath) => {
+        const source = importPath.node.source.value;
+        if (typeof source !== "string")
+            return;
+        const isTypeOnly = importPath.node.importKind === "type";
+        const specifiers = importPath.node.specifiers ?? [];
+        const specifierKey = specifiers
+            .map((spec) => {
+            const specType = spec.type;
+            if (specType === "ImportSpecifier") {
+                const s = spec;
+                const imported = s.imported.type === "Identifier"
+                    ? (s.imported.name ?? "")
+                    : "";
+                const local = s.local?.type === "Identifier"
+                    ? (s.local.name ?? "")
+                    : imported;
+                // Per-specifier importKind distinguishes
+                // `import { type X }` from `import { X }` — the two
+                // bindings have different runtime semantics and must
+                // not collapse into the same dedup key.
+                const kind = s.importKind === "type" ? "type:" : "";
+                return `named:${kind}${imported}->${local}`;
+            }
+            if (specType === "ImportDefaultSpecifier") {
+                const s = spec;
+                return `default:${s.local?.type === "Identifier" ? (s.local.name ?? "") : ""}`;
+            }
+            if (specType === "ImportNamespaceSpecifier") {
+                const s = spec;
+                return `namespace:${s.local?.type === "Identifier" ? (s.local.name ?? "") : ""}`;
+            }
+            return specType;
+        })
+            .sort()
+            .join("|");
+        const key = `${isTypeOnly ? "type:" : ""}${source}::${specifierKey}`;
+        if (seenImportKeys.has(key)) {
+            j(importPath).remove();
+            hasChanges = true;
+            return;
+        }
+        seenImportKeys.set(key, importPath.node);
+    });
     // Rewrite a single `{ X [: Y] }` property in a destructured require of
     // typeorm. Records the local binding in `localRenames` so the shared
     // NewExpression/TSTypeReference rewrite loop below picks it up.
@@ -223,6 +537,11 @@ const connectionToDataSource = (file, api) => {
                 hasChanges = true;
         }
     });
+    // Rename re-exports from "typeorm" (e.g. barrel files that do
+    // `export { Connection } from "typeorm"`)
+    if ((0, ast_helpers_1.renameReExportSpecifiers)(root, j, "typeorm", typeRenames)) {
+        hasChanges = true;
+    }
     for (const [oldName, newName] of localRenames) {
         // TSTypeReference (e.g. const x: Connection = ...)
         root.find(j.TSTypeReference, {
@@ -262,10 +581,15 @@ const connectionToDataSource = (file, api) => {
     // Expand to the set of LOCAL bindings — covers aliased ESM imports
     // (`import { Connection as LegacyConn }`) and aliased CJS destructures
     // (`const { Connection: LegacyConn } = require("typeorm")`) so code
-    // using the alias still gets `.connect()` → `.initialize()`.
+    // using the alias still gets `.connect()` → `.initialize()`. When no
+    // alias is in play the set simply contains `Connection` / `DataSource`
+    // from the plain imports.
     const connectionTypeNames = (0, ast_helpers_1.expandLocalNamesForImports)(root, j, "typeorm", new Set(["Connection", "DataSource"]));
-    connectionTypeNames.add("Connection");
-    connectionTypeNames.add("DataSource");
+    // Namespace-import locals for "typeorm" — used to gate qualified type
+    // references (`typeorm.Repository<T>`) inside `getTypeReferenceRootName`
+    // so array-element lookups don't mistake `Foo.Repository[]` from another
+    // library for a TypeORM receiver.
+    const typeormNamespaceNames = (0, ast_helpers_1.getNamespaceLocalNames)(root, j, "typeorm");
     const connectionVarNames = new Set();
     root.find(j.VariableDeclarator).forEach((path) => {
         const init = path.node.init;
@@ -293,32 +617,62 @@ const connectionToDataSource = (file, api) => {
     });
     (0, ast_helpers_1.forEachIdentifierParam)(root, j, collectDataSourceTyped);
     // Rename method calls: .connect() → .initialize(), .close() → .destroy()
-    // Only on variables known to be Connection/DataSource instances
-    for (const [oldMethod, newMethod] of Object.entries(methodRenames)) {
-        root.find(j.CallExpression, {
-            callee: {
-                type: "MemberExpression",
-                property: { name: oldMethod },
-            },
-        }).forEach((path) => {
-            if (path.node.callee.type === "MemberExpression" &&
-                path.node.callee.property.type === "Identifier") {
-                const objName = unwrapIdentifierName(path.node.callee.object);
-                if (objName && connectionVarNames.has(objName)) {
+    // Only on receivers known to be Connection/DataSource instances —
+    // covered after typed-var AND `this.<member>` collection below.
+    const renameDataSourceMethods = () => {
+        for (const [oldMethod, newMethod] of Object.entries(methodRenames)) {
+            root.find(j.CallExpression, {
+                callee: {
+                    type: "MemberExpression",
+                    property: { name: oldMethod },
+                },
+            }).forEach((path) => {
+                if (path.node.callee.type === "MemberExpression" &&
+                    path.node.callee.property.type === "Identifier" &&
+                    receiverIsIn(path.node.callee.object, connectionVarNames, thisConnectionMembers)) {
                     path.node.callee.property.name = newMethod;
                     hasChanges = true;
                 }
-            }
-        });
-    }
+            });
+        }
+    };
     // Gate metadata type matches on the actual local bindings imported from
     // typeorm — users sometimes have their own classes named `EntityMetadata`
     // or `ColumnMetadata` and their `.connection` property access must not
     // be rewritten.
     const connectionPropLocalNames = (0, ast_helpers_1.expandLocalNamesForImports)(root, j, "typeorm", typesWithConnectionProp);
     const indirectDataSourceLocalNames = (0, ast_helpers_1.expandLocalNamesForImports)(root, j, "typeorm", typesWithIndirectDataSource);
+    // Specifically the local names bound to typeorm's `EntityMetadata` —
+    // used to gate the constructor-option rewrite below. Alias-aware so
+    // `import { EntityMetadata as EM }` is still recognized.
+    const entityMetadataLocalNames = (0, ast_helpers_1.expandLocalNamesForImports)(root, j, "typeorm", new Set(["EntityMetadata"]));
     const connectionPropVarNames = new Set();
     const indirectDataSourceVarNames = new Set();
+    // Parallel sets for `this.X` member accesses — class properties and
+    // getters whose annotation is a tracked TypeORM type. Keyed by the
+    // member name (not prefixed) since the access shape (`this.X`) already
+    // signals the lookup side.
+    const thisConnectionMembers = new Set();
+    const thisConnectionPropMembers = new Set();
+    const thisIndirectMembers = new Set();
+    const classifyType = (typeName) => {
+        if (connectionTypeNames.has(typeName))
+            return connectionVarNames;
+        if (connectionPropLocalNames.has(typeName))
+            return connectionPropVarNames;
+        if (indirectDataSourceLocalNames.has(typeName))
+            return indirectDataSourceVarNames;
+        return null;
+    };
+    const classifyThisMemberType = (typeName) => {
+        if (connectionTypeNames.has(typeName))
+            return thisConnectionMembers;
+        if (connectionPropLocalNames.has(typeName))
+            return thisConnectionPropMembers;
+        if (indirectDataSourceLocalNames.has(typeName))
+            return thisIndirectMembers;
+        return null;
+    };
     const collectTypedIdentifier = (id) => {
         if (!id.name || !id.typeAnnotation)
             return;
@@ -330,18 +684,106 @@ const connectionToDataSource = (file, api) => {
         const ref = ann.typeAnnotation;
         if (ref.typeName.type !== "Identifier")
             return;
-        if (connectionPropLocalNames.has(ref.typeName.name)) {
-            connectionPropVarNames.add(id.name);
-        }
-        else if (indirectDataSourceLocalNames.has(ref.typeName.name)) {
-            indirectDataSourceVarNames.add(id.name);
-        }
+        const bucket = classifyType(ref.typeName.name);
+        if (bucket)
+            bucket.add(id.name);
     };
     root.find(j.VariableDeclarator).forEach((path) => {
         if ((0, ast_helpers_1.isIdentifier)(path.node.id))
             collectTypedIdentifier(path.node.id);
     });
     (0, ast_helpers_1.forEachIdentifierParam)(root, j, collectTypedIdentifier);
+    // Class properties with a TypeORM type annotation — e.g.
+    //   private readonly tenantConnection: DataSource
+    // — register `this.tenantConnection` for rename-side lookup.
+    root.find(j.ClassProperty).forEach((path) => {
+        const keyNode = path.node.key;
+        if (keyNode.type !== "Identifier")
+            return;
+        const ann = path.node.typeAnnotation;
+        if (ann?.type !== "TSTypeAnnotation")
+            return;
+        const inner = ann.typeAnnotation;
+        if (inner.type !== "TSTypeReference")
+            return;
+        const typeName = inner.typeName;
+        if (typeName.type !== "Identifier")
+            return;
+        const bucket = classifyThisMemberType(typeName.name);
+        if (bucket)
+            bucket.add(keyNode.name);
+    });
+    // Constructor parameter properties — `constructor(private readonly x: DataSource)`
+    // is a TSParameterProperty whose inner `parameter` is the typed Identifier.
+    // These become class fields accessed via `this.x`.
+    root.find(j.TSParameterProperty).forEach((path) => {
+        const inner = path.node.parameter;
+        if (!inner)
+            return;
+        const id = resolveTSParameterPropertyIdentifier(inner);
+        if (!id)
+            return;
+        const ann = id.typeAnnotation;
+        if (ann?.type !== "TSTypeAnnotation")
+            return;
+        if (ann.typeAnnotation.type !== "TSTypeReference")
+            return;
+        const ref = ann.typeAnnotation;
+        if (ref.typeName.type !== "Identifier")
+            return;
+        const bucket = classifyThisMemberType(ref.typeName.name);
+        if (bucket)
+            bucket.add(id.name);
+    });
+    // Class getters with a return type annotation — e.g.
+    //   private get entityManager(): EntityManager { ... }
+    // — same `this.X` lookup path.
+    root.find(j.ClassMethod).forEach((path) => {
+        if (path.node.kind !== "get")
+            return;
+        const keyNode = path.node.key;
+        if (keyNode.type !== "Identifier")
+            return;
+        const rt = path.node.returnType;
+        if (rt?.type !== "TSTypeAnnotation")
+            return;
+        const inner = rt.typeAnnotation;
+        if (inner.type !== "TSTypeReference")
+            return;
+        const typeName = inner.typeName;
+        if (typeName.type !== "Identifier")
+            return;
+        const bucket = classifyThisMemberType(typeName.name);
+        if (bucket)
+            bucket.add(keyNode.name);
+    });
+    // Resolves an object-access receiver to the set of known-type names it
+    // resolves against. Returns null for receivers we can't classify.
+    //   x             → { key: "x", isThisMember: false }
+    //   this.x        → { key: "x", isThisMember: true }
+    //   (x as T)      → same as x
+    //   (this.x as T) → same as this.x
+    const resolveReceiver = (node) => {
+        const direct = unwrapIdentifierName(node);
+        if (direct)
+            return { key: direct, isThisMember: false };
+        const unwrapped = (0, ast_helpers_1.unwrapTsExpression)(node);
+        if ((unwrapped.type === "MemberExpression" ||
+            unwrapped.type === "OptionalMemberExpression") &&
+            unwrapped.computed !== true &&
+            unwrapped.object?.type === "ThisExpression" &&
+            unwrapped.property?.type === "Identifier") {
+            const prop = unwrapped.property;
+            return { key: prop.name, isThisMember: true };
+        }
+        return null;
+    };
+    const receiverIsIn = (node, bare, thisMember) => {
+        const r = resolveReceiver(node);
+        if (!r)
+            return false;
+        return r.isThisMember ? thisMember.has(r.key) : bare.has(r.key);
+    };
     // Track variables assigned from DataSource accessors, so code like
     //   const manager = dataSource.manager
     //   manager.connection.getMetadata(...)
@@ -358,24 +800,38 @@ const connectionToDataSource = (file, api) => {
         createQueryRunner: "QueryRunner",
         createQueryBuilder: "SelectQueryBuilder",
     };
+    // Recognizes DataSource receivers: a bare local, or `this.<member>` tracked
+    // by the TSParameterProperty / ClassProperty walks above.
+    const isDataSourceReceiver = (node) => {
+        const direct = unwrapIdentifierName(node);
+        if (direct && connectionVarNames.has(direct))
+            return true;
+        const unwrapped = (0, ast_helpers_1.unwrapTsExpression)(node);
+        if ((unwrapped.type === "MemberExpression" ||
+            unwrapped.type === "OptionalMemberExpression") &&
+            unwrapped.computed !== true &&
+            unwrapped.object?.type === "ThisExpression" &&
+            unwrapped.property?.type === "Identifier") {
+            const propName = unwrapped.property.name;
+            if (thisConnectionMembers.has(propName))
+                return true;
+        }
+        return false;
+    };
     // Returns the TypeORM type that a DataSource accessor chain resolves to
-    // (`ds.manager` → "EntityManager", `ds.getRepository(X)` → "Repository"),
-    // or null when the initializer isn't a recognized accessor-chain pattern.
+    // (`ds.manager` → "EntityManager", etc.), or null if unrecognized.
     const resolveAccessorChainType = (init) => {
         if (init.type === "MemberExpression") {
-            const baseName = unwrapIdentifierName(init.object);
-            if (!baseName ||
-                !connectionVarNames.has(baseName) ||
-                init.property.type !== "Identifier") {
+            if (init.property.type !== "Identifier")
+                return null;
+            if (!isDataSourceReceiver(init.object))
                 return null;
-            }
             return dataSourceMemberAccessors[init.property.name] ?? null;
         }
         if (init.type === "CallExpression" &&
             init.callee.type === "MemberExpression" &&
             init.callee.property.type === "Identifier") {
-            const baseName = unwrapIdentifierName(init.callee.object);
-            if (!baseName || !connectionVarNames.has(baseName))
+            if (!isDataSourceReceiver(init.callee.object))
                 return null;
             return dataSourceCallAccessors[init.callee.property.name] ?? null;
         }
@@ -391,16 +847,90 @@ const connectionToDataSource = (file, api) => {
             connectionPropVarNames.add(path.node.id.name);
         }
     });
+    // Class fields with no explicit type annotation but an accessor-chain
+    // initializer (`private manager = this.dataSource.manager`). Extends the
+    // earlier ClassProperty walk, which only tracks fields with an explicit
+    // TypeORM type annotation.
+    root.find(j.ClassProperty).forEach((path) => {
+        const keyNode = path.node.key;
+        if (keyNode.type !== "Identifier")
+            return;
+        const existing = path.node
+            .typeAnnotation;
+        if (existing?.type === "TSTypeAnnotation")
+            return;
+        const value = path.node.value;
+        if (!value)
+            return;
+        const typeName = resolveAccessorChainType(value);
+        if (typeName && typesWithConnectionProp.has(typeName)) {
+            thisConnectionPropMembers.add(keyNode.name);
+        }
+    });
+    // Destructured property → TypeORM type, for `const { queryRunner } = event`
+    // style bindings where the event is already tracked as a receiver.
+    const destructuredPropertyTypes = {
+        manager: "EntityManager",
+        mongoManager: "EntityManager",
+        queryRunner: "QueryRunner",
+        metadata: "EntityMetadata",
+    };
+    // Local binding name for an ObjectPattern property value. Handles both the
+    // plain `{ queryRunner }` / `{ queryRunner: qr }` forms and defaulted
+    // `{ queryRunner = defaultQr }`.
+    const getPatternBindingName = (value) => {
+        if (value.type === "Identifier") {
+            return value.name;
+        }
+        if (value.type === "AssignmentPattern" &&
+            value.left.type === "Identifier") {
+            return value.left.name;
+        }
+        return null;
+    };
+    const classifyDestructuredProperty = (prop) => {
+        if (prop.type !== "Property" && prop.type !== "ObjectProperty")
+            return;
+        const typed = prop;
+        if (typed.key.type !== "Identifier" || !typed.key.name)
+            return;
+        const typeName = destructuredPropertyTypes[typed.key.name];
+        if (!typeName)
+            return;
+        const local = getPatternBindingName(typed.value);
+        if (!local)
+            return;
+        if (typesWithConnectionProp.has(typeName)) {
+            connectionPropVarNames.add(local);
+        }
+        if (typesWithIndirectDataSource.has(typeName)) {
+            indirectDataSourceVarNames.add(local);
+        }
+    };
+    root.find(j.VariableDeclarator).forEach((declPath) => {
+        const init = declPath.node.init;
+        if (!init)
+            return;
+        if (!receiverIsIn(init, connectionPropVarNames, thisConnectionPropMembers)) {
+            return;
+        }
+        const id = declPath.node.id;
+        if (id.type !== "ObjectPattern")
+            return;
+        for (const prop of id.properties) {
+            classifyDestructuredProperty(prop);
+        }
+    });
+    renameDataSourceMethods();
     // Rename .isConnected → .isInitialized on Connection/DataSource instances
     root.find(j.MemberExpression, {
         property: { name: "isConnected" },
     }).forEach((path) => {
-        if (path.node.property.type === "Identifier") {
-            const objName = unwrapIdentifierName(path.node.object);
-            if (objName && connectionVarNames.has(objName)) {
-                path.node.property.name = "isInitialized";
-                hasChanges = true;
-            }
+        if (path.node.property.type !== "Identifier")
+            return;
+        if (receiverIsIn(path.node.object, connectionVarNames, thisConnectionMembers)) {
+            path.node.property.name = "isInitialized";
+            hasChanges = true;
         }
     });
     // Rename .connection → .dataSource on known TypeORM instances.
@@ -411,21 +941,274 @@ const connectionToDataSource = (file, api) => {
     }).forEach((path) => {
         if (path.node.property.type !== "Identifier")
             return;
-        const objName = unwrapIdentifierName(path.node.object);
-        if (!objName)
-            return;
-        if (connectionPropVarNames.has(objName)) {
+        if (receiverIsIn(path.node.object, connectionPropVarNames, thisConnectionPropMembers)) {
             path.node.property.name = "dataSource";
             hasChanges = true;
             return;
         }
-        if (indirectDataSourceVarNames.has(objName)) {
+        if (receiverIsIn(path.node.object, indirectDataSourceVarNames, thisIndirectMembers)) {
             // `col.connection` → `col.entityMetadata.dataSource`
             path.node.object = j.memberExpression(path.node.object, j.identifier("entityMetadata"));
             path.node.property.name = "dataSource";
             hasChanges = true;
         }
     });
+    const isReferenceIdentifier = (idPath) => {
+        const parentNode = idPath.parent?.node;
+        if (!parentNode)
+            return true;
+        const parent = parentNode;
+        const isPropertyKey = parent.type === "Property" ||
+            parent.type === "ObjectProperty" ||
+            parent.type === "TSPropertySignature" ||
+            parent.type === "ClassProperty" ||
+            parent.type === "ClassMethod" ||
+            parent.type === "MethodDefinition";
+        if (isPropertyKey && parent.key === idPath.node && !parent.computed) {
+            return false;
+        }
+        const isMemberProperty = parent.type === "MemberExpression" ||
+            parent.type === "OptionalMemberExpression";
+        if (isMemberProperty &&
+            parent.property === idPath.node &&
+            !parent.computed) {
+            return false;
+        }
+        if (parent.type === "ImportSpecifier" &&
+            parent.imported === idPath.node) {
+            return false;
+        }
+        if (parent.type === "ExportSpecifier" &&
+            parent.exported === idPath.node) {
+            return false;
+        }
+        return true;
+    };
+    // Cache all `connection` and `dataSource` identifier paths once, then
+    // filter by scope subtree per destructure pass instead of re-walking the
+    // AST. Both caches use the current `node.name` at lookup time, so a
+    // previously-renamed `connection` → `dataSource` node correctly counts
+    // as a `dataSource` reference in subsequent passes.
+    const allConnectionRefs = [];
+    const allDataSourceRefs = [];
+    root.find(j.Identifier, { name: "connection" }).forEach((p) => {
+        allConnectionRefs.push(p);
+    });
+    root.find(j.Identifier, { name: "dataSource" }).forEach((p) => {
+        allDataSourceRefs.push(p);
+    });
+    const isInSubtree = (idPath, root) => {
+        let cursor = idPath.parent;
+        while (cursor) {
+            if (cursor.node === root)
+                return true;
+            cursor = cursor.parent;
+        }
+        return false;
+    };
+    // True if any `dataSource` reference lives inside the given subtree — that
+    // reference would rebind to the about-to-be-renamed local, so the rename
+    // must fall back to the alias form. Checks both caches because a previous
+    // rename pass may have renamed a cached `connection` path to `dataSource`,
+    // creating a sibling-scope conflict that ast-types' scope object — being
+    // built once at parse time — won't reflect.
+    const hasDataSourceUsageIn = (scopeBodyNode) => {
+        const isDataSourceRefInSubtree = (idPath) => idPath.node.name === "dataSource" &&
+            isInSubtree(idPath, scopeBodyNode) &&
+            isReferenceIdentifier(idPath);
+        for (const p of allDataSourceRefs) {
+            if (isDataSourceRefInSubtree(p))
+                return true;
+        }
+        for (const p of allConnectionRefs) {
+            if (isDataSourceRefInSubtree(p))
+                return true;
+        }
+        return false;
+    };
+    // Collect every `connection` reference inside `scopeBodyNode` whose
+    // resolved binding is `scope`. Skips non-reference positions and paths
+    // whose node was renamed by a previous pass.
+    const collectConnectionRefsInScope = (scope, scopeBodyNode) => {
+        const expectedScopeNode = scope.path?.node;
+        const refs = [];
+        for (const idPath of allConnectionRefs) {
+            if (idPath.node.name !== "connection")
+                continue;
+            if (!isInSubtree(idPath, scopeBodyNode))
+                continue;
+            if (!isReferenceIdentifier(idPath))
+                continue;
+            const refScope = idPath.scope;
+            if (!refScope)
+                continue;
+            const lookup = refScope.lookup("connection");
+            if (!lookup)
+                continue;
+            if (lookup !== scope &&
+                (!expectedScopeNode || lookup.path?.node !== expectedScopeNode)) {
+                continue;
+            }
+            refs.push(idPath);
+        }
+        return refs;
+    };
+    // Attempts a scope-aware rename of a shorthand `{ connection }` binding to
+    // `{ dataSource }`, plus every reference to the local within the scope.
+    // Returns false (caller falls back to the alias form) when the rename
+    // would disturb an existing `dataSource` usage in the subtree.
+    const tryRenameShorthandConnectionBinding = (prop, declPath, scopeBodyNode) => {
+        const scope = declPath.scope;
+        if (!scope)
+            return false;
+        if (scope.declares("dataSource"))
+            return false;
+        if (hasDataSourceUsageIn(scopeBodyNode))
+            return false;
+        const refsToRename = collectConnectionRefsInScope(scope, scopeBodyNode);
+        prop.key.name = "dataSource";
+        if (prop.value.type === "Identifier") {
+            ;
+            prop.value.name = "dataSource";
+        }
+        else if (getPatternBindingName(prop.value) !== null) {
+            ;
+            prop.value.left.name = "dataSource";
+        }
+        for (const ref of refsToRename)
+            ref.node.name = "dataSource";
+        return true;
+    };
+    // `const { connection } = event` / `for (const { connection } of events)`
+    // where the RHS is a tracked receiver. Tries a scope-aware rename of the
+    // local binding; falls back to the alias form `{ dataSource: connection }`
+    // when the rename would collide with an existing `dataSource` binding.
+    const renameConnectionInObjectPattern = (id, declPath, scopeBodyNode) => {
+        if (id.type !== "ObjectPattern")
+            return;
+        for (const prop of id.properties) {
+            if (prop.type !== "Property" && prop.type !== "ObjectProperty")
+                continue;
+            const typed = prop;
+            if (typed.key.type !== "Identifier")
+                continue;
+            if (typed.key.name !== "connection")
+                continue;
+            if (typed.shorthand &&
+                tryRenameShorthandConnectionBinding(typed, declPath, scopeBodyNode)) {
+                hasChanges = true;
+                continue;
+            }
+            // Fallback: rename only the key, keep the local name.
+            // `{ connection }` expands to `{ dataSource: connection }`.
+            typed.key.name = "dataSource";
+            if (typed.shorthand)
+                typed.shorthand = false;
+            hasChanges = true;
+        }
+    };
+    root.find(j.VariableDeclarator).forEach((declPath) => {
+        const init = declPath.node.init;
+        if (!init)
+            return;
+        if (!receiverIsIn(init, connectionPropVarNames, thisConnectionPropMembers)) {
+            return;
+        }
+        const scoped = declPath;
+        const scopeNode = scoped.scope?.path?.node ?? declPath.node;
+        renameConnectionInObjectPattern(declPath.node.id, scoped, scopeNode);
+    });
+    // `for (const { connection } of events)` — `ForOfStatement.left` is a
+    // `VariableDeclaration` whose declarators have no `init`, so the
+    // plain VariableDeclarator loop above skips them. Classify the loop
+    // variable's inferred type: either the iterable variable itself is a
+    // tracked receiver, or its declared annotation is `Tracked[]` /
+    // `Array<Tracked>`.
+    const elementTypeOf = (rhsNode) => {
+        if (rhsNode.type !== "Identifier")
+            return null;
+        const name = rhsNode.name;
+        let resolved = null;
+        root.find(j.VariableDeclarator).forEach((p) => {
+            if (resolved)
+                return;
+            if (p.node.id.type !== "Identifier")
+                return;
+            if (p.node.id.name !== name)
+                return;
+            const ann = p.node.id.typeAnnotation;
+            if (ann?.type !== "TSTypeAnnotation")
+                return;
+            const inner = ann.typeAnnotation;
+            if (inner.type === "TSArrayType") {
+                resolved =
+                    (0, ast_helpers_1.getTypeReferenceRootName)(inner.elementType, typeormNamespaceNames) ?? null;
+                return;
+            }
+            if (inner.type === "TSTypeReference" &&
+                inner.typeName?.name ===
+                    "Array") {
+                const params = inner.typeParameters?.params;
+                if (params && params.length > 0) {
+                    resolved =
+                        (0, ast_helpers_1.getTypeReferenceRootName)(params[0], typeormNamespaceNames) ?? null;
+                }
+            }
+        });
+        return resolved;
+    };
+    // Set of VariableDeclarator AST nodes that belong to a tracked for-of /
+    // for-in loop's `left` (i.e. the per-iteration binding). Populated in the
+    // ForOf/ForIn walks below; consumed by the root-wide VariableDeclarator
+    // walk that follows, so declarator paths carry their proper `.scope` info.
+    const forLoopDeclaratorNodes = new Set();
+    // Maps a tracked declarator node → the loop body to walk for references.
+    const forLoopBodyByDeclarator = new Map();
+    const collectForLoopDeclarators = (forPath) => {
+        const leftNode = forPath.node.left;
+        const rightNode = forPath.node.right;
+        const bodyNode = forPath.node.body;
+        if (!leftNode || !rightNode || !bodyNode)
+            return;
+        if (leftNode.type !== "VariableDeclaration")
+            return;
+        const directlyTracked = receiverIsIn(rightNode, connectionPropVarNames, thisConnectionPropMembers);
+        const elementType = elementTypeOf(rightNode);
+        const elementTracked = elementType !== null && connectionPropLocalNames.has(elementType);
+        if (!directlyTracked && !elementTracked)
+            return;
+        for (const d of leftNode
+            .declarations) {
+            if (d.type !== "VariableDeclarator")
+                continue;
+            forLoopDeclaratorNodes.add(d);
+            forLoopBodyByDeclarator.set(d, bodyNode);
+        }
+    };
+    root.find(j.ForOfStatement).forEach(collectForLoopDeclarators);
+    root.find(j.ForInStatement).forEach(collectForLoopDeclarators);
+    if (forLoopDeclaratorNodes.size > 0) {
+        // Walking from the root (rather than `j(forPath.node)`) preserves
+        // `.scope` on the declarator paths — ast-types scope info is only
+        // populated by the top-down traversal that starts at Program.
+        root.find(j.VariableDeclarator).forEach((dPath) => {
+            if (!forLoopDeclaratorNodes.has(dPath.node))
+                return;
+            const bodyNode = forLoopBodyByDeclarator.get(dPath.node);
+            if (!bodyNode)
+                return;
+            renameConnectionInObjectPattern(dPath.node.id, dPath, bodyNode);
+        });
+    }
+    // Rewrite the `connection` option passed to metadata-type constructors:
+    //   - `new EntityMetadata({ connection: X, ... })` → rename key to
+    //     `dataSource` (the option was just renamed in v1).
+    //   - `new ColumnMetadata({ connection, ... })` / `IndexMetadata` →
+    //     drop the `connection` key entirely. These constructors no longer
+    //     accept `connection` in v1; the DataSource is reached through
+    //     `entityMetadata.dataSource` and is set by the entity-metadata
+    //     builder rather than the caller.
+    hasChanges = rewriteMetadataConstructors(root, j, entityMetadataLocalNames, indirectDataSourceLocalNames, hasChanges);
     return hasChanges ? root.toSource() : undefined;
 };
 exports.connectionToDataSource = connectionToDataSource;