upstreamfix 0.1.0 → 0.1.3

package/dist/migrations/firebase-admin-v14/index.js

@@ -1,4 +1,5 @@
 import { Node, SyntaxKind, } from 'ts-morph';
+import { guaranteesNodeMajor } from '../../core/node-range.js';
 import { APP_MODULE, CREDENTIAL_FACTORIES, REMOVED_SERVICES, ROOT_TYPES, SERVICES, } from './mapping.js';
 const PKG = 'firebase-admin';
 const NODE_RUNTIME_GUIDANCE = 'firebase-admin v14 requires Node.js 22 or later; package.json does not declare engines.node. Add `"engines": { "node": ">=22" }` or use `--node-runtime 22` after confirming the deployment runtime.';
@@ -24,6 +25,9 @@ export const firebaseAdminV14 = {
             .find((value) => typeof value === 'string');
         if (functionsTest)
             notes.push(`firebase-functions-test "${functionsTest}" is installed. In a benchmarked project, the v14 typecheck failed because this package's declarations import firebase-admin exports removed in v14 (including app and firestore). Check whether a compatible release is available; otherwise update the test setup, then rerun the tests before upgrading.`);
+        const functionsVersion = dependencyVersion(manifest, 'firebase-functions');
+        if (functionsVersion)
+            notes.push(`firebase-functions \`${functionsVersion}\` is installed: check that its firebase-admin peer range accepts v14.`);
         return notes;
     },
     transform(project) {
@@ -85,16 +89,20 @@ export const firebaseAdminV14 = {
         else if (!runtimeReady) {
             notes.push(`firebase-admin v14 requires Node.js 22 or later; review \`engines.node\` (${engine}).`);
         }
-        const functionsVersion = manifest.dependencies?.['firebase-functions'];
+        const functionsVersion = dependencyVersion(manifest, 'firebase-functions');
         if (functionsVersion) {
             notes.push(`firebase-functions \`${functionsVersion}\` is installed: check that its firebase-admin peer range accepts v14 (firebase-functions#1902).`);
         }
         return notes;
     },
 };
+function dependencyVersion(manifest, name) {
+    return [manifest.dependencies, manifest.devDependencies, manifest.peerDependencies, manifest.optionalDependencies]
+        .map((section) => section?.[name])
+        .find((value) => typeof value === 'string');
+}
 function supportsNode22(range) {
-    const normalized = range.trim();
-    return /^(?:>=\s*22(?:\.\d+){0,2}|(?:\^|~)\s*22(?:\.\d+){0,2}|22(?:\.\d+){0,2})$/.test(normalized);
+    return guaranteesNodeMajor(range, 22);
 }
 function migrateFile(sourceFile, result) {
     const file = sourceFile.getFilePath();
@@ -104,6 +112,34 @@ function migrateFile(sourceFile, result) {
     const aliases = findAliases(sourceFile);
     if (aliases.length === 0)
         return false;
+    const aliasNames = new Set(aliases.map((alias) => alias.name));
+    for (const declaration of sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+        const initializer = declaration.getInitializer();
+        const nameNode = declaration.getNameNode();
+        if (!Node.isCallExpression(initializer) || !Node.isIdentifier(nameNode))
+            continue;
+        const factory = initializer.getExpression();
+        if (!Node.isPropertyAccessExpression(factory) || factory.getName() !== 'app')
+            continue;
+        const root = factory.getExpression();
+        if (!Node.isIdentifier(root) || !aliasNames.has(root.getText()))
+            continue;
+        for (const reference of nameNode.findReferencesAsNodes()) {
+            if (reference === nameNode || reference.getSourceFile() !== sourceFile)
+                continue;
+            const access = reference.getParent();
+            if (!Node.isPropertyAccessExpression(access) || access.getExpression() !== reference)
+                continue;
+            const service = access.getName();
+            if (!Object.hasOwn(SERVICES, service) && !Object.hasOwn(REMOVED_SERVICES, service))
+                continue;
+            result.manual.push({ file, line: access.getStartLineNumber(), reason: `Stored admin.app() result calls app.${service}; choose the modular service getter manually.`, snippet: snippetOf(access) });
+        }
+    }
+    if (result.manual.length > manualBefore) {
+        sortManual(result.manual, manualBefore);
+        return false;
+    }
     const edits = [];
     const aliasesWithManualUses = new Set();
     for (const alias of aliases) {
@@ -129,19 +165,37 @@ function migrateFile(sourceFile, result) {
             });
             continue;
         }
+        if (alias.kind === 'cjs') {
+            for (const type of sourceFile.getDescendantsOfKind(SyntaxKind.TypeReference)) {
+                if (!aliasMemberPattern(alias.name).test(type.getText()))
+                    continue;
+                aliasesWithManualUses.add(alias.name);
+                result.manual.push({ file, line: type.getStartLineNumber(), reason: 'A type-only Firebase reference from require needs a manual import type; no runtime require was synthesized.', snippet: snippetOf(type) });
+            }
+        }
         const references = alias.nameNode
             .findReferencesAsNodes()
             .filter(Node.isIdentifier)
             .filter((reference) => reference.getSourceFile() === sourceFile)
             .filter((reference) => reference !== alias.nameNode);
         for (const ref of references) {
-            const classification = classify(ref);
             const line = ref.getStartLineNumber();
+            if (alias.kind === 'cjs' && ref.getFirstAncestorByKind(SyntaxKind.TypeReference)) {
+                aliasesWithManualUses.add(alias.name);
+                result.manual.push({ file, line, reason: 'A type-only Firebase reference from require needs a manual import type; no runtime require was synthesized.', snippet: snippetOf(ref) });
+                continue;
+            }
+            const classification = classify(ref);
             if ('reason' in classification) {
                 aliasesWithManualUses.add(alias.name);
                 result.manual.push({ file, line, reason: classification.reason, snippet: snippetOf(ref) });
                 continue;
             }
+            if (alias.kind === 'cjs' && classification.imports.some((imp) => imp.typeOnly)) {
+                aliasesWithManualUses.add(alias.name);
+                result.manual.push({ file, line, reason: 'A type-only Firebase reference from require needs a manual import type; no runtime require was synthesized.', snippet: snippetOf(ref) });
+                continue;
+            }
             const collision = classification.imports.find((imp) => hasImportCollision(sourceFile, imp));
             if (collision) {
                 aliasesWithManualUses.add(alias.name);
@@ -164,15 +218,33 @@ function migrateFile(sourceFile, result) {
             });
         }
     }
+    if (result.manual.slice(manualBefore).some((item) => item.reason.startsWith('App-scoped ') && item.reason.includes('arguments'))) {
+        sortManual(result.manual, manualBefore);
+        return false;
+    }
     if (edits.length === 0) {
         if (result.manual.length > manualBefore)
             sortManual(result.manual, manualBefore);
         return false;
     }
-    const textEdits = edits.map((edit) => ({ start: edit.start, end: edit.end, text: edit.text }));
-    for (const edit of edits) {
-        result.changes.push({ file, line: edit.line, rule: edit.rule, before: edit.before, after: edit.text });
+    const orderedEdits = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+    if (hasOverlappingEdits(orderedEdits)) {
+        for (let index = 1; index < orderedEdits.length; index++) {
+            const previous = orderedEdits[index - 1];
+            const current = orderedEdits[index];
+            if (current.start >= previous.end)
+                continue;
+            result.manual.push({
+                file,
+                line: current.line,
+                reason: 'Automatic Firebase edits overlap in this file; review the nested usage manually before migrating it.',
+                snippet: current.before,
+            });
+            sortManual(result.manual, manualBefore);
+            return false;
+        }
     }
+    const textEdits = edits.map((edit) => ({ start: edit.start, end: edit.end, text: edit.text }));
     const importMap = mergeImports(edits.flatMap((edit) => edit.imports));
     const kind = aliases.some((alias) => alias.kind === 'esm') ? 'esm' : 'cjs';
     const importText = renderImports(sourceFile, kind, importMap);
@@ -182,12 +254,41 @@ function migrateFile(sourceFile, result) {
     }
     textEdits.push(...aliasDeclarationRemovals(sourceFile, aliases, aliasesWithManualUses));
     const transformed = applyTextEdits(sourceFile.getFullText(), textEdits);
+    for (const alias of aliases) {
+        if (!aliasesWithManualUses.has(alias.name) && aliasMemberPattern(alias.name).test(transformed)) {
+            result.manual.push({
+                file,
+                line: alias.nameNode.getStartLineNumber(),
+                reason: `The ${alias.name} namespace still has references after migration; its import cannot be removed safely. Review this file manually.`,
+                snippet: snippetOf(alias.nameNode),
+            });
+            sortManual(result.manual, manualBefore);
+            return false;
+        }
+    }
+    for (const edit of edits) {
+        result.changes.push({ file, line: edit.line, rule: edit.rule, before: edit.before, after: edit.text });
+    }
     if (transformed !== sourceFile.getFullText())
         result.fileUpdates?.push({ file, contents: transformed });
     if (result.manual.length > manualBefore)
         sortManual(result.manual, manualBefore);
     return true;
 }
+export function hasOverlappingEdits(edits) {
+    const ordered = [...edits].sort((left, right) => left.start - right.start || left.end - right.end);
+    let boundary = -1;
+    for (const edit of ordered) {
+        if (edit.start < boundary)
+            return true;
+        boundary = Math.max(boundary, edit.end);
+    }
+    return false;
+}
+function aliasMemberPattern(alias) {
+    const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`(?<![\\w$])${escaped}\\s*[.\\[]`);
+}
 function classify(ref) {
     const parent = ref.getParent();
     if (Node.isPropertyAccessExpression(parent) && parent.getExpression() === ref)
@@ -251,6 +352,9 @@ function classifyAccess(access) {
                 const serviceName = serviceAccess.getName();
                 const nestedService = Object.hasOwn(SERVICES, serviceName) ? SERVICES[serviceName] : undefined;
                 if (nestedService) {
+                    if (serviceCall.getArguments().length > 0) {
+                        return { reason: `App-scoped ${serviceName} call has arguments; choose the equivalent modular API manually so its target is preserved.` };
+                    }
                     return {
                         node: serviceCall,
                         text: `${nestedService.getter}()`,
@@ -515,7 +619,7 @@ function renderImports(sourceFile, kind, byModule) {
     const newline = fullText.includes('\r\n') ? '\r\n' : '\n';
     const before = fullText.slice(0, position);
     const after = fullText.slice(position);
-    const prefix = before.endsWith('\n') ? '' : newline;
+    const prefix = before.length === 0 || before.endsWith('\n') ? '' : newline;
     const suffix = after.startsWith('\n') ? '' : newline;
     return `${prefix}${lines.join(newline)}${suffix}`;
 }
@@ -568,7 +672,7 @@ function aliasDeclarationRemovals(sourceFile, aliases, aliasesWithManualUses) {
                 importDecl.getNamedImports().length === 0) {
                 const key = `${importDecl.getStart()}:${importDecl.getEnd()}`;
                 if (!seen.has(key))
-                    removals.push({ start: importDecl.getStart(), end: importDecl.getEnd(), text: '' });
+                    removals.push({ start: importDecl.getStart(), end: endIncludingLineBreak(sourceFile, importDecl.getEnd()), text: '' });
                 seen.add(key);
             }
             continue;
@@ -580,12 +684,20 @@ function aliasDeclarationRemovals(sourceFile, aliases, aliasesWithManualUses) {
         if (removable) {
             const key = `${removable.getStart()}:${removable.getEnd()}`;
             if (!seen.has(key))
-                removals.push({ start: removable.getStart(), end: removable.getEnd(), text: '' });
+                removals.push({ start: removable.getStart(), end: endIncludingLineBreak(sourceFile, removable.getEnd()), text: '' });
             seen.add(key);
         }
     }
     return removals;
 }
+function endIncludingLineBreak(sourceFile, end) {
+    const text = sourceFile.getFullText();
+    if (text.slice(end, end + 2) === '\r\n')
+        return end + 2;
+    if (text[end] === '\n')
+        return end + 1;
+    return end;
+}
 function snippetOf(node) {
     const statement = node.getFirstAncestor((n) => Node.isStatement(n)) ?? node;
     const text = statement.getText().split('\n')[0].trim();

package/dist/migrations/index.js

@@ -1,25 +1,21 @@
 import { readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
+import { IGNORED_PROJECT_DIRECTORIES, isSupportedSourceMajor } from '../core/project-discovery.js';
 import { firebaseAdminV14 } from './firebase-admin-v14/index.js';
 import { stripeV22 } from './stripe-v22/index.js';
 import { stripeV23 } from './stripe-v23/index.js';
 /** The shipped migration catalog. Adding a migration requires registering it here, not in core or the CLI. */
 export const migrations = [firebaseAdminV14, stripeV22, stripeV23];
-const ignoredDirectories = new Set(['.git', 'node_modules', 'dist', 'coverage', '.next', '.nuxt', '.turbo', '.cache']);
 export async function findApplicableMigrations(cwd) {
     const manifests = await readManifests(path.resolve(cwd));
     return migrations.filter((migration) => manifests.some((manifest) => {
         const sections = [manifest.dependencies, manifest.devDependencies, manifest.peerDependencies, manifest.optionalDependencies];
         return sections.some((section) => {
             const range = section?.[migration.packageName];
-            return typeof range === 'string' && declaredMajor(range) === migration.fromMajor;
+            return typeof range === 'string' && isSupportedSourceMajor(range, migration.fromMajor);
         });
     }));
 }
-function declaredMajor(range) {
-    const match = /^\s*(?:[~^=]|>=?\s*)?(\d+)(?:\.|\s|$)/.exec(range);
-    return match ? Number(match[1]) : undefined;
-}
 async function readManifests(root) {
     const manifests = [];
     async function visit(directory) {
@@ -28,7 +24,7 @@ async function readManifests(root) {
                 continue;
             const absolute = path.join(directory, entry.name);
             if (entry.isDirectory()) {
-                if (!ignoredDirectories.has(entry.name))
+                if (!IGNORED_PROJECT_DIRECTORIES.has(entry.name))
                     await visit(absolute);
             }
             else if (entry.isFile() && entry.name === 'package.json') {

package/dist/migrations/stripe-shared.js

@@ -37,6 +37,9 @@ function emptyResult() {
     return { changes: [], manual: [], filesChanged: [], fileUpdates: [] };
 }
 function migrateV22File(sourceFile, result) {
+    if (withholdInvalidSource(sourceFile, result))
+        return;
+    reportUnsupportedStripeImports(sourceFile, result);
     const edits = [];
     const before = sourceFile.getFullText();
     const stripeBindings = findStripeBindings(sourceFile);
@@ -44,6 +47,10 @@ function migrateV22File(sourceFile, result) {
     for (const variable of sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
         const name = variable.getNameNode();
         const initializer = variable.getInitializer();
+        if (Node.isObjectBindingPattern(name) && initializer && Node.isPropertyAccessExpression(initializer)
+            && initializer.getName() === 'default' && isRequireStripe(initializer.getExpression())) {
+            addManual(sourceFile, result.manual, variable, 'Destructuring require("stripe").default is not rewritten automatically; inspect this import shape manually.', variable.getText());
+        }
         if (!Node.isObjectBindingPattern(name) || !initializer || !isRequireStripe(initializer))
             continue;
         const elements = name.getElements();
@@ -100,6 +107,10 @@ function migrateV22File(sourceFile, result) {
     }
     for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
         const expression = call.getExpression();
+        if (expression.getText().startsWith('this.stripe.')
+            && call.getArguments().some((argument) => Node.isArrowFunction(argument) || Node.isFunctionExpression(argument))) {
+            addManual(sourceFile, result.manual, call, 'Stripe v22 removes callbacks from client methods reached through this.stripe; convert this call manually to promises.', call.getText());
+        }
         const [root, ...path] = propertyPath(expression);
         if (root && clients.has(root) && path.length >= 2) {
             const args = call.getArguments();
@@ -159,9 +170,12 @@ function migrateV22File(sourceFile, result) {
             edits.push(edit(sourceFile, expression, `new (${expression.getText()})`, 'stripe-constructor', expression.getText()));
         }
     }
-    applyEdits(sourceFile, edits, result, before);
+    applyStripeEdits(sourceFile, edits, result, before);
 }
 function migrateV23File(sourceFile, result) {
+    if (withholdInvalidSource(sourceFile, result))
+        return;
+    reportUnsupportedStripeImports(sourceFile, result);
     const edits = [];
     const before = sourceFile.getFullText();
     const stripeBindings = findStripeBindings(sourceFile);
@@ -242,7 +256,19 @@ function migrateV23File(sourceFile, result) {
             addManual(sourceFile, result.manual, creation, reason, redactedSnippet(creation.getText()));
         }
     }
-    applyEdits(sourceFile, edits, result, before);
+    applyStripeEdits(sourceFile, edits, result, before);
+}
+function reportUnsupportedStripeImports(sourceFile, result) {
+    for (const declaration of sourceFile.getImportDeclarations()) {
+        if (declaration.getModuleSpecifierValue() !== PACKAGE)
+            continue;
+        if (declaration.getNamespaceImport()) {
+            addManual(sourceFile, result.manual, declaration, 'A namespace Stripe import needs manual review before this migration.', declaration.getText());
+        }
+        if (declaration.getNamedImports().some((specifier) => specifier.getName() === 'default')) {
+            addManual(sourceFile, result.manual, declaration, 'A named default Stripe import needs manual review before this migration.', declaration.getText());
+        }
+    }
 }
 function findStripeBindings(sourceFile) {
     const constructors = new Set();
@@ -359,20 +385,31 @@ function edit(sourceFile, node, replacement, rule, before) {
         line: sourceFile.getLineAndColumnAtPos(node.getStart()).line,
     };
 }
-function applyEdits(sourceFile, edits, result, original) {
+export function applyStripeEdits(sourceFile, edits, result, original) {
     if (edits.length === 0)
         return;
     const unique = new Map();
-    for (const change of edits)
-        unique.set(`${change.start}:${change.end}`, change);
+    for (const change of edits) {
+        const key = `${change.start}:${change.end}`;
+        const previous = unique.get(key);
+        if (previous && previous.replacement !== change.replacement) {
+            reportOverlap(sourceFile, result, change);
+            return;
+        }
+        unique.set(key, change);
+    }
     const ordered = [...unique.values()].sort((left, right) => right.start - left.start || right.end - left.end);
-    let migrated = original;
     let boundary = original.length + 1;
     for (const change of ordered) {
-        if (change.end > boundary)
-            continue;
-        migrated = migrated.slice(0, change.start) + change.replacement + migrated.slice(change.end);
+        if (change.end > boundary) {
+            reportOverlap(sourceFile, result, change);
+            return;
+        }
         boundary = change.start;
+    }
+    let migrated = original;
+    for (const change of ordered) {
+        migrated = migrated.slice(0, change.start) + change.replacement + migrated.slice(change.end);
         const after = change.rule === 'request-options-position'
             ? `undefined, ${change.before}`
             : change.replacement;
@@ -383,6 +420,35 @@ function applyEdits(sourceFile, edits, result, original) {
     result.filesChanged.push(sourceFile.getFilePath());
     result.fileUpdates?.push({ file: sourceFile.getFilePath(), contents: migrated });
 }
+function withholdInvalidSource(sourceFile, result) {
+    const diagnostics = sourceFile.compilerNode.parseDiagnostics ?? [];
+    if (diagnostics.length === 0)
+        return false;
+    const isStripeSpecifier = (value) => value === PACKAGE || value.startsWith(`${PACKAGE}/`);
+    const hasImport = sourceFile.getImportDeclarations().some((declaration) => isStripeSpecifier(declaration.getModuleSpecifierValue()));
+    const hasRequire = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => {
+        const expression = call.getExpression();
+        if (!(Node.isIdentifier(expression) && expression.getText() === 'require') && expression.getKind() !== SyntaxKind.ImportKeyword)
+            return false;
+        const argument = call.getArguments()[0];
+        return Node.isStringLiteral(argument) && isStripeSpecifier(argument.getLiteralValue());
+    });
+    if (!hasImport && !hasRequire)
+        return true;
+    result.manual.push({
+        file: sourceFile.getFilePath(), line: 1,
+        reason: `This Stripe source file has ${diagnostics.length} syntax error(s); automatic edits were withheld until the file parses cleanly.`,
+        snippet: redactedSnippet(sourceFile.getFullText().split(/\r?\n/, 1)[0] ?? ''),
+    });
+    return true;
+}
+function reportOverlap(sourceFile, result, change) {
+    result.manual.push({
+        file: sourceFile.getFilePath(), line: change.line,
+        reason: 'Two Stripe migration edits overlap; automatic edits for this file were withheld for manual review.',
+        snippet: redactedSnippet(change.before),
+    });
+}
 function addManual(sourceFile, findings, node, reason, snippet) {
     if (findings.some((finding) => finding.file === sourceFile.getFilePath() && finding.line === node.getStartLineNumber() && finding.reason === reason))
         return;

package/dist/migrations/stripe-v23/index.js

@@ -1,4 +1,5 @@
 import { migrateStripeV23 } from '../stripe-shared.js';
+import { guaranteesNodeMajor } from '../../core/node-range.js';
 export const stripeV23 = {
     id: 'stripe@23',
     packageName: 'stripe',
@@ -51,5 +52,5 @@ export const stripeV23 = {
     },
 };
 function supportsNode20(range) {
-    return /^(?:>=\s*20(?:\.\d+){0,2}|(?:\^|~)\s*(?:20|2[1-9]|[3-9]\d)(?:\.\d+){0,2}|(?:20|2[1-9]|[3-9]\d)(?:\.\d+){0,2})$/.test(range.trim());
+    return guaranteesNodeMajor(range, 20);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upstreamfix",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Preview supported migrations for breaking SDK changes.",
   "repository": {
     "type": "git",