firebase-tools 15.22.3 → 15.23.0

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineDeploymentEvent = determineDeploymentEvent;
+exports.executeLifecycleHooks = executeLifecycleHooks;
+exports.executeHook = executeHook;
+const backend = require("../backend");
+const error_1 = require("../../../error");
+const logger_1 = require("../../../logger");
+const utils_1 = require("../../../utils");
+const cloudtasks = require("../../../gcp/cloudtasks");
+const computeEngine = require("../../../gcp/computeEngine");
+const projects_1 = require("../../../management/projects");
+const functional_1 = require("../../../functional");
+function determineDeploymentEvent(haveBackend) {
+    const hasExistingEndpoints = backend.someEndpoint(haveBackend, () => true);
+    if (!hasExistingEndpoints) {
+        return "afterFirstDeploy";
+    }
+    return "afterRedeploy";
+}
+async function executeLifecycleHooks(wantBackend, haveBackend, plan, codebase) {
+    const event = determineDeploymentEvent(haveBackend);
+    const hooks = wantBackend.lifecycleHooks || {};
+    const hook = hooks[event];
+    if (!hook) {
+        logger_1.logger.debug(`No lifecycle hook configured for event: ${event}`);
+        return false;
+    }
+    if (event === "afterRedeploy" && plan) {
+        const codebasePlans = codebase ? [plan[codebase]].filter(Boolean) : Object.values(plan);
+        const hasResourceModifications = codebasePlans.some((codebasePlan) => Object.values(codebasePlan.regionalChangesets).some((changeset) => changeset.endpointsToCreate.length > 0 ||
+            changeset.endpointsToUpdate.length > 0 ||
+            changeset.endpointsToDelete.length > 0));
+        if (!hasResourceModifications) {
+            (0, utils_1.logLabeledBullet)("functions", `No resources modified for codebase: ${codebase ?? "default"}. Skipping afterRedeploy lifecycle hook.`);
+            return false;
+        }
+    }
+    try {
+        await executeHook(event, hook, wantBackend);
+        return true;
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        (0, utils_1.logLabeledWarning)("functions", `Failed to execute ${event} lifecycle hook: ${errorMsg}`);
+        (0, utils_1.logLabeledBullet)("functions", `You can retry the lifecycle hook in isolation by running: firebase functions:lifecycle:run ${event} ${codebase ?? "default"}`);
+        return false;
+    }
+}
+async function executeTaskQueueHook(taskHook, wantBackend) {
+    const targetEndpoint = backend.findEndpoint(wantBackend, (ep) => ep.id === taskHook.function);
+    if (!targetEndpoint) {
+        throw new error_1.FirebaseError(`Target endpoint "${taskHook.function}" not found in backend for lifecycle hook.`);
+    }
+    if (!backend.isTaskQueueTriggered(targetEndpoint)) {
+        throw new error_1.FirebaseError(`Target endpoint "${taskHook.function}" is not a task queue function.`);
+    }
+    const queueName = cloudtasks.queueNameForEndpoint(targetEndpoint);
+    const bodyStr = taskHook.body ? JSON.stringify(taskHook.body) : "";
+    const body = bodyStr ? Buffer.from(bodyStr).toString("base64") : undefined;
+    const url = targetEndpoint.uri;
+    if (!url) {
+        throw new error_1.FirebaseError(`Target endpoint "${taskHook.function}" does not have a trigger URI.`);
+    }
+    const projectMetadata = await (0, projects_1.getProject)(targetEndpoint.project);
+    const projectNumber = projectMetadata.projectNumber;
+    const sa = targetEndpoint.serviceAccount || (await computeEngine.getDefaultServiceAccount(projectNumber));
+    const task = {
+        httpRequest: {
+            url,
+            httpMethod: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            oidcToken: {
+                serviceAccountEmail: sa,
+                audience: url,
+            },
+        },
+    };
+    if (body) {
+        task.httpRequest.body = body;
+    }
+    await cloudtasks.enqueueTask(queueName, task);
+    (0, utils_1.logLabeledSuccess)("functions", `Successfully queued task for lifecycle hook ${taskHook.function} in queue ${queueName}.`);
+    return targetEndpoint;
+}
+function getCloudConsoleLogUrl(endpoint) {
+    const { project, region, id } = endpoint;
+    const serviceName = endpoint.runServiceId || id;
+    const query = `resource.type="cloud_run_revision"\nresource.labels.service_name="${serviceName}"\nresource.labels.location="${region}"`;
+    return `https://console.cloud.google.com/logs/query;query=${encodeURIComponent(query)};project=${project}`;
+}
+async function executeHook(event, hook, backendSpec) {
+    let executedEndpoint;
+    if ("task" in hook) {
+        (0, utils_1.logLabeledBullet)("functions", `Executing ${event} lifecycle hook targeting: ${hook.task.function}...`);
+        executedEndpoint = await executeTaskQueueHook(hook.task, backendSpec);
+    }
+    else if ("call" in hook) {
+        throw new error_1.FirebaseError(`Lifecycle hook action type "call" is not supported.`);
+    }
+    else if ("http" in hook) {
+        throw new error_1.FirebaseError(`Lifecycle hook action type "http" is not supported.`);
+    }
+    else {
+        (0, functional_1.assertExhaustive)(hook);
+    }
+    if (executedEndpoint) {
+        (0, utils_1.logLabeledBullet)("functions", `View logs for ${event} at: ${getCloudConsoleLogUrl(executedEndpoint)}`);
+    }
+    return executedEndpoint;
+}

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

@@ -75,9 +75,25 @@ function calculateUpdate(want, have) {
     }
     return update;
 }
-function createDeploymentPlan(args) {
-    let { wantBackend, haveBackend, codebase, filters, deleteAll } = args;
-    let deployment = {};
+async function createDeploymentPlan(args) {
+    let { wantBackend, haveBackend, codebase, filters, deleteAll, haveRoles, existingManagedSA, managedSA, } = args;
+    const requiredRoles = wantBackend.requiredRoles;
+    const roles = haveRoles || [];
+    let rolesToAdd;
+    let rolesToRemove;
+    let serviceAccountToCreate;
+    let serviceAccountToDelete;
+    const isFiltered = !!(filters && filters.length > 0 && !deleteAll);
+    if (requiredRoles) {
+        rolesToAdd = requiredRoles.filter((r) => !roles.includes(r));
+        rolesToRemove = roles.filter((r) => !requiredRoles.includes(r));
+        if (!existingManagedSA && managedSA) {
+            serviceAccountToCreate = managedSA;
+        }
+    }
+    else if (existingManagedSA && !isFiltered) {
+        serviceAccountToDelete = existingManagedSA;
+    }
     wantBackend = backend.matchingBackend(wantBackend, (endpoint) => {
         return (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
     });
@@ -85,13 +101,14 @@ function createDeploymentPlan(args) {
     haveBackend = backend.matchingBackend(haveBackend, (endpoint) => {
         return wantedEndpoint(endpoint) || (0, functionsDeployHelper_1.endpointMatchesAnyFilter)(endpoint, filters);
     });
+    const regionalChangesets = {};
     const regions = new Set([
         ...Object.keys(wantBackend.endpoints),
         ...Object.keys(haveBackend.endpoints),
     ]);
     for (const region of regions) {
         const changesets = calculateChangesets(wantBackend.endpoints[region] || {}, haveBackend.endpoints[region] || {}, (e) => `${codebase}-${e.region}-${e.availableMemoryMb || "default"}`, deleteAll);
-        deployment = { ...deployment, ...changesets };
+        Object.assign(regionalChangesets, changesets);
     }
     if (upgradedToGCFv2WithoutSettingConcurrency(wantBackend, haveBackend)) {
         utils.logLabeledBullet("functions", "You are updating one or more functions to Google Cloud Functions v2, " +
@@ -99,7 +116,26 @@ function createDeploymentPlan(args) {
             "default to 80 concurrent executions, but existing functions keep the " +
             "old default of 1. You can change this with the 'concurrency' option.");
     }
-    return deployment;
+    if (requiredRoles) {
+        if (!managedSA) {
+            throw new error_1.FirebaseError("managedServiceAccount is required when requiredRoles is defined.", {
+                exit: 1,
+            });
+        }
+        return {
+            regionalChangesets,
+            rolesToAdd,
+            rolesToRemove,
+            serviceAccountToCreate,
+            managedServiceAccount: managedSA,
+        };
+    }
+    else {
+        return {
+            regionalChangesets,
+            serviceAccountToDelete,
+        };
+    }
 }
 function upgradedToGCFv2WithoutSettingConcurrency(want, have) {
     return backend.someEndpoint(want, (endpoint) => {

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

@@ -5,7 +5,6 @@ exports.yamlToBuild = yamlToBuild;
 exports.detectFromYaml = detectFromYaml;
 exports.detectFromPort = detectFromPort;
 exports.detectFromOutputPath = detectFromOutputPath;
-const node_fetch_1 = require("node-fetch");
 const fs = require("fs");
 const path = require("path");
 const yaml = require("yaml");
@@ -65,12 +64,14 @@ async function detectFromPort(port, project, runtime, initialDelay = 0, timeout
     const url = `http://127.0.0.1:${port}/__/functions.yaml`;
     while (true) {
         try {
-            res = await Promise.race([(0, node_fetch_1.default)(url), timedOut]);
+            res = await Promise.race([fetch(url), timedOut]);
             break;
         }
         catch (err) {
+            const realErr = err?.cause || err;
             if (err?.name === "FetchError" ||
-                ["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT"].includes(err?.code)) {
+                realErr?.name === "FetchError" ||
+                ["ECONNREFUSED", "ECONNRESET", "ETIMEDOUT"].includes(realErr?.code)) {
                 continue;
             }
             throw err;

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

@@ -20,12 +20,17 @@ function buildFromV1Alpha1(yaml, project, region, runtime) {
         specVersion: "string",
         params: "array",
         requiredAPIs: "array",
+        requiredRoles: "array",
         endpoints: "object",
         extensions: "object",
+        lifecycleHooks: "object",
     });
     const bd = build.empty();
     bd.params = manifest.params || [];
     bd.requiredAPIs = parseRequiredAPIs(manifest);
+    if (manifest.requiredRoles) {
+        bd.requiredRoles = parseRequiredRoles(manifest);
+    }
     for (const id of Object.keys(manifest.endpoints)) {
         const me = manifest.endpoints[id];
         assertBuildEndpoint(me, id);
@@ -41,8 +46,53 @@ function buildFromV1Alpha1(yaml, project, region, runtime) {
             bd.extensions[id] = be;
         }
     }
+    if (manifest.lifecycleHooks) {
+        bd.lifecycleHooks = {};
+        for (const id of Object.keys(manifest.lifecycleHooks)) {
+            if (id !== "afterFirstDeploy" && id !== "afterRedeploy") {
+                throw new error_1.FirebaseError(`Invalid eventType "${id}" for lifecycle hook.`);
+            }
+            const hook = manifest.lifecycleHooks[id];
+            if (!hook || typeof hook !== "object") {
+                throw new error_1.FirebaseError(`Invalid lifecycle hook configuration for "${id}".`);
+            }
+            if (hook.task) {
+                if (typeof hook.task.function !== "string" || !hook.task.function) {
+                    throw new error_1.FirebaseError(`Invalid target "${hook.task.function || ""}" for lifecycle hook "${id}"`);
+                }
+            }
+            else if (hook.call) {
+                if (typeof hook.call.function !== "string" || !hook.call.function) {
+                    throw new error_1.FirebaseError(`Invalid target "${hook.call.function || ""}" for lifecycle hook "${id}"`);
+                }
+            }
+            else if (hook.http) {
+                const target = hook.http.url || hook.http.function;
+                if (typeof target !== "string" || !target) {
+                    throw new error_1.FirebaseError(`Invalid target "${target || ""}" for lifecycle hook "${id}"`);
+                }
+            }
+            else {
+                throw new error_1.FirebaseError(`No action (task, call, or http) specified for lifecycle hook "${id}"`);
+            }
+            bd.lifecycleHooks[id] = hook;
+        }
+    }
     return bd;
 }
+const ROLE_REGEX = /^(roles\/[a-zA-Z0-9_\.\-]+|projects\/[a-zA-Z0-9\-]+\/roles\/[a-zA-Z0-9_\.\-]+|organizations\/[0-9]+\/roles\/[a-zA-Z0-9_\.\-]+)$/;
+function parseRequiredRoles(manifest) {
+    const roles = manifest.requiredRoles || [];
+    for (const role of roles) {
+        if (typeof role !== "string") {
+            throw new error_1.FirebaseError(`Invalid role "${JSON.stringify(role)}". Expected string`);
+        }
+        if (!ROLE_REGEX.test(role)) {
+            throw new error_1.FirebaseError(`Invalid IAM role format "${role}".`);
+        }
+    }
+    return Array.from(new Set(roles));
+}
 function parseRequiredAPIs(manifest) {
     const requiredAPIs = manifest.requiredAPIs || [];
     for (const { api, reason } of requiredAPIs) {

package/lib/deploy/functions/runtimes/node/index.js

@@ -8,7 +8,6 @@ const path = require("path");
 const portfinder = require("portfinder");
 const semver = require("semver");
 const spawn = require("cross-spawn");
-const node_fetch_1 = require("node-fetch");
 const error_1 = require("../../../../error");
 const parseRuntimeAndValidateSDK_1 = require("./parseRuntimeAndValidateSDK");
 const logger_1 = require("../../../../logger");
@@ -156,7 +155,7 @@ class Delegate {
                 childProcess.once("error", reject);
             });
             try {
-                await (0, node_fetch_1.default)(`http://localhost:${port}/__/quitquitquit`);
+                await fetch(`http://localhost:${port}/__/quitquitquit`);
             }
             catch (e) {
                 logger_1.logger.debug("Failed to call quitquitquit. This often means the server failed to start", e);

package/lib/deploy/functions/runtimes/python/index.js

@@ -5,7 +5,6 @@ exports.tryCreateDelegate = tryCreateDelegate;
 exports.getPythonBinary = getPythonBinary;
 const fs = require("fs");
 const path = require("path");
-const node_fetch_1 = require("node-fetch");
 const util_1 = require("util");
 const portfinder = require("portfinder");
 const discovery = require("../discovery");
@@ -130,7 +129,7 @@ class Delegate {
         });
         return Promise.resolve(async () => {
             try {
-                await (0, node_fetch_1.default)(`http://127.0.0.1:${port}/__/quitquitquit`);
+                await fetch(`http://127.0.0.1:${port}/__/quitquitquit`);
             }
             catch (e) {
                 logger_1.logger.debug("Failed to call quitquitquit. This often means the server failed to start", e);

package/lib/deploy/functions/validate.js

@@ -9,6 +9,7 @@ exports.functionsDirectoryExists = functionsDirectoryExists;
 exports.functionIdsAreValid = functionIdsAreValid;
 exports.secretsAreValid = secretsAreValid;
 exports.checkFiltersIntegrity = checkFiltersIntegrity;
+exports.validateLifecycleHooks = validateLifecycleHooks;
 const path = require("path");
 const clc = require("colorette");
 const error_1 = require("../../error");
@@ -20,6 +21,7 @@ const fsutils = require("../../fsutils");
 const backend = require("./backend");
 const utils = require("../../utils");
 const secrets = require("../../functions/secrets");
+const functional_1 = require("../../functional");
 const MAX_V1_TIMEOUT_SECONDS = 540;
 const MAX_V2_EVENTS_TIMEOUT_SECONDS = 540;
 const MAX_V2_SCHEDULE_TIMEOUT_SECONDS = 1800;
@@ -49,7 +51,8 @@ function validateScheduledTimeout(ep) {
             `The attempt deadline will be capped at ${exports.MAX_V2_SCHEDULE_ATTEMPT_DEADLINE_SECONDS} seconds.`);
     }
 }
-function endpointsAreValid(wantBackend) {
+function endpointsAreValid(wantBackend, existingBackend) {
+    validateLifecycleHooks(wantBackend, existingBackend);
     const endpoints = backend.allEndpoints(wantBackend);
     functionIdsAreValid(endpoints);
     validateTimeoutConfig(endpoints);
@@ -288,3 +291,43 @@ function checkFiltersIntegrity(wantBackends, filters) {
         }
     }
 }
+function validateLifecycleHooks(wantBackend, existingBackend) {
+    if (!wantBackend.lifecycleHooks) {
+        return;
+    }
+    const endpoints = [
+        ...backend.allEndpoints(wantBackend),
+        ...(existingBackend ? backend.allEndpoints(existingBackend) : []),
+    ];
+    for (const [eventType, hook] of Object.entries(wantBackend.lifecycleHooks)) {
+        const keys = Object.keys(hook).filter((k) => ["task", "call", "http"].includes(k));
+        if (keys.length !== 1) {
+            throw new error_1.FirebaseError(`Lifecycle hook "${eventType}" must specify exactly one action (task, call, or http).`);
+        }
+        if ("task" in hook) {
+            const targetEndpoint = findAndValidateTargetEndpoint(endpoints, hook.task.function, eventType);
+            if (!backend.isTaskQueueTriggered(targetEndpoint)) {
+                throw new error_1.FirebaseError(`Lifecycle hook "${eventType}" expects a task queue function.`);
+            }
+        }
+        else if ("call" in hook) {
+            throw new error_1.FirebaseError(`Lifecycle hook action type "call" is not supported in the CLI yet.`);
+        }
+        else if ("http" in hook) {
+            throw new error_1.FirebaseError(`Lifecycle hook action type "http" is not supported in the CLI yet.`);
+        }
+        else {
+            (0, functional_1.assertExhaustive)(hook);
+        }
+    }
+}
+function findAndValidateTargetEndpoint(endpoints, functionName, eventType) {
+    const targetEndpoint = endpoints.find((e) => e.id === functionName);
+    if (!targetEndpoint) {
+        throw new error_1.FirebaseError(`Target endpoint "${functionName}" not found in backend for lifecycle hook "${eventType}".`);
+    }
+    if (targetEndpoint.platform === "gcfv1") {
+        throw new error_1.FirebaseError(`Target endpoint "${functionName}" is a GCF Gen 1 function. Lifecycle hooks are only supported for GCF Gen 2 functions.`);
+    }
+    return targetEndpoint;
+}

package/lib/deploy/hosting/uploader.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Uploader = void 0;
 const lodash_1 = require("lodash");
-const abort_controller_1 = require("abort-controller");
 const clc = require("colorette");
 const crypto = require("crypto");
 const fs = require("fs");
@@ -172,7 +171,7 @@ class Uploader {
         if (!this.uploadClient) {
             throw new error_1.FirebaseError("No upload client available.", { exit: 2 });
         }
-        const controller = new abort_controller_1.default();
+        const controller = new AbortController();
         const timeout = setTimeout(() => {
             controller.abort();
         }, this.uploadTimeout(this.hashMap[toUpload]));
@@ -190,7 +189,7 @@ class Uploader {
         }
         if (res.status !== 200) {
             const errorMessage = await res.response.text();
-            logger_1.logger.debug(`[hosting][upload] ${this.hashMap[toUpload]} (${toUpload}) HTTP ERROR ${res.status}: headers=${JSON.stringify(res.response.headers.raw())} ${errorMessage}`);
+            logger_1.logger.debug(`[hosting][upload] ${this.hashMap[toUpload]} (${toUpload}) HTTP ERROR ${res.status}: headers=${JSON.stringify(Object.fromEntries(res.response.headers.entries()))} ${errorMessage}`);
             throw new Error(`Unexpected error while uploading file: ${errorMessage}`);
         }
     }

package/lib/downloadUtils.js

@@ -10,6 +10,7 @@ const ProgressBar = require("progress");
 const tmp = require("tmp");
 const apiv2_1 = require("./apiv2");
 const error_1 = require("./error");
+const streamUtils_1 = require("./streamUtils");
 async function downloadToTmp(remoteUrl, auth = false) {
     const u = new url_1.URL(remoteUrl);
     const c = new apiv2_1.Client({ urlPrefix: u.origin, auth });
@@ -24,7 +25,8 @@ async function downloadToTmp(remoteUrl, auth = false) {
         resolveOnHTTPError: true,
     });
     if (res.status !== 200) {
-        throw new error_1.FirebaseError(`download failed, status ${res.status}: ${await res.response.text()}`, {
+        const errorText = await (0, streamUtils_1.streamToString)(res.body);
+        throw new error_1.FirebaseError(`download failed, status ${res.status}: ${errorText}`, {
             status: res.status,
         });
     }

package/lib/emulator/auth/operations.js

@@ -6,8 +6,6 @@ exports.setAccountInfoImpl = setAccountInfoImpl;
 exports.parseBlockingFunctionJwt = parseBlockingFunctionJwt;
 const url_1 = require("url");
 const jsonwebtoken_1 = require("jsonwebtoken");
-const node_fetch_1 = require("node-fetch");
-const abort_controller_1 = require("abort-controller");
 const utils_1 = require("./utils");
 const errors_1 = require("./errors");
 const types_1 = require("../types");
@@ -2183,7 +2181,7 @@ async function fetchBlockingFunction(state, event, user, options = {}, oauthToke
             jwt,
         },
     };
-    const controller = new abort_controller_1.default();
+    const controller = new AbortController();
     const timeout = setTimeout(() => {
         controller.abort();
     }, timeoutMs);
@@ -2193,11 +2191,23 @@ async function fetchBlockingFunction(state, event, user, options = {}, oauthToke
     let text;
     try {
         const signal = controller.signal;
-        signal.reason = "";
-        signal.throwIfAborted = () => {
-            throw new error_1.FirebaseError("Aborted");
-        };
-        const res = await (0, node_fetch_1.default)(url, {
+        try {
+            if (!("reason" in signal)) {
+                signal.reason = "";
+            }
+        }
+        catch (e) {
+        }
+        try {
+            if (!("throwIfAborted" in signal)) {
+                signal.throwIfAborted = () => {
+                    throw new error_1.FirebaseError("Aborted");
+                };
+            }
+        }
+        catch (e) {
+        }
+        const res = await fetch(url, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify(reqBody),

package/lib/emulator/downloadableEmulatorInfo.json

@@ -44,46 +44,46 @@
         }
     },
     "pubsub": {
-        "version": "0.8.33",
-        "expectedSize": 52948835,
-        "expectedChecksum": "7dc33e0c8bb37948228e49a18375d53b",
-        "expectedChecksumSHA256": "93768f8763d85c37f7f6e0f64d10195abaa088f4ff559b7d9fb8a2fc5520848d",
-        "remoteUrl": "https://storage.googleapis.com/firebase-preview-drop/emulator/pubsub-emulator-0.8.33.zip",
-        "downloadPathRelativeToCacheDir": "pubsub-emulator-0.8.33.zip",
-        "binaryPathRelativeToCacheDir": "pubsub-emulator-0.8.33/pubsub-emulator/bin/cloud-pubsub-emulator"
+        "version": "0.8.34",
+        "expectedSize": 53008019,
+        "expectedChecksum": "3eb75c292dfa72d48a36428a49bac314",
+        "expectedChecksumSHA256": "062a71d30cbc0cc29de6e55f22ae9fc7eacb02c60272a2c4692826fdb83f0c25",
+        "remoteUrl": "https://storage.googleapis.com/firebase-preview-drop/emulator/pubsub-emulator-0.8.34.zip",
+        "downloadPathRelativeToCacheDir": "pubsub-emulator-0.8.34.zip",
+        "binaryPathRelativeToCacheDir": "pubsub-emulator-0.8.34/pubsub-emulator/bin/cloud-pubsub-emulator"
     },
     "dataconnect": {
         "darwin": {
-            "version": "3.4.14",
-            "expectedSize": 32468976,
-            "expectedChecksum": "d62fc079187a1adc2ceef7dc0e1a1e44",
-            "expectedChecksumSHA256": "4bbf0ae04ca83dcc765804549d30f94d02c7a8b6baeef5f3c52104e771627e43",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-amd64-v3.4.14",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.14"
+            "version": "3.4.15",
+            "expectedSize": 32502016,
+            "expectedChecksum": "00f4b06ef1a6a70fbba7b2b8c1cd8eac",
+            "expectedChecksumSHA256": "8ea50a699023e5464b3306689e464716b8df7c51cadfe4a3db5d346981e1a916",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-amd64-v3.4.15",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.15"
         },
         "darwin_arm64": {
-            "version": "3.4.14",
-            "expectedSize": 30604754,
-            "expectedChecksum": "306e88ebe314eec82ae44842aa87d20e",
-            "expectedChecksumSHA256": "3eeaf0dbfd48d3d7cf761e256e8850bc6159dccc128dd59f87bbeeaaaa6a62c6",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-arm64-v3.4.14",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.14"
+            "version": "3.4.15",
+            "expectedSize": 30638050,
+            "expectedChecksum": "5b824b0d725e87f4f1820f8c3d50f2ce",
+            "expectedChecksumSHA256": "563ea6788e2291b82ea1cd0744f2594f0661b79277bc13e4da190b939a99293d",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-macos-arm64-v3.4.15",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.15"
         },
         "win32": {
-            "version": "3.4.14",
-            "expectedSize": 32509952,
-            "expectedChecksum": "c5cbd9482be394bf466d4328b975d88e",
-            "expectedChecksumSHA256": "b9f14587c5d5f87bccd093e1dddc9f5bb2a77be007201028d9ee8339e79219f0",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-windows-amd64-v3.4.14",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.14.exe"
+            "version": "3.4.15",
+            "expectedSize": 32543232,
+            "expectedChecksum": "dbdbdca5482d386a142cd602177e811d",
+            "expectedChecksumSHA256": "01b1408750b2f1612d3a99e89702a600803f9d8f77669e5ad2502651ed560796",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-windows-amd64-v3.4.15",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.15.exe"
         },
         "linux": {
-            "version": "3.4.14",
-            "expectedSize": 31625400,
-            "expectedChecksum": "506a09ca12b61df98f705728047219dd",
-            "expectedChecksumSHA256": "257d7aa4f4dd1e4de9c9d3db9f7b7834323f0d53e658e6814a933b1ec73ca27d",
-            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-linux-amd64-v3.4.14",
-            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.14"
+            "version": "3.4.15",
+            "expectedSize": 31654072,
+            "expectedChecksum": "b49d21a4704ddf9420fa58d0c233821d",
+            "expectedChecksumSHA256": "b152edccdf50f3e8e3d6904d6cd1437eb88cb7a447ede3e3dd5092d12262bdc1",
+            "remoteUrl": "https://storage.googleapis.com/firemat-preview-drop/emulator/dataconnect-emulator-linux-amd64-v3.4.15",
+            "downloadPathRelativeToCacheDir": "dataconnect-emulator-3.4.15"
         }
     }
 }

package/lib/emulator/storage/apis/gcloud.js

@@ -320,6 +320,67 @@ function createCloudEndpoints(emulator) {
         }
         return (0, shared_1.sendFileBytes)(getObjectResponse.metadata, getObjectResponse.data, req, res);
     });
+    gcloudStorageAPI.post("/:bucketId", (req, res, next) => {
+        adminStorageLayer.createBucket(req.params.bucketId);
+        next();
+    }, async (req, res) => {
+        const contentTypeHeader = req.header("content-type");
+        if (!contentTypeHeader?.includes("multipart/form-data")) {
+            return res.status(400).send("Content-Type must be multipart/form-data");
+        }
+        try {
+            const bodyBuffer = await (0, request_1.reqBodyToBuffer)(req);
+            const formData = (0, multipart_1.parseFormDataMultipartRequest)(contentTypeHeader, bodyBuffer);
+            const keyPart = formData.find((p) => p.name === "key");
+            const filePart = formData.find((p) => p.type === "file");
+            if (keyPart?.type !== "field" || filePart?.type !== "file") {
+                return res.status(400).send("Missing 'key' or file.");
+            }
+            const metadata = {
+                contentType: filePart.contentType,
+                metadata: {},
+            };
+            const HEADER_MAP = {
+                "content-type": "contentType",
+                "cache-control": "cacheControl",
+                "content-disposition": "contentDisposition",
+                "content-encoding": "contentEncoding",
+                "content-language": "contentLanguage",
+            };
+            for (const part of formData) {
+                if (part.type === "file" || part.name === "key")
+                    continue;
+                const key = part.name.toLowerCase();
+                if (key.startsWith("x-goog-meta-")) {
+                    metadata.metadata[key.substring(12)] = part.value;
+                }
+                else if (HEADER_MAP[key]) {
+                    metadata[HEADER_MAP[key]] = part.value.trim();
+                }
+            }
+            const upload = uploadService.multipartUpload({
+                bucketId: req.params.bucketId,
+                objectId: keyPart.value,
+                dataRaw: filePart.data,
+                metadata: metadata,
+                authorization: req.header("authorization"),
+            });
+            await adminStorageLayer.uploadObject(upload);
+            return res.sendStatus(204);
+        }
+        catch (err) {
+            if (err instanceof errors_1.ForbiddenError) {
+                return res.sendStatus(403);
+            }
+            if (err instanceof errors_1.NotFoundError) {
+                return res.sendStatus(404);
+            }
+            if (err instanceof Error) {
+                return res.status(400).send(err.message);
+            }
+            throw err;
+        }
+    });
     gcloudStorageAPI.post("/b/:bucketId/o/:objectId/:method(rewriteTo|copyTo)/b/:destBucketId/o/:destObjectId", (req, res, next) => {
         if (req.params.method === "rewriteTo" && req.query.rewriteToken) {
             return next();