@temporalio/client 1.7.4 → 1.8.1

package/src/async-completion-client.ts

@@ -1,5 +1,6 @@
-import { Status } from '@grpc/grpc-js/build/src/constants';
+import { status as grpcStatus } from '@grpc/grpc-js';
 import { ensureTemporalFailure } from '@temporalio/common';
+import type { temporal } from '@temporalio/proto';
 import {
   encodeErrorToFailure,
   encodeToPayloads,
@@ -12,8 +13,9 @@ import {
   LoadedWithDefaults,
   WithDefaults,
 } from './base-client';
-import { isServerErrorResponse } from './errors';
+import { isGrpcServiceError } from './errors';
 import { WorkflowService } from './types';
+import { rethrowKnownErrorTypes } from './helpers';
 
 /**
  * Thrown by {@link AsyncCompletionClient} when trying to complete or heartbeat an Activity that does not exist in the
@@ -95,10 +97,13 @@ export class AsyncCompletionClient extends BaseClient {
    * Transforms grpc errors into well defined TS errors.
    */
   protected handleError(err: unknown): never {
-    if (isServerErrorResponse(err)) {
-      if (err.code === Status.NOT_FOUND) {
+    if (isGrpcServiceError(err)) {
+      rethrowKnownErrorTypes(err);
+
+      if (err.code === grpcStatus.NOT_FOUND) {
         throw new ActivityNotFoundError('Not found');
       }
+
       throw new ActivityCompletionError(err.details || err.message);
     }
     throw new ActivityCompletionError('Unexpected failure');
@@ -114,20 +119,21 @@ export class AsyncCompletionClient extends BaseClient {
   async complete(fullActivityId: FullActivityId, result: unknown): Promise<void>;
 
   async complete(taskTokenOrFullActivityId: Uint8Array | FullActivityId, result: unknown): Promise<void> {
+    const payloads = await encodeToPayloads(this.dataConverter, result);
     try {
       if (taskTokenOrFullActivityId instanceof Uint8Array) {
         await this.workflowService.respondActivityTaskCompleted({
           identity: this.options.identity,
           namespace: this.options.namespace,
           taskToken: taskTokenOrFullActivityId,
-          result: { payloads: await encodeToPayloads(this.dataConverter, result) },
+          result: { payloads },
         });
       } else {
         await this.workflowService.respondActivityTaskCompletedById({
           identity: this.options.identity,
           namespace: this.options.namespace,
           ...taskTokenOrFullActivityId,
-          result: { payloads: await encodeToPayloads(this.dataConverter, result) },
+          result: { payloads },
         });
       }
     } catch (err) {
@@ -145,20 +151,21 @@ export class AsyncCompletionClient extends BaseClient {
   async fail(fullActivityId: FullActivityId, err: unknown): Promise<void>;
 
   async fail(taskTokenOrFullActivityId: Uint8Array | FullActivityId, err: unknown): Promise<void> {
+    const failure = await encodeErrorToFailure(this.dataConverter, ensureTemporalFailure(err));
     try {
       if (taskTokenOrFullActivityId instanceof Uint8Array) {
         await this.workflowService.respondActivityTaskFailed({
           identity: this.options.identity,
           namespace: this.options.namespace,
           taskToken: taskTokenOrFullActivityId,
-          failure: await encodeErrorToFailure(this.dataConverter, ensureTemporalFailure(err)),
+          failure,
         });
       } else {
         await this.workflowService.respondActivityTaskFailedById({
           identity: this.options.identity,
           namespace: this.options.namespace,
           ...taskTokenOrFullActivityId,
-          failure: await encodeErrorToFailure(this.dataConverter, err),
+          failure,
         });
       }
     } catch (err) {
@@ -176,20 +183,21 @@ export class AsyncCompletionClient extends BaseClient {
   reportCancellation(fullActivityId: FullActivityId, details?: unknown): Promise<void>;
 
   async reportCancellation(taskTokenOrFullActivityId: Uint8Array | FullActivityId, details?: unknown): Promise<void> {
+    const payloads = await encodeToPayloads(this.dataConverter, details);
     try {
       if (taskTokenOrFullActivityId instanceof Uint8Array) {
         await this.workflowService.respondActivityTaskCanceled({
           identity: this.options.identity,
           namespace: this.options.namespace,
           taskToken: taskTokenOrFullActivityId,
-          details: { payloads: await encodeToPayloads(this.dataConverter, details) },
+          details: { payloads },
         });
       } else {
         await this.workflowService.respondActivityTaskCanceledById({
           identity: this.options.identity,
           namespace: this.options.namespace,
           ...taskTokenOrFullActivityId,
-          details: { payloads: await encodeToPayloads(this.dataConverter, details) },
+          details: { payloads },
         });
       }
     } catch (err) {
@@ -207,33 +215,31 @@ export class AsyncCompletionClient extends BaseClient {
   heartbeat(fullActivityId: FullActivityId, details?: unknown): Promise<void>;
 
   async heartbeat(taskTokenOrFullActivityId: Uint8Array | FullActivityId, details?: unknown): Promise<void> {
+    const payloads = await encodeToPayloads(this.dataConverter, details);
+    let cancelRequested = false;
     try {
+      let response: temporal.api.workflowservice.v1.RecordActivityTaskHeartbeatResponse;
       if (taskTokenOrFullActivityId instanceof Uint8Array) {
-        const { cancelRequested } = await this.workflowService.recordActivityTaskHeartbeat({
+        response = await this.workflowService.recordActivityTaskHeartbeat({
           identity: this.options.identity,
           namespace: this.options.namespace,
           taskToken: taskTokenOrFullActivityId,
-          details: { payloads: await encodeToPayloads(this.dataConverter, details) },
+          details: { payloads },
         });
-        if (cancelRequested) {
-          throw new ActivityCancelledError('cancelled');
-        }
       } else {
-        const { cancelRequested } = await this.workflowService.recordActivityTaskHeartbeatById({
+        response = await this.workflowService.recordActivityTaskHeartbeatById({
           identity: this.options.identity,
           namespace: this.options.namespace,
           ...taskTokenOrFullActivityId,
-          details: { payloads: await encodeToPayloads(this.dataConverter, details) },
+          details: { payloads },
         });
-        if (cancelRequested) {
-          throw new ActivityCancelledError('cancelled');
-        }
       }
+      cancelRequested = !!response.cancelRequested;
     } catch (err) {
-      if (err instanceof ActivityCancelledError) {
-        throw err;
-      }
       this.handleError(err);
     }
+    if (cancelRequested) {
+      throw new ActivityCancelledError('cancelled');
+    }
   }
 }

package/src/build-id-types.ts

@@ -0,0 +1,146 @@
+import { temporal } from '@temporalio/proto';
+
+/**
+ * Operations that can be passed to {@link TaskQueueClient.updateBuildIdCompatibility}.
+ *
+ * @experimental
+ */
+export type BuildIdOperation =
+  | AddNewIdInNewDefaultSet
+  | AddNewCompatibleVersion
+  | PromoteSetByBuildId
+  | PromoteBuildIdWithinSet
+  | MergeSets;
+
+/**
+ * Adds a new Build Id into a new set, which will be used as the default set for
+ * the queue. This means all new workflows will start on this Build Id.
+ *
+ * @experimental
+ */
+export interface AddNewIdInNewDefaultSet {
+  operation: 'addNewIdInNewDefaultSet';
+  buildId: string;
+}
+
+/**
+ * Adds a new Build Id into an existing compatible set. The newly added ID becomes
+ * the default for that compatible set, and thus new workflow tasks for workflows which have been
+ * executing on workers in that set will now start on this new Build Id.
+ *
+ * @experimental
+ */
+export interface AddNewCompatibleVersion {
+  operation: 'addNewCompatibleVersion';
+  // The Build Id to add to an existing compatible set.
+  buildId: string;
+  // A Build Id which must already be defined on the task queue, and is used to
+  // find the compatible set to add the new id to.
+  existingCompatibleBuildId: string;
+  // If set to true, the targeted set will also be promoted to become the
+  // overall default set for the queue.
+  promoteSet?: boolean;
+}
+
+/**
+ * Promotes a set of compatible Build Ids to become the current
+ * default set for the task queue. Any Build Id in the set may be used to
+ * target it.
+ *
+ * @experimental
+ */
+export interface PromoteSetByBuildId {
+  operation: 'promoteSetByBuildId';
+  buildId: string;
+}
+
+/**
+ * Promotes a Build Id within an existing set to become the default ID for that
+ * set.
+ *
+ * @experimental
+ */
+export interface PromoteBuildIdWithinSet {
+  operation: 'promoteBuildIdWithinSet';
+  buildId: string;
+}
+
+/**
+ * Merges two sets into one set, thus declaring all the Build Ids in both as
+ * compatible with one another. The default of the primary set is maintained as
+ * the merged set's overall default.
+ *
+ * @experimental
+ */
+export interface MergeSets {
+  operation: 'mergeSets';
+  // A Build Id which is used to find the primary set to be merged.
+  primaryBuildId: string;
+  // A Build Id which is used to find the secondary set to be merged.
+  secondaryBuildId: string;
+}
+
+/**
+ * Represents the sets of compatible Build Id versions associated with some
+ * Task Queue, as fetched by {@link TaskQueueClient.getBuildIdCompatability}.
+ *
+ * @experimental
+ */
+export interface WorkerBuildIdVersionSets {
+  /**
+   * All version sets that were fetched for this task queue.
+   */
+  readonly versionSets: BuildIdVersionSet[];
+
+  /**
+   * Returns the default set of compatible Build Ids for the task queue these sets are
+   * associated with.
+   */
+  defaultSet: BuildIdVersionSet;
+
+  /**
+   * Returns the overall default Build Id for the task queue these sets are
+   * associated with.
+   */
+  defaultBuildId: string;
+}
+
+/**
+ * Represents one set of compatible Build Ids.
+ *
+ * @experimental
+ */
+export interface BuildIdVersionSet {
+  // All build IDs contained in the set.
+  readonly buildIds: string[];
+
+  // Returns the default Build Id for this set
+  readonly default: string;
+}
+
+export function versionSetsFromProto(
+  resp: temporal.api.workflowservice.v1.GetWorkerBuildIdCompatibilityResponse
+): WorkerBuildIdVersionSets {
+  if (resp == null || resp.majorVersionSets == null || resp.majorVersionSets.length === 0) {
+    throw new Error('Must be constructed from a compatability response with at least one version set');
+  }
+  return {
+    versionSets: resp.majorVersionSets.map((set) => versionSetFromProto(set)),
+    get defaultSet(): BuildIdVersionSet {
+      return this.versionSets[this.versionSets.length - 1];
+    },
+    get defaultBuildId(): string {
+      return this.defaultSet.default;
+    },
+  };
+}
+
+function versionSetFromProto(set: temporal.api.taskqueue.v1.ICompatibleVersionSet): BuildIdVersionSet {
+  if (set == null || set.buildIds == null || set.buildIds.length === 0) {
+    throw new Error('Compatible version sets must contain at least one Build Id');
+  }
+  return {
+    buildIds: set.buildIds,
+    default: set.buildIds[set.buildIds.length - 1],
+  };
+}

package/src/client.ts

@@ -6,6 +6,7 @@ import { ClientInterceptors } from './interceptors';
 import { ScheduleClient } from './schedule-client';
 import { WorkflowService } from './types';
 import { WorkflowClient } from './workflow-client';
+import { TaskQueueClient } from './task-queue-client';
 
 export interface ClientOptions extends BaseClientOptions {
   /**
@@ -46,6 +47,12 @@ export class Client extends BaseClient {
    * @experimental
    */
   public readonly schedule: ScheduleClient;
+  /**
+   * Task Queue sub-client - use to perform operations on Task Queues
+   *
+   * @experimental
+   */
+  public readonly taskQueue: TaskQueueClient;
 
   constructor(options?: ClientOptions) {
     super(options);
@@ -73,6 +80,12 @@ export class Client extends BaseClient {
       interceptors: interceptors?.schedule,
     });
 
+    this.taskQueue = new TaskQueueClient({
+      ...commonOptions,
+      connection: this.connection,
+      dataConverter: this.dataConverter,
+    });
+
     this.options = {
       ...defaultBaseClientOptions(),
       ...filterNullAndUndefined(commonOptions),

package/src/connection.ts

@@ -2,8 +2,8 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import * as grpc from '@grpc/grpc-js';
 import type { RPCImpl } from 'protobufjs';
 import { filterNullAndUndefined, normalizeTlsConfig, TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
-import { msOptionalToNumber } from '@temporalio/common/lib/time';
-import { isServerErrorResponse, ServiceError } from './errors';
+import { Duration, msOptionalToNumber } from '@temporalio/common/lib/time';
+import { isGrpcServiceError, ServiceError } from './errors';
 import { defaultGrpcRetryOptions, makeGrpcRetryInterceptor } from './grpc-retry';
 import pkg from './pkg';
 import { CallContext, HealthService, Metadata, OperatorService, WorkflowService } from './types';
@@ -81,7 +81,7 @@ export interface ConnectionOptions {
    * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
    * @default 10 seconds
    */
-  connectTimeout?: number | string;
+  connectTimeout?: Duration;
 }
 
 export type ConnectionOptionsWithDefaults = Required<Omit<ConnectionOptions, 'tls' | 'connectTimeout'>> & {
@@ -276,7 +276,7 @@ export class Connection {
         try {
           await this.withDeadline(deadline, () => this.workflowService.getSystemInfo({}));
         } catch (err) {
-          if (isServerErrorResponse(err)) {
+          if (isGrpcServiceError(err)) {
             // Ignore old servers
             if (err.code !== grpc.status.UNIMPLEMENTED) {
               throw new ServiceError('Failed to connect to Temporal server', { cause: err });

package/src/errors.ts

@@ -1,4 +1,4 @@
-import { ServerErrorResponse } from '@grpc/grpc-js';
+import { ServiceError as GrpcServiceError } from '@grpc/grpc-js';
 import { RetryState, TemporalFailure } from '@temporalio/common';
 
 /**
@@ -47,10 +47,11 @@ export class WorkflowContinuedAsNewError extends Error {
   }
 }
 
+export function isGrpcServiceError(err: unknown): err is GrpcServiceError {
+  return err instanceof Error && (err as any).details !== undefined && (err as any).metadata !== undefined;
+}
+
 /**
- * Type assertion helper, assertion is mostly empty because any additional
- * properties are optional.
+ * @deprecated Use `isGrpcServiceError` instead
  */
-export function isServerErrorResponse(err: unknown): err is ServerErrorResponse {
-  return err instanceof Error;
-}
+export const isServerErrorResponse = isGrpcServiceError;

package/src/helpers.ts

@@ -1,13 +1,15 @@
+import { ServiceError as GrpcServiceError } from '@grpc/grpc-js';
 import {
   LoadedDataConverter,
   mapFromPayloads,
+  NamespaceNotFoundError,
   searchAttributePayloadConverter,
   SearchAttributes,
 } from '@temporalio/common';
 import { Replace } from '@temporalio/common/lib/type-helpers';
 import { optionalTsToDate, tsToDate } from '@temporalio/common/lib/time';
 import { decodeMapFromPayloads } from '@temporalio/common/lib/internal-non-workflow/codec-helpers';
-import { temporal } from '@temporalio/proto';
+import { temporal, google } from '@temporalio/proto';
 import { RawWorkflowExecutionInfo, WorkflowExecutionInfo, WorkflowExecutionStatusName } from './types';
 
 function workflowStatusCodeToName(code: temporal.api.enums.v1.WorkflowExecutionStatus): WorkflowExecutionStatusName {
@@ -75,3 +77,36 @@ export async function executionInfoFromRaw<T>(
     raw: rawDataToEmbed,
   };
 }
+
+type ErrorDetailsName = `temporal.api.errordetails.v1.${keyof typeof temporal.api.errordetails.v1}`;
+
+/**
+ * If the error type can be determined based on embedded grpc error details,
+ * then rethrow the appropriate TypeScript error. Otherwise do nothing.
+ *
+ * This function should be used before falling back to generic error handling
+ * based on grpc error code. Very few error types are currently supported, but
+ * this function will be expanded over time as more server error types are added.
+ */
+export function rethrowKnownErrorTypes(err: GrpcServiceError): void {
+  // We really don't expect multiple error details, but this really is an array, so just in case...
+  for (const entry of getGrpcStatusDetails(err) ?? []) {
+    if (!entry.type_url || !entry.value) continue;
+    const type = entry.type_url.replace(/^type.googleapis.com\//, '') as ErrorDetailsName;
+
+    switch (type) {
+      case 'temporal.api.errordetails.v1.NamespaceNotFoundFailure': {
+        const { namespace } = temporal.api.errordetails.v1.NamespaceNotFoundFailure.decode(entry.value);
+        throw new NamespaceNotFoundError(namespace);
+      }
+    }
+  }
+}
+
+function getGrpcStatusDetails(err: GrpcServiceError): google.rpc.Status['details'] | undefined {
+  const statusBuffer = err.metadata.get('grpc-status-details-bin')?.[0];
+  if (!statusBuffer || typeof statusBuffer === 'string') {
+    return undefined;
+  }
+  return google.rpc.Status.decode(statusBuffer).details;
+}

package/src/index.ts

@@ -38,3 +38,14 @@ export * from './workflow-client';
 export * from './workflow-options';
 export * from './schedule-types';
 export * from './schedule-client';
+export * from './task-queue-client';
+export {
+  WorkerBuildIdVersionSets,
+  BuildIdVersionSet,
+  BuildIdOperation,
+  PromoteSetByBuildId,
+  PromoteBuildIdWithinSet,
+  MergeSets,
+  AddNewIdInNewDefaultSet,
+  AddNewCompatibleVersion,
+} from './build-id-types';

package/src/schedule-client.ts

@@ -11,7 +11,7 @@ import { temporal } from '@temporalio/proto';
 import { optionalDateToTs, optionalTsToDate, optionalTsToMs, tsToDate } from '@temporalio/common/lib/time';
 import { CreateScheduleInput, CreateScheduleOutput, ScheduleClientInterceptor } from './interceptors';
 import { WorkflowService } from './types';
-import { isServerErrorResponse, ServiceError } from './errors';
+import { isGrpcServiceError, ServiceError } from './errors';
 import {
   Backfill,
   CompiledScheduleUpdateOptions,
@@ -45,6 +45,7 @@ import {
   LoadedWithDefaults,
   WithDefaults,
 } from './base-client';
+import { rethrowKnownErrorTypes } from './helpers';
 
 /**
  * Handle to a single Schedule
@@ -263,7 +264,7 @@ export class ScheduleClient extends BaseClient {
       if (err.code === grpcStatus.ALREADY_EXISTS) {
         throw new ScheduleAlreadyRunning('Schedule already exists and is running', opts.scheduleId);
       }
-      this.rethrowGrpcError(err, opts.scheduleId, 'Failed to create schedule');
+      this.rethrowGrpcError(err, 'Failed to create schedule', opts.scheduleId);
     }
   }
 
@@ -279,7 +280,7 @@ export class ScheduleClient extends BaseClient {
         scheduleId,
       });
     } catch (err: any) {
-      this.rethrowGrpcError(err, scheduleId, 'Failed to describe schedule');
+      this.rethrowGrpcError(err, 'Failed to describe schedule', scheduleId);
     }
   }
 
@@ -291,21 +292,22 @@ export class ScheduleClient extends BaseClient {
     opts: CompiledScheduleUpdateOptions,
     header: Headers
   ): Promise<temporal.api.workflowservice.v1.IUpdateScheduleResponse> {
+    const req = {
+      namespace: this.options.namespace,
+      scheduleId,
+      schedule: {
+        spec: encodeScheduleSpec(opts.spec),
+        action: await encodeScheduleAction(this.dataConverter, opts.action, header),
+        policies: encodeSchedulePolicies(opts.policies),
+        state: encodeScheduleState(opts.state),
+      },
+      identity: this.options.identity,
+      requestId: uuid4(),
+    };
     try {
-      return await this.workflowService.updateSchedule({
-        namespace: this.options.namespace,
-        scheduleId,
-        schedule: {
-          spec: encodeScheduleSpec(opts.spec),
-          action: await encodeScheduleAction(this.dataConverter, opts.action, header),
-          policies: encodeSchedulePolicies(opts.policies),
-          state: encodeScheduleState(opts.state),
-        },
-        identity: this.options.identity,
-        requestId: uuid4(),
-      });
+      return await this.workflowService.updateSchedule(req);
     } catch (err: any) {
-      this.rethrowGrpcError(err, scheduleId, 'Failed to update schedule');
+      this.rethrowGrpcError(err, 'Failed to update schedule', scheduleId);
     }
   }
 
@@ -325,7 +327,7 @@ export class ScheduleClient extends BaseClient {
         patch,
       });
     } catch (err: any) {
-      this.rethrowGrpcError(err, scheduleId, 'Failed to patch schedule');
+      this.rethrowGrpcError(err, 'Failed to patch schedule', scheduleId);
     }
   }
 
@@ -342,7 +344,7 @@ export class ScheduleClient extends BaseClient {
         scheduleId,
       });
     } catch (err: any) {
-      this.rethrowGrpcError(err, scheduleId, 'Failed to delete schedule');
+      this.rethrowGrpcError(err, 'Failed to delete schedule', scheduleId);
     }
   }
 
@@ -365,20 +367,23 @@ export class ScheduleClient extends BaseClient {
   public async *list(options?: ListScheduleOptions): AsyncIterable<ScheduleSummary> {
     let nextPageToken: Uint8Array | undefined = undefined;
     for (;;) {
-      const response: temporal.api.workflowservice.v1.IListSchedulesResponse = await this.workflowService.listSchedules(
-        {
+      let response: temporal.api.workflowservice.v1.ListSchedulesResponse;
+      try {
+        response = await this.workflowService.listSchedules({
           nextPageToken,
           namespace: this.options.namespace,
           maximumPageSize: options?.pageSize,
-        }
-      );
+        });
+      } catch (e) {
+        this.rethrowGrpcError(e, 'Failed to list schedules', undefined);
+      }
 
       for (const raw of response.schedules ?? []) {
         yield <ScheduleSummary>{
           scheduleId: raw.scheduleId,
 
           spec: decodeScheduleSpec(raw.info?.spec ?? {}),
-          action: raw.info?.workflowType?.name && {
+          action: raw.info?.workflowType && {
             type: 'startWorkflow',
             workflowType: raw.info.workflowType.name,
           },
@@ -496,10 +501,12 @@ export class ScheduleClient extends BaseClient {
     };
   }
 
-  protected rethrowGrpcError(err: unknown, scheduleId: string, fallbackMessage: string): never {
-    if (isServerErrorResponse(err)) {
+  protected rethrowGrpcError(err: unknown, fallbackMessage: string, scheduleId?: string): never {
+    if (isGrpcServiceError(err)) {
+      rethrowKnownErrorTypes(err);
+
       if (err.code === grpcStatus.NOT_FOUND) {
-        throw new ScheduleNotFoundError(err.details ?? 'Schedule not found', scheduleId);
+        throw new ScheduleNotFoundError(err.details ?? 'Schedule not found', scheduleId ?? '');
       }
       if (
         err.code === grpcStatus.INVALID_ARGUMENT &&
@@ -507,9 +514,10 @@ export class ScheduleClient extends BaseClient {
       ) {
         throw new TypeError(err.message.replace(/^3 INVALID_ARGUMENT: Invalid schedule spec: /, ''));
       }
+
       throw new ServiceError(fallbackMessage, { cause: err });
     }
-    throw new ServiceError('Unexpected error while making gRPC request');
+    throw new ServiceError('Unexpected error while making gRPC request', { cause: err as Error });
   }
 }
 

package/src/schedule-helpers.ts

@@ -2,6 +2,7 @@ import Long from 'long'; // eslint-disable-line import/no-named-as-default
 import {
   compileRetryPolicy,
   decompileRetryPolicy,
+  extractWorkflowType,
   LoadedDataConverter,
   mapFromPayloads,
   mapToPayloads,
@@ -66,7 +67,7 @@ const [encodeMinute, decodeMinue] = makeCalendarSpecFieldCoders(
 
 const [encodeHour, decodeHour] = makeCalendarSpecFieldCoders(
   'hour',
-  (x: number) => (typeof x === 'number' && x >= 0 && x <= 59 ? x : undefined),
+  (x: number) => (typeof x === 'number' && x >= 0 && x <= 23 ? x : undefined),
   (x: number) => x,
   [{ start: 0, end: 0, step: 0 }], // default to 0
   [{ start: 0, end: 23, step: 1 }]
@@ -74,7 +75,7 @@ const [encodeHour, decodeHour] = makeCalendarSpecFieldCoders(
 
 const [encodeDayOfMonth, decodeDayOfMonth] = makeCalendarSpecFieldCoders(
   'dayOfMonth',
-  (x: number) => (typeof x === 'number' && x >= 0 && x <= 6 ? x : undefined),
+  (x: number) => (typeof x === 'number' && x >= 0 && x <= 31 ? x : undefined),
   (x: number) => x,
   [{ start: 1, end: 31, step: 1 }], // default to *
   [{ start: 1, end: 31, step: 1 }]
@@ -139,7 +140,7 @@ function makeCalendarSpecFieldCoders<Unit>(
         const value = encodeValueFn(item as Unit);
         if (value !== undefined) return { start: value, end: value, step: 1 };
       }
-      throw new Error(`Invalid CalendarSpec component for field ${fieldName}: '${item}' of type '${typeof item}'`);
+      throw new TypeError(`Invalid CalendarSpec component for field ${fieldName}: '${item}' of type '${typeof item}'`);
     });
   }
 
@@ -208,7 +209,7 @@ export function decodeOverlapPolicy(input?: temporal.api.enums.v1.ScheduleOverla
 
 export function compileScheduleOptions(options: ScheduleOptions): CompiledScheduleOptions {
   const workflowTypeOrFunc = options.action.workflowType;
-  const workflowType = typeof workflowTypeOrFunc === 'string' ? workflowTypeOrFunc : workflowTypeOrFunc.name;
+  const workflowType = extractWorkflowType(workflowTypeOrFunc);
   return {
     ...options,
     action: {
@@ -222,7 +223,7 @@ export function compileScheduleOptions(options: ScheduleOptions): CompiledSchedu
 
 export function compileUpdatedScheduleOptions(options: ScheduleUpdateOptions): CompiledScheduleUpdateOptions {
   const workflowTypeOrFunc = options.action.workflowType;
-  const workflowType = typeof workflowTypeOrFunc === 'string' ? workflowTypeOrFunc : workflowTypeOrFunc.name;
+  const workflowType = extractWorkflowType(workflowTypeOrFunc);
   return {
     ...options,
     action: {
@@ -349,7 +350,7 @@ export async function decodeScheduleAction(
       workflowTaskTimeout: optionalTsToMs(pb.startWorkflow.workflowTaskTimeout),
     };
   }
-  throw new Error('Unsupported schedule action');
+  throw new TypeError('Unsupported schedule action');
 }
 
 export function decodeSearchAttributes(
@@ -397,7 +398,7 @@ export function decodeScheduleRecentActions(
             firstExecutionRunId: executionResult.startWorkflowResult!.runId!,
           },
         };
-      } else throw new Error('Unsupported schedule action');
+      } else throw new TypeError('Unsupported schedule action');
 
       return {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion