@temporalio/client 1.11.2 → 1.11.4

package/lib/workflow-update-stage.js

@@ -1,28 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toProtoEnum = exports.WorkflowUpdateStage = void 0;
-const proto_1 = require("@temporalio/proto");
-const type_helpers_1 = require("@temporalio/common/lib/type-helpers");
-var WorkflowUpdateStage;
-(function (WorkflowUpdateStage) {
-    /** This is not an allowed value. */
-    WorkflowUpdateStage[WorkflowUpdateStage["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+exports.encodeWorkflowUpdateStage = exports.WorkflowUpdateStage = void 0;
+const internal_workflow_1 = require("@temporalio/common/lib/internal-workflow");
+exports.WorkflowUpdateStage = {
     /** Admitted stage. This stage is reached when the server accepts the update request. It is not
      * allowed to wait for this stage when using startUpdate, since the update request has not yet
      * been durably persisted at this stage. */
-    WorkflowUpdateStage[WorkflowUpdateStage["ADMITTED"] = 1] = "ADMITTED";
+    ADMITTED: 'ADMITTED',
     /** Accepted stage. This stage is reached when a workflow has received the update and either
      * accepted it (i.e. it has passed validation, or there was no validator configured on the update
      * handler) or rejected it. This is currently the only allowed value when using startUpdate. */
-    WorkflowUpdateStage[WorkflowUpdateStage["ACCEPTED"] = 2] = "ACCEPTED";
+    ACCEPTED: 'ACCEPTED',
     /** Completed stage. This stage is reached when a workflow has completed processing the
      * update with either a success or failure. */
-    WorkflowUpdateStage[WorkflowUpdateStage["COMPLETED"] = 3] = "COMPLETED";
-})(WorkflowUpdateStage || (exports.WorkflowUpdateStage = WorkflowUpdateStage = {}));
-(0, type_helpers_1.checkExtends)();
-(0, type_helpers_1.checkExtends)();
-function toProtoEnum(stage) {
-    return proto_1.temporal.api.enums.v1.UpdateWorkflowExecutionLifecycleStage[`UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_${WorkflowUpdateStage[stage]}`];
-}
-exports.toProtoEnum = toProtoEnum;
+    COMPLETED: 'COMPLETED',
+    /**
+     * This is not an allowed value.
+     * @deprecated
+     */
+    UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+};
+exports.encodeWorkflowUpdateStage = (0, internal_workflow_1.makeProtoEnumConverters)({
+    [exports.WorkflowUpdateStage.ADMITTED]: 1,
+    [exports.WorkflowUpdateStage.ACCEPTED]: 2,
+    [exports.WorkflowUpdateStage.COMPLETED]: 3,
+    UNSPECIFIED: 0,
+}, 'UPDATE_WORKFLOW_EXECUTION_LIFECYCLE_STAGE_')[0];
 //# sourceMappingURL=workflow-update-stage.js.map

package/lib/workflow-update-stage.js.map

@@ -1 +1 @@
-{"version":3,"file":"workflow-update-stage.js","sourceRoot":"","sources":["../src/workflow-update-stage.ts"],"names":[],"mappings":";;;AAAA,6CAA6C;AAC7C,sEAAmE;AAEnE,IAAY,mBAcX;AAdD,WAAY,mBAAmB;IAC7B,oCAAoC;IACpC,2EAAe,CAAA;IACf;;+CAE2C;IAC3C,qEAAY,CAAA;IACZ;;mGAE+F;IAC/F,qEAAY,CAAA;IACZ;kDAC8C;IAC9C,uEAAa,CAAA;AACf,CAAC,EAdW,mBAAmB,mCAAnB,mBAAmB,QAc9B;AAED,IAAA,2BAAY,GAGT,CAAC;AACJ,IAAA,2BAAY,GAGT,CAAC;AAEJ,SAAgB,WAAW,CAAC,KAA0B;IACpD,OAAO,gBAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,qCAAqC,CAChE,6CAA6C,mBAAmB,CAAC,KAAK,CAAqC,EAAE,CAC9G,CAAC;AACJ,CAAC;AAJD,kCAIC"}
+{"version":3,"file":"workflow-update-stage.js","sourceRoot":"","sources":["../src/workflow-update-stage.ts"],"names":[],"mappings":";;;AACA,gFAAmF;AAEtE,QAAA,mBAAmB,GAAG;IACjC;;+CAE2C;IAC3C,QAAQ,EAAE,UAAU;IAEpB;;mGAE+F;IAC/F,QAAQ,EAAE,UAAU;IAEpB;kDAC8C;IAC9C,SAAS,EAAE,WAAW;IAEtB;;;OAGG;IACH,WAAW,EAAE,SAAS,EAAE,8CAA8C;CAC9D,CAAC;AAGG,iCAAyB,GAAI,IAAA,2CAAuB,EAOhE;IACE,CAAC,2BAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;IACjC,CAAC,2BAAmB,CAAC,QAAQ,CAAC,EAAE,CAAC;IACjC,CAAC,2BAAmB,CAAC,SAAS,CAAC,EAAE,CAAC;IAClC,WAAW,EAAE,CAAC;CACN,EACV,4CAA4C,CAC7C,IAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporalio/client",
-  "version": "1.11.2",
+  "version": "1.11.4",
   "description": "Temporal.io SDK Client sub-package",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
@@ -14,8 +14,8 @@
   "license": "MIT",
   "dependencies": {
     "@grpc/grpc-js": "^1.10.7",
-    "@temporalio/common": "1.11.2",
-    "@temporalio/proto": "1.11.2",
+    "@temporalio/common": "^1.11.4",
+    "@temporalio/proto": "^1.11.4",
     "abort-controller": "^3.0.0",
     "long": "^5.2.3",
     "uuid": "^9.0.1"
@@ -39,5 +39,5 @@
     "src",
     "lib"
   ],
-  "gitHead": "e78b4f71236ccd3227e674bad68439e961fec639"
+  "gitHead": "6a7e2d527c9f7078ee78abd9d59ca0d318bb70dd"
 }

package/src/async-completion-client.ts

@@ -1,6 +1,5 @@
 import { status as grpcStatus } from '@grpc/grpc-js';
 import { ensureTemporalFailure } from '@temporalio/common';
-import type { temporal } from '@temporalio/proto';
 import {
   encodeErrorToFailure,
   encodeToPayloads,
@@ -216,23 +215,23 @@ export class AsyncCompletionClient extends BaseClient {
     const payloads = await encodeToPayloads(this.dataConverter, details);
     let cancelRequested = false;
     try {
-      let response: temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatResponse;
       if (taskTokenOrFullActivityId instanceof Uint8Array) {
-        response = await this.workflowService.recordActivityTaskHeartbeat({
+        const response = await this.workflowService.recordActivityTaskHeartbeat({
           identity: this.options.identity,
           namespace: this.options.namespace,
           taskToken: taskTokenOrFullActivityId,
           details: { payloads },
         });
+        cancelRequested = !!response.cancelRequested;
       } else {
-        response = await this.workflowService.recordActivityTaskHeartbeatById({
+        const response = await this.workflowService.recordActivityTaskHeartbeatById({
           identity: this.options.identity,
           namespace: this.options.namespace,
           ...taskTokenOrFullActivityId,
           details: { payloads },
         });
+        cancelRequested = !!response.cancelRequested;
       }
-      cancelRequested = !!response.cancelRequested;
     } catch (err) {
       this.handleError(err);
     }

package/src/base-client.ts

@@ -1,4 +1,5 @@
 import os from 'node:os';
+import type * as _grpc from '@grpc/grpc-js'; // For JSDoc only
 import { DataConverter, LoadedDataConverter } from '@temporalio/common';
 import { isLoadedDataConverter, loadDataConverter } from '@temporalio/common/lib/internal-non-workflow';
 import { Connection } from './connection';
@@ -51,7 +52,14 @@ export function defaultBaseClientOptions(): WithDefaults<BaseClientOptions> {
 }
 
 export class BaseClient {
+  /**
+   * The underlying {@link Connection | connection} used by this client.
+   *
+   * Clients are cheap to create, but connections are expensive. Where that make sense,
+   * a single connection may and should be reused by multiple `Client`.
+   */
   public readonly connection: ConnectionLike;
+
   private readonly loadedDataConverter: LoadedDataConverter;
 
   protected constructor(options?: BaseClientOptions) {
@@ -61,19 +69,37 @@ export class BaseClient {
   }
 
   /**
-   * Set the deadline for any service requests executed in `fn`'s scope.
+   * Set a deadline for any service requests executed in `fn`'s scope.
+   *
+   * The deadline is a point in time after which any pending gRPC request will be considered as failed;
+   * this will locally result in the request call throwing a {@link _grpc.ServiceError|ServiceError}
+   * with code {@link _grpc.status.DEADLINE_EXCEEDED|DEADLINE_EXCEEDED}; see {@link isGrpcDeadlineError}.
+   *
+   * It is stronly recommended to explicitly set deadlines. If no deadline is set, then it is
+   * possible for the client to end up waiting forever for a response.
+   *
+   * This method is only a convenience wrapper around {@link Connection.withDeadline}.
+   *
+   * @param deadline a point in time after which the request will be considered as failed; either a
+   *                 Date object, or a number of milliseconds since the Unix epoch (UTC).
+   * @returns the value returned from `fn`
+   *
+   * @see https://grpc.io/docs/guides/deadlines/
    */
   public async withDeadline<R>(deadline: number | Date, fn: () => Promise<R>): Promise<R> {
     return await this.connection.withDeadline(deadline, fn);
   }
 
   /**
-   * Set an {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} that, when aborted,
-   * cancels any ongoing service requests executed in `fn`'s scope.
+   * Set an {@link AbortSignal} that, when aborted, cancels any ongoing service requests executed in
+   * `fn`'s scope. This will locally result in the request call throwing a {@link _grpc.ServiceError|ServiceError}
+   * with code {@link _grpc.status.CANCELLED|CANCELLED}; see {@link isGrpcCancelledError}.
+   *
+   * This method is only a convenience wrapper around {@link Connection.withAbortSignal}.
    *
    * @returns value returned from `fn`
    *
-   * @see {@link Connection.withAbortSignal}
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
    */
   async withAbortSignal<R>(abortSignal: AbortSignal, fn: () => Promise<R>): Promise<R> {
     return await this.connection.withAbortSignal(abortSignal, fn);
@@ -82,9 +108,9 @@ export class BaseClient {
   /**
    * Set metadata for any service requests executed in `fn`'s scope.
    *
-   * @returns returned value of `fn`
+   * This method is only a convenience wrapper around {@link Connection.withMetadata}.
    *
-   * @see {@link Connection.withMetadata}
+   * @returns returned value of `fn`
    */
   public async withMetadata<R>(metadata: Metadata, fn: () => Promise<R>): Promise<R> {
     return await this.connection.withMetadata(metadata, fn);

package/src/client.ts

@@ -1,10 +1,9 @@
 import { filterNullAndUndefined } from '@temporalio/common/lib/internal-non-workflow';
-import { temporal } from '@temporalio/proto';
 import { AsyncCompletionClient } from './async-completion-client';
 import { BaseClient, BaseClientOptions, defaultBaseClientOptions, LoadedWithDefaults } from './base-client';
 import { ClientInterceptors } from './interceptors';
 import { ScheduleClient } from './schedule-client';
-import { WorkflowService } from './types';
+import { QueryRejectCondition, WorkflowService } from './types';
 import { WorkflowClient } from './workflow-client';
 import { TaskQueueClient } from './task-queue-client';
 
@@ -20,9 +19,9 @@ export interface ClientOptions extends BaseClientOptions {
     /**
      * Should a query be rejected by closed and failed workflows
      *
-     * @default QUERY_REJECT_CONDITION_UNSPECIFIED which means that closed and failed workflows are still queryable
+     * @default `undefined`, which means that closed and failed workflows are still queryable
      */
-    queryRejectCondition?: temporal.api.enums.v1.QueryRejectCondition;
+    queryRejectCondition?: QueryRejectCondition;
   };
 }
 
@@ -63,6 +62,7 @@ export class Client extends BaseClient {
       connection: this.connection,
       dataConverter: this.dataConverter,
       interceptors: interceptors?.workflow,
+      queryRejectCondition: workflow?.queryRejectCondition,
     });
 
     this.activity = new AsyncCompletionClient({

package/src/connection.ts

@@ -5,7 +5,7 @@ import {
   filterNullAndUndefined,
   normalizeTlsConfig,
   TLSConfig,
-  normalizeTemporalGrpcEndpointAddress,
+  normalizeGrpcEndpointAddress,
 } from '@temporalio/common/lib/internal-non-workflow';
 import { Duration, msOptionalToNumber } from '@temporalio/common/lib/time';
 import { isGrpcServiceError, ServiceError } from './errors';
@@ -13,6 +13,11 @@ import { defaultGrpcRetryOptions, makeGrpcRetryInterceptor } from './grpc-retry'
 import pkg from './pkg';
 import { CallContext, HealthService, Metadata, OperatorService, WorkflowService } from './types';
 
+/**
+ * The default Temporal Server's TCP port for public gRPC connections.
+ */
+const DEFAULT_TEMPORAL_GRPC_PORT = 7233;
+
 /**
  * gRPC and Temporal Server connection options
  */
@@ -174,7 +179,7 @@ function normalizeGRPCConfig(options?: ConnectionOptions): ConnectionOptions {
     }
   }
   if (rest.address) {
-    rest.address = normalizeTemporalGrpcEndpointAddress(rest.address);
+    rest.address = normalizeGrpcEndpointAddress(rest.address, DEFAULT_TEMPORAL_GRPC_PORT);
   }
   const tls = normalizeTlsConfig(tlsFromConfig);
   if (tls) {
@@ -220,20 +225,24 @@ export interface RPCImplOptions {
 export interface ConnectionCtorOptions {
   readonly options: ConnectionOptionsWithDefaults;
   readonly client: grpc.Client;
+
   /**
    * Raw gRPC access to the Temporal service.
    *
    * **NOTE**: The namespace provided in {@link options} is **not** automatically set on requests made to the service.
    */
   readonly workflowService: WorkflowService;
+
   /**
    * Raw gRPC access to the Temporal {@link https://github.com/temporalio/api/blob/ddf07ab9933e8230309850e3c579e1ff34b03f53/temporal/api/operatorservice/v1/service.proto | operator service}.
    */
   readonly operatorService: OperatorService;
+
   /**
    * Raw gRPC access to the standard gRPC {@link https://github.com/grpc/grpc/blob/92f58c18a8da2728f571138c37760a721c8915a2/doc/health-checking.md | health service}.
    */
   readonly healthService: HealthService;
+
   readonly callContextStorage: AsyncLocalStorage<CallContext>;
   readonly apiKeyFnRef: { fn?: () => string };
 }
@@ -241,8 +250,8 @@ export interface ConnectionCtorOptions {
 /**
  * Client connection to the Temporal Server
  *
- * ⚠️ Connections are expensive to construct and should be reused. Make sure to {@link close} any unused connections to
- * avoid leaking resources.
+ * ⚠️ Connections are expensive to construct and should be reused.
+ * Make sure to {@link close} any unused connections to avoid leaking resources.
  */
 export class Connection {
   /**
@@ -275,7 +284,12 @@ export class Connection {
    * Cloud namespace will result in gRPC `unauthorized` error.
    */
   public readonly operatorService: OperatorService;
+
+  /**
+   * Raw gRPC access to the standard gRPC {@link https://github.com/grpc/grpc/blob/92f58c18a8da2728f571138c37760a721c8915a2/doc/health-checking.md | health service}.
+   */
   public readonly healthService: HealthService;
+
   readonly callContextStorage: AsyncLocalStorage<CallContext>;
   private readonly apiKeyFnRef: { fn?: () => string };
 
@@ -424,7 +438,8 @@ export class Connection {
       const metadataContainer = new grpc.Metadata();
       const { metadata, deadline, abortSignal } = callContextStorage.getStore() ?? {};
       if (apiKeyFnRef.fn) {
-        metadataContainer.set('Authorization', `Bearer ${apiKeyFnRef.fn()}`);
+        const apiKey = apiKeyFnRef.fn();
+        if (apiKey) metadataContainer.set('Authorization', `Bearer ${apiKey}`);
       }
       for (const [k, v] of Object.entries(staticMetadata)) {
         metadataContainer.set(k, v);
@@ -452,9 +467,20 @@ export class Connection {
   }
 
   /**
-   * Set the deadline for any service requests executed in `fn`'s scope.
+   * Set a deadline for any service requests executed in `fn`'s scope.
    *
-   * @returns value returned from `fn`
+   * The deadline is a point in time after which any pending gRPC request will be considered as failed;
+   * this will locally result in the request call throwing a {@link grpc.ServiceError|ServiceError}
+   * with code {@link grpc.status.DEADLINE_EXCEEDED|DEADLINE_EXCEEDED}; see {@link isGrpcDeadlineError}.
+   *
+   * It is stronly recommended to explicitly set deadlines. If no deadline is set, then it is
+   * possible for the client to end up waiting forever for a response.
+   *
+   * @param deadline a point in time after which the request will be considered as failed; either a
+   *                 Date object, or a number of milliseconds since the Unix epoch (UTC).
+   * @returns the value returned from `fn`
+   *
+   * @see https://grpc.io/docs/guides/deadlines/
    */
   async withDeadline<ReturnType>(deadline: number | Date, fn: () => Promise<ReturnType>): Promise<ReturnType> {
     const cc = this.callContextStorage.getStore();
@@ -462,10 +488,11 @@ export class Connection {
   }
 
   /**
-   * Set an {@link https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal | `AbortSignal`} that, when aborted,
-   * cancels any ongoing requests executed in `fn`'s scope.
+   * Set an {@link AbortSignal} that, when aborted, cancels any ongoing service requests executed in
+   * `fn`'s scope. This will locally result in the request call throwing a {@link grpc.ServiceError|ServiceError}
+   * with code {@link grpc.status.CANCELLED|CANCELLED}; see {@link isGrpcCancelledError}.
    *
-   * @returns value returned from `fn`
+   * This method is only a convenience wrapper around {@link Connection.withAbortSignal}.
    *
    * @example
    *
@@ -475,6 +502,10 @@ export class Connection {
    * // 👇 throws if incomplete by the timeout.
    * await conn.withAbortSignal(ctrl.signal, () => client.workflow.execute(myWorkflow, options));
    * ```
+   *
+   * @returns value returned from `fn`
+   *
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
    */
   async withAbortSignal<ReturnType>(abortSignal: AbortSignal, fn: () => Promise<ReturnType>): Promise<ReturnType> {
     const cc = this.callContextStorage.getStore();
@@ -572,5 +603,6 @@ export class Connection {
    */
   public async close(): Promise<void> {
     this.client.close();
+    this.callContextStorage.disable();
   }
 }

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { ServiceError as GrpcServiceError } from '@grpc/grpc-js';
+import { ServiceError as GrpcServiceError, status } from '@grpc/grpc-js';
 import { RetryState, TemporalFailure } from '@temporalio/common';
 import { isError, isRecord, SymbolBasedInstanceOfError } from '@temporalio/common/lib/type-helpers';
 
@@ -79,6 +79,9 @@ export class WorkflowContinuedAsNewError extends Error {
   }
 }
 
+/**
+ * Returns true if the provided error is a {@link GrpcServiceError}.
+ */
 export function isGrpcServiceError(err: unknown): err is GrpcServiceError {
   return (
     isError(err) &&
@@ -87,6 +90,36 @@ export function isGrpcServiceError(err: unknown): err is GrpcServiceError {
   );
 }
 
+/**
+ * Returns true if the provided error or its cause is a {@link GrpcServiceError} with code DEADLINE_EXCEEDED.
+ *
+ * @see {@link Connection.withDeadline}
+ */
+export function isGrpcDeadlineError(err: unknown): err is Error {
+  while (isError(err)) {
+    if (isGrpcServiceError(err) && (err as GrpcServiceError).code === status.DEADLINE_EXCEEDED) {
+      return true;
+    }
+    err = (err as any).cause;
+  }
+  return false;
+}
+
+/**
+ * Returns true if the provided error or its cause is a {@link GrpcServiceError} with code CANCELLED.
+ *
+ * @see {@link Connection.withAbortSignal}
+ */
+export function isGrpcCancelledError(err: unknown): err is Error {
+  while (isError(err)) {
+    if (isGrpcServiceError(err) && (err as GrpcServiceError).code === status.CANCELLED) {
+      return true;
+    }
+    err = (err as any).cause;
+  }
+  return false;
+}
+
 /**
  * @deprecated Use `isGrpcServiceError` instead
  */

package/src/schedule-client.ts

@@ -29,17 +29,17 @@ import {
   ScheduleUpdateOptions,
   ScheduleOptionsAction,
   ScheduleOptionsStartWorkflowAction,
+  encodeScheduleOverlapPolicy,
+  decodeScheduleOverlapPolicy,
 } from './schedule-types';
 import {
   compileScheduleOptions,
   compileUpdatedScheduleOptions,
-  decodeOverlapPolicy,
   decodeScheduleAction,
   decodeScheduleRecentActions,
   decodeScheduleRunningActions,
   decodeScheduleSpec,
   decodeSearchAttributes,
-  encodeOverlapPolicy,
   encodeScheduleAction,
   encodeSchedulePolicies,
   encodeScheduleSpec,
@@ -162,6 +162,10 @@ export interface ListScheduleOptions {
    * @default 1000
    */
   pageSize?: number;
+  /**
+   * Filter schedules by a query string.
+   */
+  query?: string;
 }
 
 /**
@@ -247,7 +251,7 @@ export class ScheduleClient extends BaseClient {
           ? opts.state.backfill.map((x) => ({
               startTime: optionalDateToTs(x.start),
               endTime: optionalDateToTs(x.end),
-              overlapPolicy: x.overlap ? encodeOverlapPolicy(x.overlap) : undefined,
+              overlapPolicy: x.overlap ? encodeScheduleOverlapPolicy(x.overlap) : undefined,
             }))
           : undefined,
       },
@@ -368,6 +372,7 @@ export class ScheduleClient extends BaseClient {
           nextPageToken,
           namespace: this.options.namespace,
           maximumPageSize: options?.pageSize,
+          query: options?.query,
         });
       } catch (e) {
         this.rethrowGrpcError(e, 'Failed to list schedules', undefined);
@@ -422,7 +427,8 @@ export class ScheduleClient extends BaseClient {
           memo: await decodeMapFromPayloads(this.client.dataConverter, raw.memo?.fields),
           searchAttributes: decodeSearchAttributes(raw.searchAttributes),
           policies: {
-            overlap: decodeOverlapPolicy(raw.schedule.policies?.overlapPolicy),
+            // 'overlap' should never be missing on describe, as the server will replace UNSPECIFIED by an actual value
+            overlap: decodeScheduleOverlapPolicy(raw.schedule.policies?.overlapPolicy) ?? ScheduleOverlapPolicy.SKIP,
             catchupWindow: optionalTsToMs(raw.schedule.policies?.catchupWindow) ?? 60_000,
             pauseOnFailure: raw.schedule.policies?.pauseOnFailure === true,
           },
@@ -480,7 +486,7 @@ export class ScheduleClient extends BaseClient {
         await this.client._patchSchedule(this.scheduleId, {
           triggerImmediately: {
             overlapPolicy: overlap
-              ? encodeOverlapPolicy(overlap)
+              ? encodeScheduleOverlapPolicy(overlap)
               : temporal.api.enums.v1.ScheduleOverlapPolicy.SCHEDULE_OVERLAP_POLICY_ALLOW_ALL,
           },
         });
@@ -492,7 +498,7 @@ export class ScheduleClient extends BaseClient {
           backfillRequest: backfills.map((x) => ({
             startTime: optionalDateToTs(x.start),
             endTime: optionalDateToTs(x.end),
-            overlapPolicy: x.overlap ? encodeOverlapPolicy(x.overlap) : undefined,
+            overlapPolicy: x.overlap ? encodeScheduleOverlapPolicy(x.overlap) : undefined,
           })),
         });
       },

package/src/schedule-helpers.ts

@@ -32,7 +32,6 @@ import {
   CompiledScheduleUpdateOptions,
   Range,
   ScheduleOptions,
-  ScheduleOverlapPolicy,
   ScheduleUpdateOptions,
   DayOfWeek,
   DAYS_OF_WEEK,
@@ -47,6 +46,7 @@ import {
   ScheduleExecutionActionResult,
   ScheduleExecutionResult,
   ScheduleExecutionStartWorkflowActionResult,
+  encodeScheduleOverlapPolicy,
 } from './schedule-types';
 
 const [encodeSecond, decodeSecond] = makeCalendarSpecFieldCoders(
@@ -192,21 +192,6 @@ export function decodeOptionalStructuredCalendarSpecs(
   );
 }
 
-export function encodeOverlapPolicy(input: ScheduleOverlapPolicy): temporal.api.enums.v1.ScheduleOverlapPolicy {
-  return temporal.api.enums.v1.ScheduleOverlapPolicy[
-    `SCHEDULE_OVERLAP_POLICY_${ScheduleOverlapPolicy[input] as keyof typeof ScheduleOverlapPolicy}`
-  ];
-}
-
-export function decodeOverlapPolicy(input?: temporal.api.enums.v1.ScheduleOverlapPolicy | null): ScheduleOverlapPolicy {
-  if (!input) return ScheduleOverlapPolicy.UNSPECIFIED;
-  const encodedPolicyName = temporal.api.enums.v1.ScheduleOverlapPolicy[input];
-  const decodedPolicyName = encodedPolicyName.substring(
-    'SCHEDULE_OVERLAP_POLICY_'.length
-  ) as keyof typeof ScheduleOverlapPolicy;
-  return ScheduleOverlapPolicy[decodedPolicyName];
-}
-
 export function compileScheduleOptions(options: ScheduleOptions): CompiledScheduleOptions {
   const workflowTypeOrFunc = options.action.workflowType;
   const workflowType = extractWorkflowType(workflowTypeOrFunc);
@@ -290,7 +275,7 @@ export function encodeSchedulePolicies(
 ): temporal.api.schedule.v1.ISchedulePolicies {
   return {
     catchupWindow: msOptionalToTs(policies?.catchupWindow),
-    overlapPolicy: policies?.overlap ? encodeOverlapPolicy(policies.overlap) : undefined,
+    overlapPolicy: policies?.overlap ? encodeScheduleOverlapPolicy(policies.overlap) : undefined,
     pauseOnFailure: policies?.pauseOnFailure,
   };
 }

package/src/schedule-types.ts

@@ -1,5 +1,6 @@
 import { checkExtends, Replace } from '@temporalio/common/lib/type-helpers';
 import { Duration, SearchAttributes, Workflow } from '@temporalio/common';
+import { makeProtoEnumConverters } from '@temporalio/common/lib/internal-workflow';
 import type { temporal } from '@temporalio/proto';
 import { WorkflowStartOptions } from './workflow-options';
 
@@ -795,57 +796,69 @@ export type CompiledScheduleAction = Replace<
 /**
  * Policy for overlapping Actions.
  */
-export enum ScheduleOverlapPolicy {
-  /**
-   * Use server default (currently SKIP).
-   *
-   * FIXME: remove this field if this issue is implemented: https://github.com/temporalio/temporal/issues/3240
-   */
-  UNSPECIFIED = 0,
-
+export const ScheduleOverlapPolicy = {
   /**
    * Don't start a new Action.
+   * @default
    */
-  SKIP,
+  SKIP: 'SKIP',
 
   /**
    * Start another Action as soon as the current Action completes, but only buffer one Action in this way. If another
    * Action is supposed to start, but one Action is running and one is already buffered, then only the buffered one will
    * be started after the running Action finishes.
    */
-  BUFFER_ONE,
+  BUFFER_ONE: 'BUFFER_ONE',
 
   /**
    * Allows an unlimited number of Actions to buffer. They are started sequentially.
    */
-  BUFFER_ALL,
+  BUFFER_ALL: 'BUFFER_ALL',
 
   /**
    * Cancels the running Action, and then starts the new Action once the cancelled one completes.
    */
-  CANCEL_OTHER,
+  CANCEL_OTHER: 'CANCEL_OTHER',
 
   /**
    * Terminate the running Action and start the new Action immediately.
    */
-  TERMINATE_OTHER,
+  TERMINATE_OTHER: 'TERMINATE_OTHER',
 
   /**
    * Allow any number of Actions to start immediately.
    *
    * This is the only policy under which multiple Actions can run concurrently.
    */
-  ALLOW_ALL,
-}
+  ALLOW_ALL: 'ALLOW_ALL',
 
-checkExtends<
+  /**
+   * Use server default (currently SKIP).
+   *
+   * @deprecated Either leave property `undefined`, or use {@link SKIP} instead.
+   */
+  UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+} as const;
+export type ScheduleOverlapPolicy = (typeof ScheduleOverlapPolicy)[keyof typeof ScheduleOverlapPolicy];
+
+export const [encodeScheduleOverlapPolicy, decodeScheduleOverlapPolicy] = makeProtoEnumConverters<
+  temporal.api.enums.v1.ScheduleOverlapPolicy,
+  typeof temporal.api.enums.v1.ScheduleOverlapPolicy,
   keyof typeof temporal.api.enums.v1.ScheduleOverlapPolicy,
-  `SCHEDULE_OVERLAP_POLICY_${keyof typeof ScheduleOverlapPolicy}`
->();
-checkExtends<
-  `SCHEDULE_OVERLAP_POLICY_${keyof typeof ScheduleOverlapPolicy}`,
-  keyof typeof temporal.api.enums.v1.ScheduleOverlapPolicy
->();
+  typeof ScheduleOverlapPolicy,
+  'SCHEDULE_OVERLAP_POLICY_'
+>(
+  {
+    [ScheduleOverlapPolicy.SKIP]: 1,
+    [ScheduleOverlapPolicy.BUFFER_ONE]: 2,
+    [ScheduleOverlapPolicy.BUFFER_ALL]: 3,
+    [ScheduleOverlapPolicy.CANCEL_OTHER]: 4,
+    [ScheduleOverlapPolicy.TERMINATE_OTHER]: 5,
+    [ScheduleOverlapPolicy.ALLOW_ALL]: 6,
+    UNSPECIFIED: 0,
+  } as const,
+  'SCHEDULE_OVERLAP_POLICY_'
+);
 
 export interface Backfill {
   /**