Refactor initializing endpoint to fix bug.

Author: taeold

src/common/providers/tasks.ts

@@ -26,8 +26,7 @@ import { DecodedIdToken } from "firebase-admin/auth";
 import * as logger from "../../logger";
 import * as https from "./https";
 import { Expression } from "../../params";
-import { ResettableKeys, ResetValue } from "../options";
-import { ManifestEndpoint } from "../../runtime/manifest";
+import { ResetValue } from "../options";
 
 /** How a task should be retried in the event of a non-2xx return. */
 export interface RetryConfig {
@@ -109,25 +108,6 @@ export interface Request<T = any> {
 type v1TaskHandler = (data: any, context: TaskContext) => void | Promise<void>;
 type v2TaskHandler<Req> = (request: Request<Req>) => void | Promise<void>;
 
-/** @internal */
-export const RESETTABLE_RETRY_CONFIG_OPTIONS: ResettableKeys<
-  ManifestEndpoint["taskQueueTrigger"]["retryConfig"]
-> = {
-  maxAttempts: null,
-  maxDoublings: null,
-  maxBackoffSeconds: null,
-  maxRetrySeconds: null,
-  minBackoffSeconds: null,
-};
-
-/** @internal */
-export const RESETTABLE_RATE_LIMITS_OPTIONS: ResettableKeys<
-  ManifestEndpoint["taskQueueTrigger"]["rateLimits"]
-> = {
-  maxConcurrentDispatches: null,
-  maxDispatchesPerSecond: null,
-};
-
 /** @internal */
 export function onDispatchHandler<Req = any>(
   handler: v1TaskHandler | v2TaskHandler<Req>

src/runtime/manifest.ts

@@ -20,7 +20,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-import { ResetValue } from "../common/options";
+import { RESET_VALUE, RESETTABLE_OPTIONS, ResettableKeys, ResetValue } from "../common/options";
 import { Expression } from "../params";
 import { WireParamSpec } from "../params/types";
 
@@ -64,14 +64,14 @@ export interface ManifestEndpoint {
   };
 
   taskQueueTrigger?: {
-    retryConfig: {
+    retryConfig?: {
       maxAttempts?: number | Expression<number> | ResetValue;
       maxRetrySeconds?: number | Expression<number> | ResetValue;
       maxBackoffSeconds?: number | Expression<number> | ResetValue;
       maxDoublings?: number | Expression<number> | ResetValue;
       minBackoffSeconds?: number | Expression<number> | ResetValue;
     };
-    rateLimits: {
+    rateLimits?: {
       maxConcurrentDispatches?: number | Expression<number> | ResetValue;
       maxDispatchesPerSecond?: number | Expression<number> | ResetValue;
     };
@@ -137,3 +137,117 @@ export function stackToWire(stack: ManifestStack): Record<string, unknown> {
   traverse(wireStack.endpoints);
   return wireStack;
 }
+
+/**
+ * @internal
+ */
+export function initEndpoint(...opts: { preserveExternalChanges?: boolean }[]): ManifestEndpoint {
+  const endpoint: ManifestEndpoint = {};
+  if (opts.every((opt) => !opt.preserveExternalChanges)) {
+    for (const key of Object.keys(RESETTABLE_OPTIONS)) {
+      endpoint[key] = RESET_VALUE;
+    }
+    // VPC settings is not flat and handled separately.
+    endpoint.vpc = {
+      connector: RESET_VALUE,
+      egressSettings: RESET_VALUE,
+    };
+  }
+  return endpoint;
+}
+
+const RESETTABLE_RETRY_CONFIG_OPTIONS: ResettableKeys<
+  ManifestEndpoint["taskQueueTrigger"]["retryConfig"]
+> = {
+  maxAttempts: null,
+  maxDoublings: null,
+  maxBackoffSeconds: null,
+  maxRetrySeconds: null,
+  minBackoffSeconds: null,
+};
+
+const RESETTABLE_RATE_LIMITS_OPTIONS: ResettableKeys<
+  ManifestEndpoint["taskQueueTrigger"]["rateLimits"]
+> = {
+  maxConcurrentDispatches: null,
+  maxDispatchesPerSecond: null,
+};
+
+/**
+ * @internal
+ */
+export function initTaskQueueTrigger(
+  ...opts: { preserveExternalChanges?: boolean }[]
+): ManifestEndpoint["taskQueueTrigger"] {
+  let taskQueueTrigger = {};
+  if (opts.every((opt) => !opt.preserveExternalChanges)) {
+    const retryConfig = {};
+    for (const key of Object.keys(RESETTABLE_RETRY_CONFIG_OPTIONS)) {
+      retryConfig[key] = RESET_VALUE;
+    }
+    const rateLimits = {};
+    for (const key of Object.keys(RESETTABLE_RATE_LIMITS_OPTIONS)) {
+      rateLimits[key] = RESET_VALUE;
+    }
+    taskQueueTrigger = { retryConfig, rateLimits };
+  }
+  return taskQueueTrigger;
+}
+
+export const RESETTABLE_V1_SCHEDULE_OPTIONS: Omit<
+  ResettableKeys<ManifestEndpoint["scheduleTrigger"]["retryConfig"]>,
+  "maxBackoffSeconds" | "minBackoffSeconds" | "maxRetrySeconds"
+> = {
+  retryCount: null,
+  maxDoublings: null,
+  maxRetryDuration: null,
+  maxBackoffDuration: null,
+  minBackoffDuration: null,
+};
+
+const RESETTABLE_V2_SCHEDULE_OPTIONS: Omit<
+  ResettableKeys<ManifestEndpoint["scheduleTrigger"]["retryConfig"]>,
+  "maxRetryDuration" | "maxBackoffDuration" | "minBackoffDuration"
+> = {
+  retryCount: null,
+  maxDoublings: null,
+  maxRetrySeconds: null,
+  minBackoffSeconds: null,
+  maxBackoffSeconds: null,
+};
+
+function initScheduleTrigger(
+  resetOptions: Record<string, unknown>,
+  schedule: string | Expression<string>,
+  ...opts: { preserveExternalChanges?: boolean }[]
+): ManifestEndpoint["scheduleTrigger"] {
+  let scheduleTrigger: ManifestEndpoint["scheduleTrigger"] = { schedule };
+  if (opts.every((opt) => !opt.preserveExternalChanges)) {
+    const retryConfig = {};
+    for (const key of Object.keys(resetOptions)) {
+      retryConfig[key] = RESET_VALUE;
+    }
+    scheduleTrigger = { ...scheduleTrigger, timeZone: RESET_VALUE, retryConfig };
+  }
+  return scheduleTrigger;
+}
+
+/**
+ * @internal
+ */
+export function initV1ScheduleTrigger(
+  schedule: string | Expression<string>,
+  ...opts: { preserveExternalChanges?: boolean }[]
+): ManifestEndpoint["scheduleTrigger"] {
+  return initScheduleTrigger(RESETTABLE_V1_SCHEDULE_OPTIONS, schedule, ...opts);
+}
+
+/**
+ * @internal
+ */
+export function initV2ScheduleTrigger(
+  schedule: string | Expression<string>,
+  ...opts: { preserveExternalChanges?: boolean }[]
+): ManifestEndpoint["scheduleTrigger"] {
+  return initScheduleTrigger(RESETTABLE_V2_SCHEDULE_OPTIONS, schedule, ...opts);
+}

src/v1/cloud-functions.ts

@@ -25,26 +25,19 @@ import { warn } from "../logger";
 import { DeploymentOptions, RESET_VALUE } from "./function-configuration";
 export { Request, Response };
 import { convertIfPresent, copyIfPresent } from "../common/encoding";
-import { ManifestEndpoint, ManifestRequiredAPI } from "../runtime/manifest";
-import { RESETTABLE_OPTIONS, ResettableKeys, ResetValue } from "../common/options";
+import {
+  initEndpoint,
+  initV1ScheduleTrigger,
+  ManifestEndpoint,
+  ManifestRequiredAPI,
+} from "../runtime/manifest";
+import { ResetValue } from "../common/options";
 
 export { Change } from "../common/change";
 
 /** @internal */
 const WILDCARD_REGEX = new RegExp("{[^/{}]*}", "g");
 
-/** @internal */
-export const RESETTABLE_SCHEDULE_OPTIONS: Omit<
-  ResettableKeys<ManifestEndpoint["scheduleTrigger"]["retryConfig"]>,
-  "maxBackoffSeconds" | "minBackoffSeconds" | "maxRetrySeconds"
-> = {
-  retryCount: null,
-  maxDoublings: null,
-  maxRetryDuration: null,
-  maxBackoffDuration: null,
-  minBackoffDuration: null,
-};
-
 /**
  * Wire format for an event.
  */
@@ -381,21 +374,12 @@ export function makeCloudFunction<EventData>({
 
       const endpoint: ManifestEndpoint = {
         platform: "gcfv1",
+        ...initEndpoint(options),
         ...optionsToEndpoint(options),
       };
 
       if (options.schedule) {
-        let scheduleTrigger: ManifestEndpoint["scheduleTrigger"] = {
-          schedule: options.schedule.schedule,
-        };
-        if (!options.preserveExternalChanges) {
-          const retryConfig = {};
-          for (const key of Object.keys(RESETTABLE_SCHEDULE_OPTIONS)) {
-            retryConfig[key] = RESET_VALUE;
-          }
-          scheduleTrigger = { ...scheduleTrigger, timeZone: RESET_VALUE, retryConfig };
-        }
-        endpoint.scheduleTrigger = scheduleTrigger;
+        endpoint.scheduleTrigger = initV1ScheduleTrigger(options.schedule.schedule, options);
         copyIfPresent(endpoint.scheduleTrigger, options.schedule, "timeZone");
         copyIfPresent(
           endpoint.scheduleTrigger.retryConfig,
@@ -406,7 +390,6 @@ export function makeCloudFunction<EventData>({
           "maxRetryDuration",
           "minBackoffDuration"
         );
-        endpoint.scheduleTrigger = scheduleTrigger;
       } else {
         endpoint.eventTrigger = {
           eventType: legacyEventType || provider + "." + eventType,
@@ -490,12 +473,7 @@ function _detectAuthType(event: Event) {
 
 /** @internal */
 export function optionsToEndpoint(options: DeploymentOptions): ManifestEndpoint {
-  const endpoint: ManifestEndpoint = {};
-  if (!options.preserveExternalChanges) {
-    for (const key of Object.keys(RESETTABLE_OPTIONS)) {
-      endpoint[key] = RESET_VALUE;
-    }
-  }
+  const endpoint: ManifestEndpoint = initEndpoint(options);
   copyIfPresent(
     endpoint,
     options,
@@ -512,7 +490,7 @@ export function optionsToEndpoint(options: DeploymentOptions): ManifestEndpoint
   );
   if (options?.vpcConnector !== undefined) {
     if (options.vpcConnector === null || options.vpcConnector instanceof ResetValue) {
-      endpoint.vpc = null;
+      endpoint.vpc = { connector: RESET_VALUE, egressSettings: RESET_VALUE };
     } else {
       const vpc: ManifestEndpoint["vpc"] = { connector: options.vpcConnector };
       convertIfPresent(vpc, options, "egressSettings", "vpcConnectorEgressSettings");

src/v1/providers/auth.ts

@@ -42,6 +42,7 @@ import {
   optionsToEndpoint,
 } from "../cloud-functions";
 import { DeploymentOptions } from "../function-configuration";
+import { initEndpoint } from "../../runtime/manifest";
 
 // TODO: yank in next breaking change release
 export { UserRecord, UserInfo, UserRecordMetadata, userRecordConstructor };
@@ -215,6 +216,7 @@ export class UserBuilder {
     func.__endpoint = {
       platform: "gcfv1",
       labels: {},
+      ...initEndpoint(this.options),
       ...optionsToEndpoint(this.options),
       blockingTrigger: {
         eventType: legacyEventType,

src/v1/providers/https.ts

@@ -32,6 +32,7 @@ import {
 } from "../../common/providers/https";
 import { HttpsFunction, optionsToEndpoint, Runnable } from "../cloud-functions";
 import { DeploymentOptions } from "../function-configuration";
+import { initEndpoint } from "../../runtime/manifest";
 
 export { Request, CallableContext, FunctionsErrorCode, HttpsError };
 
@@ -69,6 +70,7 @@ export function _onRequestWithOptions(
 
   cloudFunction.__endpoint = {
     platform: "gcfv1",
+    ...initEndpoint(options),
     ...optionsToEndpoint(options),
     httpsTrigger: {},
   };
@@ -102,6 +104,7 @@ export function _onCallWithOptions(
   func.__endpoint = {
     platform: "gcfv1",
     labels: {},
+    ...initEndpoint(options),
     ...optionsToEndpoint(options),
     callableTrigger: {},
   };

src/v1/providers/tasks.ts

@@ -27,14 +27,17 @@ import { Request } from "../../common/providers/https";
 import {
   onDispatchHandler,
   RateLimits,
-  RESETTABLE_RATE_LIMITS_OPTIONS,
-  RESETTABLE_RETRY_CONFIG_OPTIONS,
   RetryConfig,
   TaskContext,
 } from "../../common/providers/tasks";
-import { ManifestEndpoint, ManifestRequiredAPI } from "../../runtime/manifest";
+import {
+  initEndpoint,
+  initTaskQueueTrigger,
+  ManifestEndpoint,
+  ManifestRequiredAPI,
+} from "../../runtime/manifest";
 import { optionsToEndpoint } from "../cloud-functions";
-import { DeploymentOptions, RESET_VALUE } from "../function-configuration";
+import { DeploymentOptions } from "../function-configuration";
 
 export { RetryConfig, RateLimits, TaskContext };
 
@@ -103,23 +106,11 @@ export class TaskQueueBuilder {
     const fixedLen = (data: any, context: TaskContext) => handler(data, context);
     const func: any = onDispatchHandler(fixedLen);
 
-    let taskQueueTrigger = {};
-    if (!this.depOpts?.preserveExternalChanges) {
-      const retryConfig = {};
-      for (const key of Object.keys(RESETTABLE_RETRY_CONFIG_OPTIONS)) {
-        retryConfig[key] = RESET_VALUE;
-      }
-      const rateLimits = {};
-      for (const key of Object.keys(RESETTABLE_RATE_LIMITS_OPTIONS)) {
-        rateLimits[key] = RESET_VALUE;
-      }
-      taskQueueTrigger = { retryConfig, rateLimits };
-    }
-
     func.__endpoint = {
       platform: "gcfv1",
+      ...initEndpoint(this.depOpts),
       ...optionsToEndpoint(this.depOpts),
-      taskQueueTrigger,
+      taskQueueTrigger: initTaskQueueTrigger(this.depOpts),
     };
     copyIfPresent(func.__endpoint.taskQueueTrigger, this.tqOpts, "retryConfig");
     copyIfPresent(func.__endpoint.taskQueueTrigger, this.tqOpts, "rateLimits");