firebase-tools 15.18.0 → 15.19.1

package/lib/crashlytics/sourcemap.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONCURRENCY = void 0;
+exports.checkGoogleAppID = checkGoogleAppID;
+exports.getAppVersion = getAppVersion;
+exports.getGitCommit = getGitCommit;
+exports.getPackageVersion = getPackageVersion;
+exports.upsertBucket = upsertBucket;
+exports.findSourceMapMappings = findSourceMapMappings;
+exports.getLinkedSourceMapPath = getLinkedSourceMapPath;
+exports.uploadSourceMaps = uploadSourceMaps;
+exports.uploadMap = uploadMap;
+exports.normalizeFileName = normalizeFileName;
+exports.registerSourceMap = registerSourceMap;
+const fs = require("fs");
+const path = require("path");
+const node_child_process_1 = require("node:child_process");
+const pLimit = require("p-limit");
+const apiv2_1 = require("../apiv2");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+const utils_1 = require("../utils");
+const gcs = require("../gcp/storage");
+const archiveFile_1 = require("../archiveFile");
+exports.CONCURRENCY = 25;
+function checkGoogleAppID(options) {
+    if (!options.app) {
+        throw new error_1.FirebaseError("set --app <appId> to a valid Firebase application id, e.g. 1:00000000:android:0000000");
+    }
+}
+function getAppVersion(options) {
+    if (options.appVersion) {
+        return options.appVersion;
+    }
+    const gitCommit = getGitCommit();
+    if (gitCommit) {
+        (0, utils_1.logLabeledBullet)("crashlytics", `Using git commit as app version: ${gitCommit}`);
+        return gitCommit;
+    }
+    const packageVersion = getPackageVersion();
+    if (packageVersion) {
+        (0, utils_1.logLabeledBullet)("crashlytics", `Using package version as app version: ${packageVersion}`);
+        return packageVersion;
+    }
+    return "unset";
+}
+function getGitCommit() {
+    if (!(0, utils_1.commandExistsSync)("git")) {
+        return undefined;
+    }
+    try {
+        return (0, node_child_process_1.execSync)("git rev-parse HEAD").toString().trim();
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+function getPackageVersion() {
+    if (!(0, utils_1.commandExistsSync)("npm")) {
+        return undefined;
+    }
+    try {
+        return (0, node_child_process_1.execSync)("npm pkg get version").toString().trim().replaceAll('"', "");
+    }
+    catch (error) {
+        return undefined;
+    }
+}
+async function upsertBucket(projectId, projectNumber, options) {
+    let loc = "US-CENTRAL1";
+    if (options.bucketLocation) {
+        loc = options.bucketLocation.toUpperCase();
+    }
+    else {
+        (0, utils_1.logLabeledBullet)("crashlytics", "No Google Cloud Storage bucket location specified. Defaulting to US-CENTRAL1.");
+    }
+    const baseName = `firebasecrashlytics-sourcemaps-${projectNumber}-${loc.toLowerCase()}`;
+    return await gcs.upsertBucket({
+        product: "crashlytics",
+        createMessage: `Creating Cloud Storage bucket in ${loc} to store Crashlytics source maps at ${baseName}...`,
+        projectId,
+        req: {
+            baseName,
+            purposeLabel: `crashlytics-sourcemaps-${loc.toLowerCase()}`,
+            location: loc,
+            lifecycle: {
+                rule: [
+                    {
+                        action: {
+                            type: "Delete",
+                        },
+                        condition: {
+                            age: 30,
+                        },
+                    },
+                ],
+            },
+        },
+    });
+}
+async function findSourceMapMappings(files, rootDir) {
+    const jsFiles = files.filter((f) => f.name.endsWith(".js"));
+    const mapFiles = files.filter((f) => f.name.endsWith(".js.map"));
+    const mappings = [];
+    const mapFilePathsSet = new Set(mapFiles.map((f) => f.name));
+    const mapFilesLinkedInJsComment = new Set();
+    const limit = pLimit(exports.CONCURRENCY);
+    const results = await Promise.all(jsFiles.map((jsFile) => limit(async () => {
+        const mapFilePath = await getLinkedSourceMapPath(jsFile.name);
+        return { jsFile, mapFilePath };
+    })));
+    for (const { jsFile, mapFilePath } of results) {
+        if (mapFilePath && mapFilePathsSet.has(mapFilePath)) {
+            mappings.push({
+                mapFilePath,
+                obfuscatedFilePath: path.relative(rootDir, path.resolve(jsFile.name)),
+            });
+            mapFilesLinkedInJsComment.add(mapFilePath);
+        }
+    }
+    for (const mapFile of mapFiles) {
+        if (!mapFilesLinkedInJsComment.has(mapFile.name)) {
+            mappings.push({
+                mapFilePath: mapFile.name,
+                obfuscatedFilePath: path.relative(rootDir, path.resolve(mapFile.name)),
+            });
+        }
+    }
+    return mappings;
+}
+async function getLinkedSourceMapPath(jsFilePath) {
+    let fileHandle;
+    try {
+        const stat = await fs.promises.stat(jsFilePath);
+        const size = stat.size;
+        const bufferSize = Math.min(size, 4096);
+        if (bufferSize === 0) {
+            return undefined;
+        }
+        fileHandle = await fs.promises.open(jsFilePath, "r");
+        const buffer = Buffer.alloc(bufferSize);
+        const { bytesRead } = await fileHandle.read(buffer, 0, bufferSize, size - bufferSize);
+        const tail = buffer.toString("utf-8", 0, bytesRead);
+        const regex = /^\/\/\s*[#@]\s*sourceMappingURL=(?<sourceMappingURL>.+)\s*$/m;
+        const match = regex.exec(tail);
+        const sourceMappingURL = match?.groups?.sourceMappingURL?.trim();
+        if (sourceMappingURL) {
+            return path.join(path.dirname(jsFilePath), sourceMappingURL);
+        }
+    }
+    catch (e) {
+        logger_1.logger.debug(`Error reading sourceMappingURL from ${jsFilePath}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    finally {
+        if (fileHandle) {
+            try {
+                await fileHandle.close();
+            }
+            catch (e) {
+            }
+        }
+    }
+    return undefined;
+}
+async function uploadSourceMaps(mappings, request) {
+    const { projectId, bucketName, appVersion, options } = request;
+    const limit = pLimit(exports.CONCURRENCY);
+    const results = await Promise.all(mappings.map((mapping) => limit(async () => {
+        const uploadRequest = {
+            projectId,
+            mappingFile: mapping.mapFilePath,
+            obfuscatedFilePath: mapping.obfuscatedFilePath,
+            bucketName,
+            appVersion,
+            options,
+        };
+        let success = await uploadMap(uploadRequest, 1);
+        if (!success) {
+            await new Promise((res) => setTimeout(res, options.retryDelay || 5000));
+            success = await uploadMap(uploadRequest);
+        }
+        return success;
+    })));
+    let successCount = 0;
+    const failedFiles = [];
+    for (const [i, success] of results.entries()) {
+        if (success) {
+            successCount++;
+        }
+        else {
+            failedFiles.push(mappings[i].mapFilePath);
+        }
+    }
+    return {
+        successCount,
+        failedFiles,
+    };
+}
+async function uploadMap(request, attemptsRemaining = 0) {
+    const { projectId, mappingFile, obfuscatedFilePath, bucketName, appVersion, options } = request;
+    const filePath = path.relative(options.projectRoot ?? process.cwd(), mappingFile);
+    const obfuscatedPath = obfuscatedFilePath
+        .split(path.sep)
+        .map((p) => (p === ".next" ? "_next" : p))
+        .filter((p) => p !== "dev")
+        .join("/");
+    const tmpArchive = await (0, archiveFile_1.archiveFile)(filePath, { archivedFileName: "mapping.js.map" });
+    const appId = options.app || "";
+    const gcsFile = `${appId}-${appVersion}-${normalizeFileName(obfuscatedPath)}.zip`;
+    const uid = (0, utils_1.murmurHashV3)(`${appId}-${appVersion}-${obfuscatedPath}`);
+    const name = `projects/${projectId}/locations/global/mappingFiles/${uid}`;
+    const stream = fs.createReadStream(tmpArchive);
+    stream.on("error", (err) => {
+        logger_1.logger.debug(`Stream error on tmpArchive: ${err instanceof Error ? err.message : String(err)}`);
+    });
+    try {
+        const { bucket, object } = await gcs.uploadObject({
+            file: gcsFile,
+            stream,
+        }, bucketName);
+        const fileUri = `gs://${bucket}/${object}`;
+        logger_1.logger.debug(`Uploaded mapping file ${filePath} to ${fileUri}`);
+        await registerSourceMap({
+            name,
+            appId,
+            version: appVersion,
+            obfuscatedFilePath: `/${obfuscatedPath}`,
+            fileUri,
+        });
+        logger_1.logger.debug(`Registered mapping file ${filePath}`);
+        return true;
+    }
+    catch (e) {
+        if (attemptsRemaining === 0) {
+            (0, utils_1.logLabeledWarning)("crashlytics", `Failed to upload mapping file ${filePath}:\n${e instanceof Error ? e.message : String(e)}`);
+        }
+        return false;
+    }
+    finally {
+        stream.destroy();
+        try {
+            fs.rmSync(tmpArchive, { force: true });
+        }
+        catch (err) {
+            logger_1.logger.debug(`Failed to delete temporary archive ${tmpArchive}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+function normalizeFileName(fileName) {
+    return fileName.replaceAll(/\//g, "-");
+}
+async function registerSourceMap(sourceMap) {
+    const client = new apiv2_1.Client({
+        urlPrefix: "https://firebasetelemetryadmin.googleapis.com",
+        auth: true,
+        apiVersion: "v1",
+    });
+    try {
+        await client.patch(sourceMap.name, sourceMap, { queryParams: { allowMissing: "true" } });
+        logger_1.logger.debug(`Registered source map ${sourceMap.obfuscatedFilePath} with Firebase Telemetry service`);
+    }
+    catch (e) {
+        if (e instanceof error_1.FirebaseError) {
+            if (e.status === 409) {
+                return;
+            }
+        }
+        throw new error_1.FirebaseError(`Failed to register source map ${sourceMap.obfuscatedFilePath} with Firebase Telemetry service:\n${e instanceof Error ? e.message : String(e)}`);
+    }
+}

package/lib/dataconnect/ensureApis.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureApis = ensureApis;
-exports.ensureGIFApiTos = ensureGIFApiTos;
 const api = require("../api");
-const configstore_1 = require("../configstore");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
 const prefix = "dataconnect";
 async function ensureApis(projectId, silent = false) {
@@ -12,14 +10,3 @@ async function ensureApis(projectId, silent = false) {
         (0, ensureApiEnabled_1.ensure)(projectId, api.cloudSQLAdminOrigin(), prefix, silent),
     ]);
 }
-async function ensureGIFApiTos(projectId) {
-    if (configstore_1.configstore.get("gemini")) {
-        await (0, ensureApiEnabled_1.ensure)(projectId, api.cloudAiCompanionOrigin(), "");
-    }
-    else {
-        if (!(await (0, ensureApiEnabled_1.check)(projectId, api.cloudAiCompanionOrigin(), ""))) {
-            return false;
-        }
-    }
-    return true;
-}

package/lib/deploy/apphosting/deploy.js

@@ -10,6 +10,7 @@ const projectUtils_1 = require("../../projectUtils");
 const utils_1 = require("../../utils");
 const util = require("./util");
 const experiments = require("../../experiments");
+const logger_1 = require("../../logger");
 async function default_1(context, options) {
     if (Object.entries(context.backendConfigs).length === 0) {
         return;
@@ -52,31 +53,46 @@ async function default_1(context, options) {
     }));
     await Promise.all(Object.values(context.backendConfigs).map(async (cfg) => {
         const rootDir = options.projectRoot ?? process.cwd();
-        let builtAppDir;
-        const isLocalBuild = !!cfg.localBuild;
-        if (isLocalBuild) {
-            experiments.assertEnabled("apphostinglocalbuilds", "App Hosting local builds");
-            builtAppDir = context.backendLocalBuilds[cfg.backendId].buildDir;
-            if (!builtAppDir) {
-                throw new error_1.FirebaseError(`No local build dir found for ${cfg.backendId}`);
+        let localBuildScratchDir;
+        try {
+            const isLocalBuild = cfg.localBuild;
+            let outputFiles;
+            if (isLocalBuild) {
+                experiments.assertEnabled("apphostinglocalbuilds", "App Hosting local builds");
+                const localBuild = context.backendLocalBuilds[cfg.backendId];
+                outputFiles = localBuild?.outputFiles;
+                localBuildScratchDir = localBuild?.localBuildScratchDir;
+                if (!outputFiles || !localBuildScratchDir) {
+                    throw new error_1.FirebaseError(`No local build output files found for ${cfg.backendId}`);
+                }
             }
+            const zippedSourcePath = isLocalBuild
+                ? await util.createLocalBuildTarArchive(cfg, localBuildScratchDir, outputFiles ?? [])
+                : await util.createSourceDeployArchive(cfg, rootDir);
+            (0, utils_1.logLabeledBullet)("apphosting", `Zipped ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}`);
+            const backendLocation = context.backendLocations[cfg.backendId];
+            if (!backendLocation) {
+                throw new error_1.FirebaseError(`Failed to find location for backend ${cfg.backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`);
+            }
+            (0, utils_1.logLabeledBullet)("apphosting", `Uploading ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}...`);
+            const bucketName = bucketsPerLocation[backendLocation];
+            const { bucket, object } = await gcs.uploadObject({
+                file: zippedSourcePath,
+                stream: fs.createReadStream(zippedSourcePath),
+            }, bucketName, isLocalBuild ? gcs.ContentType.TAR : gcs.ContentType.ZIP);
+            (0, utils_1.logLabeledBullet)("apphosting", `Uploaded at gs://${bucket}/${object}`);
+            context.backendStorageUris[cfg.backendId] =
+                `gs://${bucketName}/${path.basename(zippedSourcePath)}`;
         }
-        const zippedSourcePath = isLocalBuild
-            ? await util.createLocalBuildTarArchive(cfg, rootDir, builtAppDir)
-            : await util.createSourceDeployArchive(cfg, rootDir);
-        (0, utils_1.logLabeledBullet)("apphosting", `Zipped ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}`);
-        const backendLocation = context.backendLocations[cfg.backendId];
-        if (!backendLocation) {
-            throw new error_1.FirebaseError(`Failed to find location for backend ${cfg.backendId}. Please contact support with the contents of your firebase-debug.log to report your issue.`);
+        finally {
+            if (localBuildScratchDir && fs.existsSync(localBuildScratchDir)) {
+                try {
+                    fs.rmSync(localBuildScratchDir, { recursive: true, force: true });
+                }
+                catch (err) {
+                    logger_1.logger.debug(`Failed to clean up local build directory ${localBuildScratchDir}: ${err}`);
+                }
+            }
         }
-        (0, utils_1.logLabeledBullet)("apphosting", `Uploading ${isLocalBuild ? "built app" : "source"} for backend ${cfg.backendId}...`);
-        const bucketName = bucketsPerLocation[backendLocation];
-        const { bucket, object } = await gcs.uploadObject({
-            file: zippedSourcePath,
-            stream: fs.createReadStream(zippedSourcePath),
-        }, bucketName, isLocalBuild ? gcs.ContentType.TAR : gcs.ContentType.ZIP);
-        (0, utils_1.logLabeledBullet)("apphosting", `Uploaded at gs://${bucket}/${object}`);
-        context.backendStorageUris[cfg.backendId] =
-            `gs://${bucketName}/${path.basename(zippedSourcePath)}`;
     }));
 }

package/lib/deploy/apphosting/prepare.js

@@ -4,7 +4,12 @@ exports.default = default_1;
 exports.injectEnvVarsFromApphostingConfig = injectEnvVarsFromApphostingConfig;
 exports.injectAutoInitEnvVars = injectAutoInitEnvVars;
 exports.getBackendConfigs = getBackendConfigs;
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
 const path = require("path");
+const fsAsync = require("../../fsAsync");
+const util_1 = require("./util");
 const backend_1 = require("../../apphosting/backend");
 const apphosting_1 = require("../../gcp/apphosting");
 const yaml_1 = require("../../apphosting/yaml");
@@ -132,21 +137,22 @@ async function default_1(context, options) {
         (0, utils_1.logLabeledBullet)("apphosting", `Starting local build for backend ${cfg.backendId}`);
         await injectEnvVarsFromApphostingConfig(configs.filter((c) => c.backendId === cfg.backendId), options, buildEnv, runtimeEnv);
         await injectAutoInitEnvVars(cfg, backends, buildEnv, runtimeEnv);
+        const rootDir = path.resolve(options.projectRoot || process.cwd());
+        const pathHash = crypto.createHash("md5").update(rootDir).digest("hex").substring(0, 8);
+        const localBuildScratchDir = path.join(os.tmpdir(), `apphosting-local-build-${cfg.backendId}-${pathHash}`);
         try {
-            const { outputFiles, annotations, buildConfig } = await (0, localbuilds_1.localBuild)(projectId, options.projectRoot || "./", "nextjs", buildEnv[cfg.backendId] || {}, {
+            await prepareLocalBuildScratchDirectory(rootDir, localBuildScratchDir, cfg);
+            const { outputFiles, buildConfig } = await (0, localbuilds_1.localBuild)(projectId, localBuildScratchDir, buildEnv[cfg.backendId] || {}, {
                 nonInteractive: options.nonInteractive,
                 allowLocalBuildSecrets: !!options.allowLocalBuildSecrets,
             });
-            if (outputFiles.length !== 1) {
-                throw new error_1.FirebaseError(`Local build for backend ${cfg.backendId} failed: No output files found.`);
-            }
             context.backendLocalBuilds[cfg.backendId] = {
-                buildDir: outputFiles[0],
+                outputFiles,
+                localBuildScratchDir,
                 buildConfig: {
                     ...buildConfig,
                     env: mergeEnvVars(buildConfig.env || [], runtimeEnv[cfg.backendId] || {}),
                 },
-                annotations,
             };
         }
         catch (e) {
@@ -244,3 +250,19 @@ async function ensureAppHostingServiceAgentRoles(projectId, projectNumber) {
         (0, utils_1.logLabeledWarning)("apphosting", `Unable to verify App Hosting service agent permissions for ${p4saEmail}. If you encounter a PERMISSION_DENIED error during rollout, please ensure the service agent has the "Storage Object Viewer" role.`);
     }
 }
+async function prepareLocalBuildScratchDirectory(rootDir, localBuildScratchDir, cfg) {
+    const ignore = (0, util_1.resolveIgnorePatterns)(cfg);
+    fs.rmSync(localBuildScratchDir, { recursive: true, force: true });
+    fs.mkdirSync(localBuildScratchDir, { recursive: true });
+    const filesToCopy = await fsAsync.readdirRecursive({
+        path: rootDir,
+        ignoreStrings: ignore,
+        supportGitIgnore: true,
+    });
+    for (const file of filesToCopy) {
+        const relativePath = path.relative(rootDir, file.name);
+        const destPath = path.join(localBuildScratchDir, relativePath);
+        fs.mkdirSync(path.dirname(destPath), { recursive: true });
+        fs.copyFileSync(file.name, destPath);
+    }
+}

package/lib/deploy/apphosting/util.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLocalBuildTarArchive = createLocalBuildTarArchive;
 exports.createSourceDeployArchive = createSourceDeployArchive;
+exports.resolveIgnorePatterns = resolveIgnorePatterns;
 const archiver = require("archiver");
 const fs = require("fs");
 const path = require("path");
@@ -9,25 +10,28 @@ const tar = require("tar");
 const tmp = require("tmp");
 const error_1 = require("../../error");
 const fsAsync = require("../../fsAsync");
-const config_1 = require("../../apphosting/config");
-async function createLocalBuildTarArchive(config, rootDir, targetSubDir) {
+const utils_1 = require("../../utils");
+async function createLocalBuildTarArchive(config, rootDir, outputFiles) {
     const tmpFile = tmp.fileSync({ prefix: `${config.backendId}-`, postfix: ".tar.gz" }).name;
-    const targetDir = targetSubDir ? path.join(rootDir, targetSubDir) : rootDir;
-    const ignore = ["firebase-debug.log", "firebase-debug.*.log", ".git"];
-    const rdrFiles = await fsAsync.readdirRecursive({
-        path: targetDir,
-        ignoreStrings: ignore,
-        supportGitIgnore: true,
-    });
-    const allFiles = rdrFiles.map((rdrf) => path.relative(rootDir, rdrf.name));
-    if (targetSubDir) {
-        const defaultFiles = fs.readdirSync(rootDir).filter((file) => {
-            return config_1.APPHOSTING_YAML_FILE_REGEX.test(file);
-        });
-        for (const file of defaultFiles) {
-            if (!allFiles.includes(file)) {
-                allFiles.push(file);
-            }
+    const filesToPackage = outputFiles.length > 0 ? outputFiles : ["."];
+    const allFiles = [];
+    for (const fileOrDir of filesToPackage) {
+        const absolutePath = path.join(rootDir, fileOrDir);
+        if (!fs.existsSync(absolutePath)) {
+            (0, utils_1.logLabeledWarning)("apphosting", `Expected build output file or directory not found: ${fileOrDir}`);
+            continue;
+        }
+        const stat = fs.statSync(absolutePath);
+        if (stat.isDirectory()) {
+            const rdrFiles = await fsAsync.readdirRecursive({
+                path: absolutePath,
+                ignoreStrings: ["firebase-debug.log", "firebase-debug.*.log"],
+                supportGitIgnore: false,
+            });
+            allFiles.push(...rdrFiles.map((rdrf) => path.relative(rootDir, rdrf.name)));
+        }
+        else {
+            allFiles.push(path.relative(rootDir, absolutePath));
         }
     }
     try {
@@ -58,8 +62,7 @@ async function createSourceDeployArchive(config, rootDir, targetSubDir) {
     });
     const archive = archiver("zip");
     const targetDir = targetSubDir ? path.join(rootDir, targetSubDir) : rootDir;
-    const ignore = config.ignore || ["node_modules", ".git"];
-    ignore.push("firebase-debug.log", "firebase-debug.*.log");
+    const ignore = resolveIgnorePatterns(config);
     try {
         const files = await fsAsync.readdirRecursive({
             path: targetDir,
@@ -76,10 +79,20 @@ async function createSourceDeployArchive(config, rootDir, targetSubDir) {
         await pipeAsync(archive, fileStream);
     }
     catch (err) {
-        throw new error_1.FirebaseError(`Could not read source directory. Remove links and shortcuts and try again. Original: ${err}`, { original: err, exit: 1 });
+        throw new error_1.FirebaseError(`Could not read source directory. Remove links and shortcuts and try again. Original: ${String(err)}`, { original: err, exit: 1 });
     }
     return tmpFile;
 }
+function resolveIgnorePatterns(config, skipDefaultNodeModules = false) {
+    const ignore = config.ignore
+        ? [...config.ignore]
+        : skipDefaultNodeModules
+            ? [".git"]
+            : ["node_modules", ".git"];
+    ignore.push("firebase-debug.log", "firebase-debug.*.log");
+    ignore.push(".local_build_*");
+    return ignore;
+}
 async function pipeAsync(from, to) {
     from.pipe(to);
     await from.finalize();

package/lib/deploy/functions/prepare.js

@@ -249,12 +249,11 @@ async function resolveDefaultRegionsForBuild(buildObj, have) {
             }
             else {
                 try {
-                    const fullEndpoint = { ...endpoint, id };
                     if (build.isBlockingTriggered(endpoint)) {
-                        resolvedRegion = resolveRegionForBlockingTrigger(fullEndpoint);
+                        resolvedRegion = resolveRegionForBlockingTrigger(endpoint.blockingTrigger);
                     }
                     else if (build.isEventTriggered(endpoint)) {
-                        resolvedRegion = await resolveRegionForEventTrigger(fullEndpoint);
+                        resolvedRegion = await resolveRegionForEventTrigger(endpoint.project, endpoint.eventTrigger);
                     }
                 }
                 catch (err) {
@@ -265,18 +264,17 @@ async function resolveDefaultRegionsForBuild(buildObj, have) {
         }
     }
 }
-function resolveRegionForBlockingTrigger(endpoint) {
-    const eventType = endpoint.blockingTrigger.eventType;
+function resolveRegionForBlockingTrigger(blockingTrigger) {
+    const eventType = blockingTrigger.eventType;
     if (events.AUTH_BLOCKING_EVENTS.includes(eventType)) {
         return "us-east1";
     }
-    if ((0, ailogic_1.isGlobalAILogicEndpoint)(endpoint)) {
+    if ((0, ailogic_1.isGlobalAILogicTrigger)(blockingTrigger)) {
         return "us-east1";
     }
     return exports.DEFAULT_FUNCTION_REGION;
 }
-async function resolveRegionForEventTrigger(endpoint) {
-    const eventTrigger = endpoint.eventTrigger;
+async function resolveRegionForEventTrigger(project, eventTrigger) {
     const eventType = eventTrigger.eventType;
     if (eventType.startsWith("google.cloud.pubsub.") ||
         eventType.startsWith("providers/cloud.auth/eventTypes/") ||
@@ -289,7 +287,7 @@ async function resolveRegionForEventTrigger(endpoint) {
     if (eventType.startsWith("google.cloud.firestore.")) {
         try {
             const databaseId = eventTrigger.eventFilters?.database || "(default)";
-            const db = await (0, firestore_1.getDatabase)(endpoint.project, databaseId);
+            const db = await (0, firestore_1.getDatabase)(project, databaseId);
             const locationId = db.locationId.toLowerCase();
             if (locationId === "nam5" || locationId === "nam7")
                 return "us-central1";
@@ -326,7 +324,7 @@ async function resolveRegionForEventTrigger(endpoint) {
         try {
             const instanceName = eventTrigger.eventFilters?.instance;
             if (instanceName) {
-                const details = await (0, database_1.getDatabaseInstanceDetails)(endpoint.project, instanceName);
+                const details = await (0, database_1.getDatabaseInstanceDetails)(project, instanceName);
                 if (details.location && details.location !== "-") {
                     return details.location.toLowerCase();
                 }

package/lib/deploy/functions/services/ailogic.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AILogicService = exports.AI_LOGIC_EVENTS = exports.AI_LOGIC_AFTER_GENERATE_CONTENT = exports.AI_LOGIC_BEFORE_GENERATE_CONTENT = void 0;
 exports.isAILogicEvent = isAILogicEvent;
-exports.isGlobalAILogicEndpoint = isGlobalAILogicEndpoint;
+exports.isGlobalAILogicTrigger = isGlobalAILogicTrigger;
 const backend = require("../backend");
 const error_1 = require("../../../error");
 const ailogicApi = require("../../../gcp/ailogic");
@@ -20,11 +20,9 @@ function isAILogicEvent(endpoint) {
     }
     return exports.AI_LOGIC_EVENTS.includes(endpoint.blockingTrigger.eventType);
 }
-function isGlobalAILogicEndpoint(endpoint) {
-    if (!isAILogicEvent(endpoint)) {
-        return false;
-    }
-    return !endpoint.blockingTrigger.options?.regionalWebhook;
+function isGlobalAILogicTrigger(blockingTrigger) {
+    return (exports.AI_LOGIC_EVENTS.includes(blockingTrigger.eventType) &&
+        !blockingTrigger.options?.regionalWebhook);
 }
 class AILogicService {
     constructor() {