firebase-tools 15.5.0 → 15.6.0

package/lib/apiv2.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.CLI_OAUTH_PROJECT_NUMBER = exports.STANDARD_HEADERS = void 0;
+exports.Client = exports.CLI_OAUTH_PROJECT_NUMBER = exports.GOOG_USER_PROJECT_HEADER = exports.STANDARD_HEADERS = void 0;
 exports.setRefreshToken = setRefreshToken;
 exports.setAccessToken = setAccessToken;
 exports.getAccessToken = getAccessToken;
@@ -29,7 +29,7 @@ exports.STANDARD_HEADERS = {
     "X-Client-Version": clientVersion,
 };
 const GOOG_QUOTA_USER_HEADER = "x-goog-quota-user";
-const GOOG_USER_PROJECT_HEADER = "x-goog-user-project";
+exports.GOOG_USER_PROJECT_HEADER = "x-goog-user-project";
 const GOOGLE_CLOUD_QUOTA_PROJECT = process.env.GOOGLE_CLOUD_QUOTA_PROJECT;
 exports.CLI_OAUTH_PROJECT_NUMBER = "563584335869";
 let accessToken = "";
@@ -163,7 +163,7 @@ class Client {
         if (!reqOptions.ignoreQuotaProject &&
             GOOGLE_CLOUD_QUOTA_PROJECT &&
             GOOGLE_CLOUD_QUOTA_PROJECT !== "") {
-            reqOptions.headers.set(GOOG_USER_PROJECT_HEADER, GOOGLE_CLOUD_QUOTA_PROJECT);
+            reqOptions.headers.set(exports.GOOG_USER_PROJECT_HEADER, GOOGLE_CLOUD_QUOTA_PROJECT);
         }
         return reqOptions;
     }
@@ -352,8 +352,14 @@ class Client {
         const logURL = this.requestURL(options);
         logger_1.logger.debug(`>>> [apiv2][query] ${options.method} ${logURL} ${queryParamsLog}`);
         const headers = options.headers;
-        if (headers && headers.has(GOOG_QUOTA_USER_HEADER)) {
-            logger_1.logger.debug(`>>> [apiv2][(partial)header] ${options.method} ${logURL} x-goog-quota-user=${headers.get(GOOG_QUOTA_USER_HEADER) || ""}`);
+        if (headers && (headers.has(GOOG_QUOTA_USER_HEADER) || headers.has(exports.GOOG_USER_PROJECT_HEADER))) {
+            const userHeader = headers.has(GOOG_QUOTA_USER_HEADER)
+                ? `${GOOG_QUOTA_USER_HEADER}=${headers.get(GOOG_QUOTA_USER_HEADER)}`
+                : "";
+            const projectHeader = headers.has(exports.GOOG_USER_PROJECT_HEADER)
+                ? `${exports.GOOG_USER_PROJECT_HEADER}=${headers.get(exports.GOOG_USER_PROJECT_HEADER)}`
+                : "";
+            logger_1.logger.debug(`>>> [apiv2][(partial)header] ${options.method} ${logURL} ${userHeader} ${projectHeader}`);
         }
         if (options.body !== undefined) {
             let logBody = "[omitted]";

package/lib/apphosting/backend.js

@@ -190,7 +190,7 @@ async function ensureAppHostingComputeServiceAccount(projectId, serviceAccount)
     const sa = serviceAccount || defaultComputeServiceAccountEmail(projectId);
     const name = `projects/${projectId}/serviceAccounts/${sa}`;
     try {
-        await iam.testResourceIamPermissions((0, api_1.iamOrigin)(), "v1", name, ["iam.serviceAccounts.actAs"], `projects/${projectId}`);
+        await iam.testResourceIamPermissions((0, api_1.iamOrigin)(), "v1", name, ["iam.serviceAccounts.actAs"], `${projectId}`);
     }
     catch (err) {
         if (!(err instanceof error_1.FirebaseError)) {

package/lib/commands/deploy.js

@@ -26,6 +26,7 @@ exports.VALID_DEPLOY_TARGETS = [
     "extensions",
     "dataconnect",
     "apphosting",
+    "auth",
 ];
 exports.TARGET_PERMISSIONS = {
     database: ["firebasedatabase.instances.update"],
@@ -73,6 +74,8 @@ exports.TARGET_PERMISSIONS = {
         "firebasedataconnect.schemas.list",
         "firebasedataconnect.schemas.update",
     ],
+    apphosting: [],
+    auth: ["firebase.projects.update", "firebaseauth.configs.update"],
 };
 exports.command = new command_1.Command("deploy")
     .description("deploy code and assets to your Firebase project")

package/lib/commands/init.js

@@ -88,6 +88,11 @@ let choices = [
         checked: false,
         hidden: true,
     },
+    {
+        value: "auth",
+        name: "Authentication: Set up Firebase Authentication",
+        checked: false,
+    },
 ];
 if ((0, experiments_1.isEnabled)("fdcwebhooks")) {
     choices.push({

package/lib/config.js

@@ -261,6 +261,7 @@ Config.MATERIALIZE_TARGETS = [
     "remoteconfig",
     "dataconnect",
     "apphosting",
+    "auth",
 ];
 function stringifyContent(content) {
     if (typeof content === "string") {

package/lib/dataconnect/client.js

@@ -117,8 +117,8 @@ async function upsertSchema(schema, validateOnly = false, async = false) {
         masterTimeout: 60000,
     });
 }
-async function deleteSchema(serviceName) {
-    const op = await dataconnectClient().delete(`${serviceName}/schemas/${types.MAIN_SCHEMA_ID}`);
+async function deleteSchema(name) {
+    const op = await dataconnectClient().delete(name);
     await operationPoller.pollOperation({
         apiOrigin: (0, api_1.dataconnectOrigin)(),
         apiVersion: DATACONNECT_API_VERSION,

package/lib/dataconnect/prompts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.promptDeleteConnector = promptDeleteConnector;
+exports.promptDeleteSchema = promptDeleteSchema;
 const prompt_1 = require("../prompt");
 const utils = require("../utils");
 const client_1 = require("./client");
@@ -17,3 +18,16 @@ async function promptDeleteConnector(options, connectorName) {
         utils.logLabeledSuccess("dataconnect", `Connector ${connectorName} deleted`);
     }
 }
+async function promptDeleteSchema(options, schemaName) {
+    utils.logLabeledWarning("dataconnect", `Schema ${schemaName} exists but is not listed in dataconnect.yaml.`);
+    const confirmDeletion = await (0, prompt_1.confirm)({
+        default: false,
+        message: `Do you want to delete the schema ${schemaName}?`,
+        force: options.force,
+        nonInteractive: options.nonInteractive,
+    });
+    if (confirmDeletion) {
+        await (0, client_1.deleteSchema)(schemaName);
+        utils.logLabeledSuccess("dataconnect", `Schema ${schemaName} deleted`);
+    }
+}

package/lib/deploy/auth/deploy.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploy = deploy;
+const projectUtils_1 = require("../../projectUtils");
+const provision_1 = require("../../management/provisioning/provision");
+const apps_1 = require("../../management/apps");
+const types_1 = require("../../management/provisioning/types");
+const logger_1 = require("../../logger");
+const utils_1 = require("../../utils");
+async function deploy(context, options) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const config = options.config.src.auth;
+    if (!config) {
+        return;
+    }
+    const appId = context.auth?.appId;
+    if (!appId) {
+        return;
+    }
+    const authInput = {};
+    const providers = config.providers;
+    const logMsg = [];
+    if (providers) {
+        if (providers.anonymous === true) {
+            logMsg.push("anonymous");
+            authInput.anonymousAuthProviderMode = types_1.ProviderMode.PROVIDER_ENABLED;
+        }
+        if (providers.emailPassword === true) {
+            logMsg.push("email/password");
+            authInput.emailAuthProviderMode = types_1.ProviderMode.PROVIDER_ENABLED;
+        }
+        if (providers.googleSignIn) {
+            logMsg.push("Google sign-in");
+            authInput.googleSigninProviderMode = types_1.ProviderMode.PROVIDER_ENABLED;
+            authInput.googleSigninProviderConfig = {
+                publicDisplayName: providers.googleSignIn.oAuthBrandDisplayName,
+                customerSupportEmail: providers.googleSignIn.supportEmail,
+                oauthRedirectUris: providers.googleSignIn.authorizedRedirectUris,
+            };
+        }
+    }
+    if (Object.keys(authInput).length === 0) {
+        logger_1.logger.debug("[auth] No auth providers configured to enable.");
+        return;
+    }
+    logger_1.logger.info(`Enabling auth providers: ${logMsg.join(", ")}...`);
+    await (0, provision_1.provisionFirebaseApp)({
+        project: {
+            parent: {
+                type: "existing_project",
+                projectId: projectId,
+            },
+        },
+        app: {
+            platform: apps_1.AppPlatform.WEB,
+            appId: appId,
+        },
+        features: {
+            firebaseAuthInput: authInput,
+        },
+    });
+    (0, utils_1.logSuccess)(`Auth providers enabled: ${logMsg.join(", ")}`);
+}

package/lib/deploy/auth/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.deploy = exports.prepare = void 0;
+var prepare_1 = require("./prepare");
+Object.defineProperty(exports, "prepare", { enumerable: true, get: function () { return prepare_1.prepare; } });
+var deploy_1 = require("./deploy");
+Object.defineProperty(exports, "deploy", { enumerable: true, get: function () { return deploy_1.deploy; } });
+var release_1 = require("./release");
+Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.release; } });

package/lib/deploy/auth/prepare.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepare = prepare;
+const apps_1 = require("../../management/apps");
+const logger_1 = require("../../logger");
+const projectUtils_1 = require("../../projectUtils");
+async function prepare(context, options) {
+    const projectId = (0, projectUtils_1.needProjectId)(options);
+    const config = options.config.src.auth;
+    if (!config) {
+        return;
+    }
+    const apps = await (0, apps_1.listFirebaseApps)(projectId, apps_1.AppPlatform.WEB);
+    let app = apps.find((a) => a.displayName === "Default Web App");
+    if (!app && apps.length > 0) {
+        app = apps[0];
+    }
+    if (!app) {
+        logger_1.logger.info("No Firebase Web App found. Creating 'Default Web App' for Auth provisioning...");
+        app = await (0, apps_1.createWebApp)(projectId, {
+            displayName: "Default Web App",
+        });
+    }
+    context.auth = context.auth || {};
+    context.auth.appId = app.appId;
+}

package/lib/deploy/auth/release.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = release;
+async function release() {
+}

package/lib/deploy/dataconnect/release.js

@@ -88,6 +88,13 @@ async function default_1(context, options) {
     for (const c of connectorsToDelete) {
         await (0, prompts_1.promptDeleteConnector)(options, c.name);
     }
+    const allSchemas = await deployedSchemas(serviceInfos);
+    const schemasToDelete = filters
+        ? []
+        : allSchemas.filter((s) => !wantSecondarySchemas.some((w) => w.name === s.name) && !(0, types_1.isMainSchema)(s));
+    for (const s of schemasToDelete) {
+        await (0, prompts_1.promptDeleteSchema)(options, s.name);
+    }
     let consolePath = "/dataconnect";
     if (serviceInfos.length === 1) {
         const sn = (0, names_1.parseServiceName)(serviceInfos[0].serviceName);
@@ -106,3 +113,7 @@ async function deployedConnectors(serviceInfos) {
     }
     return connectors;
 }
+async function deployedSchemas(serviceInfos) {
+    const schemasPerService = await Promise.all(serviceInfos.map((si) => (0, client_1.listSchemas)(si.serviceName)));
+    return schemasPerService.flat();
+}

package/lib/deploy/functions/backend.js

@@ -29,6 +29,7 @@ exports.findEndpoint = findEndpoint;
 exports.matchingBackend = matchingBackend;
 exports.regionalEndpoints = regionalEndpoints;
 exports.compareFunctions = compareFunctions;
+exports.maybeDeterministicCloudRunUri = maybeDeterministicCloudRunUri;
 const gcf = require("../../gcp/cloudfunctions");
 const gcfV2 = require("../../gcp/cloudfunctionsv2");
 const run = require("../../gcp/runv2");
@@ -340,3 +341,12 @@ function compareFunctions(left, right) {
     }
     return 0;
 }
+function maybeDeterministicCloudRunUri(httpsFunc, projectNumber) {
+    const serviceName = httpsFunc.id.toLowerCase().replaceAll("_", "-");
+    const dnsSegment = `${serviceName}-${projectNumber}`;
+    if (dnsSegment.length > 63) {
+        logger_1.logger.info(`Function name ${httpsFunc.id} is too long to have a deterministic Cloud Run URI. Printing the non-deterministic URI instead.`);
+        return httpsFunc.uri;
+    }
+    return `https://${serviceName}-${projectNumber}.${httpsFunc.region}.run.app`;
+}

package/lib/deploy/functions/build.js

@@ -55,7 +55,7 @@ function isBlockingTriggered(triggered) {
     return {}.hasOwnProperty.call(triggered, "blockingTrigger");
 }
 const allMemoryOptions = [128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768];
-exports.AllFunctionsPlatforms = ["gcfv1", "gcfv2"];
+exports.AllFunctionsPlatforms = ["gcfv1", "gcfv2", "run"];
 exports.AllVpcEgressSettings = ["PRIVATE_RANGES_ONLY", "ALL_TRAFFIC"];
 exports.AllIngressSettings = [
     "ALLOW_ALL",
@@ -207,7 +207,7 @@ function toBackend(build, paramValues) {
                 runtime: bdEndpoint.runtime,
                 ...trigger,
             };
-            proto.copyIfPresent(bkEndpoint, bdEndpoint, "environmentVariables", "labels", "secretEnvironmentVariables");
+            proto.copyIfPresent(bkEndpoint, bdEndpoint, "environmentVariables", "labels", "secretEnvironmentVariables", "baseImageUri", "command", "args");
             r.resolveStrings(bkEndpoint, bdEndpoint, "serviceAccount");
             proto.convertIfPresent(bkEndpoint, bdEndpoint, "ingressSettings", (from) => {
                 if (from !== null && !backend.AllIngressSettings.includes(from)) {

package/lib/deploy/functions/checkIam.js

@@ -52,8 +52,9 @@ async function checkHttpIam(context, options, payload) {
     const filters = context.filters || (0, functionsDeployHelper_1.getEndpointFilters)(options, context.config);
     const wantBackends = Object.values(payload.functions).map(({ wantBackend }) => wantBackend);
     const httpEndpoints = [...(0, functional_1.flattenArray)(wantBackends.map((b) => backend.allEndpoints(b)))]
-        .filter(backend.isHttpsTriggered || backend.isDataConnectGraphqlTriggered)
-        .filter((f) => (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(f, filters));
+        .filter((f) => backend.isHttpsTriggered(f) || backend.isDataConnectGraphqlTriggered(f))
+        .filter((f) => (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(f, filters))
+        .filter((f) => f.platform !== "run");
     const existing = await backend.existingBackend(context);
     const newHttpsEndpoints = httpEndpoints.filter(backend.missingEndpoint(existing));
     if (newHttpsEndpoints.length === 0) {

package/lib/deploy/functions/deploy.js

@@ -18,6 +18,7 @@ const experiments = require("../../experiments");
 const backend_1 = require("./backend");
 const extensions_1 = require("../extensions");
 const getProjectNumber_1 = require("../../getProjectNumber");
+const path = require("path");
 (0, tmp_1.setGracefulCleanup)();
 async function uploadSourceV1(projectId, source, wantBackend) {
     const v1Endpoints = backend.allEndpoints(wantBackend).filter((e) => e.platform === "gcfv1");
@@ -53,7 +54,8 @@ async function uploadSourceV2(projectId, projectNumber, source, wantBackend) {
         file: source.functionsSourceV2,
         stream: exports.createReadStream(source.functionsSourceV2),
     };
-    if (!experiments.isEnabled("runfunctions")) {
+    if (!experiments.isEnabled("functionsrunapionly") &&
+        !v2Endpoints.some((e) => e.platform === "run")) {
         if (process.env.GOOGLE_CLOUD_QUOTA_PROJECT) {
             (0, utils_1.logLabeledWarning)("functions", "GOOGLE_CLOUD_QUOTA_PROJECT is not usable when uploading source for Cloud Functions.");
         }
@@ -80,7 +82,7 @@ async function uploadSourceV2(projectId, projectNumber, source, wantBackend) {
             },
         },
     });
-    const objectPath = `${source.functionsSourceV2Hash}.zip`;
+    const objectPath = `${source.functionsSourceV2Hash}${path.extname(source.functionsSourceV2)}`;
     await gcs.upload(uploadOpts, `${bucketName}/${objectPath}`, undefined, true);
     return {
         bucket: bucketName,

package/lib/deploy/functions/prepare.js

@@ -157,7 +157,7 @@ async function prepare(context, options, payload) {
         if (backend.someEndpoint(wantBackend, () => true)) {
             (0, utils_1.logLabeledBullet)("functions", `preparing ${clc.bold(sourceDirName)} directory for uploading...`);
         }
-        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2")) {
+        if (backend.someEndpoint(wantBackend, (e) => e.platform === "gcfv2" || e.platform === "run")) {
             const schPathSet = new Set();
             for (const e of backend.allEndpoints(wantBackend)) {
                 if (backend.isDataConnectGraphqlTriggered(e) &&
@@ -165,7 +165,10 @@ async function prepare(context, options, payload) {
                     schPathSet.add(e.dataConnectGraphqlTrigger.schemaFilePath);
                 }
             }
-            const packagedSource = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(options.config.projectDir, sourceDir, localCfg, [...schPathSet]);
+            const exportType = backend.someEndpoint(wantBackend, (e) => e.platform === "run")
+                ? "tar.gz"
+                : "zip";
+            const packagedSource = await (0, prepareFunctionsUpload_1.prepareFunctionsUpload)(options.config.projectDir, sourceDir, localCfg, [...schPathSet], undefined, { exportType });
             source.functionsSourceV2 = packagedSource?.pathToSource;
             source.functionsSourceV2Hash = packagedSource?.hash;
         }

package/lib/deploy/functions/prepareFunctionsUpload.js

@@ -44,13 +44,15 @@ async function pipeAsync(from, to) {
         to.on("error", reject);
     });
 }
-async function packageSource(projectDir, sourceDir, config, additionalSources, runtimeConfig) {
-    const tmpFile = tmp.fileSync({ prefix: "firebase-functions-", postfix: ".zip" }).name;
+async function packageSource(projectDir, sourceDir, config, additionalSources, runtimeConfig, options) {
+    const exportType = options?.exportType || "zip";
+    const postfix = `.${exportType}`;
+    const tmpFile = tmp.fileSync({ prefix: "firebase-functions-", postfix }).name;
     const fileStream = fs.createWriteStream(tmpFile, {
         flags: "w",
         encoding: "binary",
     });
-    const archive = archiver("zip");
+    const archive = exportType === "tar.gz" ? archiver("tar", { gzip: true }) : archiver("zip");
     const hashes = [];
     const ignore = config.ignore || ["node_modules", ".git"];
     ignore.push("firebase-debug.log", "firebase-debug.*.log", CONFIG_DEST_FILE);
@@ -110,8 +112,8 @@ async function packageSource(projectDir, sourceDir, config, additionalSources, r
     const hash = hashes.join(".");
     return { pathToSource: tmpFile, hash };
 }
-async function prepareFunctionsUpload(projectDir, sourceDir, config, additionalSources, runtimeConfig) {
-    return packageSource(projectDir, sourceDir, config, additionalSources, runtimeConfig);
+async function prepareFunctionsUpload(projectDir, sourceDir, config, additionalSources, runtimeConfig, options) {
+    return packageSource(projectDir, sourceDir, config, additionalSources, runtimeConfig, options);
 }
 function convertToSortedKeyValueArray(config) {
     if (typeof config !== "object" || config === null)

package/lib/deploy/functions/release/fabricator.js

@@ -22,6 +22,7 @@ const poller = require("../../../operation-poller");
 const pubsub = require("../../../gcp/pubsub");
 const reporter = require("./reporter");
 const run = require("../../../gcp/run");
+const runV2 = require("../../../gcp/runv2");
 const scheduler = require("../../../gcp/cloudscheduler");
 const utils = require("../../../utils");
 const services = require("../services");
@@ -138,9 +139,7 @@ class Fabricator {
             await this.createV2Function(endpoint, scraperV2);
         }
         else if (endpoint.platform === "run") {
-            throw new error_1.FirebaseError("Creating new Cloud Run functions is not supported yet.", {
-                exit: 1,
-            });
+            await this.createRunFunction(endpoint);
         }
         else {
             (0, functional_1.assertExhaustive)(endpoint.platform);
@@ -161,7 +160,7 @@ class Fabricator {
             await this.updateV2Function(update.endpoint, scraperV2);
         }
         else if (update.endpoint.platform === "run") {
-            throw new error_1.FirebaseError("Updating Cloud Run functions is not supported yet.", { exit: 1 });
+            await this.updateRunFunction(update);
         }
         else {
             (0, functional_1.assertExhaustive)(update.endpoint.platform);
@@ -177,7 +176,7 @@ class Fabricator {
             return this.deleteV2Function(endpoint);
         }
         else if (endpoint.platform === "run") {
-            throw new error_1.FirebaseError("Deleting Cloud Run functions is not supported yet.", { exit: 1 });
+            return this.deleteRunFunction(endpoint);
         }
         (0, functional_1.assertExhaustive)(endpoint.platform);
     }
@@ -507,6 +506,80 @@ class Fabricator {
         }, { retryCodes: [...executor_1.DEFAULT_RETRY_CODES, CLOUD_RUN_RESOURCE_EXHAUSTED_CODE] })
             .catch(rethrowAs(endpoint, "delete"));
     }
+    async createRunFunction(endpoint) {
+        const storageSource = this.sources[endpoint.codebase]?.storage;
+        if (!storageSource) {
+            logger_1.logger.debug("Precondition failed. Cannot create a Cloud Run function without storage");
+            throw new Error("Precondition failed");
+        }
+        const service = runV2.serviceFromEndpoint(endpoint, "scratch");
+        const container = service.template.containers[0];
+        container.sourceCode = {
+            cloudStorageSource: {
+                bucket: storageSource.bucket,
+                object: storageSource.object,
+                generation: storageSource.generation ? String(storageSource.generation) : undefined,
+            },
+        };
+        await this.executor
+            .run(async () => {
+            const op = await runV2.createService(endpoint.project, endpoint.region, endpoint.id, service);
+            endpoint.uri = op.uri;
+            endpoint.runServiceId = endpoint.id;
+        })
+            .catch(rethrowAs(endpoint, "create"));
+        await this.setInvoker(endpoint);
+    }
+    async updateRunFunction(update) {
+        const endpoint = update.endpoint;
+        const storageSource = this.sources[endpoint.codebase]?.storage;
+        if (!storageSource) {
+            logger_1.logger.debug("Precondition failed. Cannot update a Cloud Run function without storage");
+            throw new Error("Precondition failed");
+        }
+        const service = runV2.serviceFromEndpoint(endpoint, "scratch");
+        const container = service.template.containers[0];
+        container.sourceCode = {
+            cloudStorageSource: {
+                bucket: storageSource.bucket,
+                object: storageSource.object,
+                generation: storageSource.generation ? String(storageSource.generation) : undefined,
+            },
+        };
+        await this.executor
+            .run(async () => {
+            const op = await runV2.updateService(service);
+            endpoint.uri = op.uri;
+            endpoint.runServiceId = endpoint.id;
+        })
+            .catch(rethrowAs(endpoint, "update"));
+        await this.setInvoker(endpoint);
+    }
+    async deleteRunFunction(endpoint) {
+        await this.executor
+            .run(async () => {
+            try {
+                await runV2.deleteService(endpoint.project, endpoint.region, endpoint.id);
+            }
+            catch (err) {
+                if (err.status === 404) {
+                    return;
+                }
+                throw err;
+            }
+        })
+            .catch(rethrowAs(endpoint, "delete"));
+    }
+    async setInvoker(endpoint) {
+        if (backend.isHttpsTriggered(endpoint)) {
+            const invoker = endpoint.httpsTrigger.invoker || ["public"];
+            if (!invoker.includes("private")) {
+                await this.executor
+                    .run(() => run.setInvokerUpdate(endpoint.project, `projects/${endpoint.project}/locations/${endpoint.region}/services/${endpoint.runServiceId}`, invoker))
+                    .catch(rethrowAs(endpoint, "set invoker"));
+            }
+        }
+    }
     async setRunTraits(serviceName, endpoint) {
         await this.functionExecutor
             .run(async () => {
@@ -530,11 +603,6 @@ class Fabricator {
             .catch(rethrowAs(endpoint, "set concurrency"));
     }
     async setTrigger(endpoint) {
-        if (endpoint.platform === "run") {
-            throw new error_1.FirebaseError("Setting triggers for Cloud Run functions is not supported yet.", {
-                exit: 1,
-            });
-        }
         if (backend.isScheduleTriggered(endpoint)) {
             if (endpoint.platform === "gcfv1") {
                 await this.upsertScheduleV1(endpoint);
@@ -544,21 +612,25 @@ class Fabricator {
                 await this.upsertScheduleV2(endpoint);
                 return;
             }
+            else if (endpoint.platform === "run") {
+                throw new error_1.FirebaseError("Schedule triggers for Cloud Run functions are not supported yet.");
+            }
             (0, functional_1.assertExhaustive)(endpoint.platform);
         }
         else if (backend.isTaskQueueTriggered(endpoint)) {
+            if (endpoint.platform === "run") {
+                throw new error_1.FirebaseError("Task Queue triggers for Cloud Run functions are not supported yet.");
+            }
             await this.upsertTaskQueue(endpoint);
         }
         else if (backend.isBlockingTriggered(endpoint)) {
+            if (endpoint.platform === "run") {
+                throw new error_1.FirebaseError("Blocking triggers for Cloud Run functions are not supported yet.");
+            }
             await this.registerBlockingTrigger(endpoint);
         }
     }
     async deleteTrigger(endpoint) {
-        if (endpoint.platform === "run") {
-            throw new error_1.FirebaseError("Deleting triggers for Cloud Run functions is not supported yet.", {
-                exit: 1,
-            });
-        }
         if (backend.isScheduleTriggered(endpoint)) {
             if (endpoint.platform === "gcfv1") {
                 await this.deleteScheduleV1(endpoint);
@@ -568,12 +640,21 @@ class Fabricator {
                 await this.deleteScheduleV2(endpoint);
                 return;
             }
+            else if (endpoint.platform === "run") {
+                throw new error_1.FirebaseError("Schedule triggers for Cloud Run functions are not supported yet.");
+            }
             (0, functional_1.assertExhaustive)(endpoint.platform);
         }
         else if (backend.isTaskQueueTriggered(endpoint)) {
+            if (endpoint.platform === "run") {
+                throw new error_1.FirebaseError("Task Queue triggers for Cloud Run functions are not supported yet.");
+            }
             await this.disableTaskQueue(endpoint);
         }
         else if (backend.isBlockingTriggered(endpoint)) {
+            if (endpoint.platform === "run") {
+                throw new error_1.FirebaseError("Blocking triggers for Cloud Run functions are not supported yet.");
+            }
             await this.unregisterBlockingTrigger(endpoint);
         }
     }

package/lib/deploy/functions/release/index.js

@@ -107,7 +107,8 @@ function printTriggerUrls(results, projectNumber) {
             continue;
         }
         if (backend.isDataConnectGraphqlTriggered(httpsFunc)) {
-            logger_1.logger.info(clc.bold("Function URL"), `(${(0, functionsDeployHelper_1.getFunctionLabel)(httpsFunc)}):`, `https://${httpsFunc.id.toLowerCase()}-${projectNumber}.${httpsFunc.region}.run.app`);
+            const uri = backend.maybeDeterministicCloudRunUri(httpsFunc, projectNumber);
+            logger_1.logger.info(clc.bold("Function URL"), `(${(0, functionsDeployHelper_1.getFunctionLabel)(httpsFunc)}):`, uri);
             continue;
         }
         logger_1.logger.info(clc.bold("Function URL"), `(${(0, functionsDeployHelper_1.getFunctionLabel)(httpsFunc)}):`, httpsFunc.uri);

package/lib/deploy/functions/runtimes/dart.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryCreateDelegate = tryCreateDelegate;
+const fs = require("fs-extra");
+const path = require("path");
+const yaml = require("js-yaml");
+const discovery = require("./discovery");
+async function tryCreateDelegate(context) {
+    const yamlPath = path.join(context.sourceDir, "functions.yaml");
+    if (!(await fs.pathExists(yamlPath))) {
+        return undefined;
+    }
+    const runtime = context.runtime || "dart3";
+    return {
+        language: "dart",
+        runtime: runtime,
+        bin: "",
+        validate: async () => {
+            try {
+                const content = await fs.readFile(yamlPath, "utf8");
+                yaml.load(content);
+            }
+            catch (e) {
+                throw new Error(`Failed to parse functions.yaml: ${e.message}`);
+            }
+        },
+        build: async () => {
+            return Promise.resolve();
+        },
+        watch: async () => {
+            return Promise.resolve(async () => {
+            });
+        },
+        discoverBuild: async () => {
+            const build = await discovery.detectFromYaml(context.sourceDir, context.projectId, runtime);
+            if (!build) {
+                throw new Error("Could not find functions.yaml");
+            }
+            return build;
+        },
+    };
+}

package/lib/deploy/functions/runtimes/discovery/v1alpha1.js

@@ -82,6 +82,9 @@ function assertBuildEndpoint(ep, id) {
         taskQueueTrigger: "object",
         blockingTrigger: "object",
         cpu: (cpu) => cpu === null || isCEL(cpu) || cpu === "gcf_gen1" || typeof cpu === "number",
+        baseImageUri: "string?",
+        command: "array?",
+        args: "array?",
     });
     if (ep.vpc) {
         (0, parsing_1.assertKeyTypes)(prefix + ".vpc", ep.vpc, {
@@ -294,7 +297,7 @@ function parseEndpointForBuild(id, ep, project, defaultRegion, runtime) {
     if ("serviceAccountEmail" in ep) {
         parsed.serviceAccount = ep.serviceAccountEmail;
     }
-    (0, proto_1.copyIfPresent)(parsed, ep, "omit", "availableMemoryMb", "cpu", "maxInstances", "minInstances", "concurrency", "timeoutSeconds", "vpc", "labels", "ingressSettings", "environmentVariables", "serviceAccount");
+    (0, proto_1.copyIfPresent)(parsed, ep, "omit", "availableMemoryMb", "cpu", "maxInstances", "minInstances", "concurrency", "timeoutSeconds", "vpc", "labels", "ingressSettings", "environmentVariables", "serviceAccount", "baseImageUri", "command", "args");
     (0, proto_1.convertIfPresent)(parsed, ep, "secretEnvironmentVariables", (senvs) => {
         if (!senvs) {
             return null;