@temporalio/common 1.11.2 → 1.11.4

package/src/type-helpers.ts

@@ -17,6 +17,84 @@ export function checkExtends<_Orig, _Copy extends _Orig>(): void {
 
 export type Replace<Base, New> = Omit<Base, keyof New> & New;
 
+// From https://github.com/sindresorhus/type-fest/blob/main/source/union-to-intersection.d.ts
+// MIT or CC0-1.0 — It is meant to be copied into your codebase rather than being used as a dependency.
+export type UnionToIntersection<Union> =
+  // `extends unknown` is always going to be the case and is used to convert the `Union` into a
+  // [distributive conditional type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+  (
+    Union extends unknown
+      ? // The union type is used as the only argument to a function since the union
+        // of function arguments is an intersection.
+        (distributedUnion: Union) => void
+      : // This won't happen.
+        never
+  ) extends // Infer the `Intersection` type since TypeScript represents the positional
+  // arguments of unions of functions as an intersection of the union.
+  (mergedIntersection: infer Intersection) => void
+    ? // The `& Union` is to allow indexing by the resulting type
+      Intersection & Union
+    : never;
+
+type IsEqual<A, B> = (<G>() => G extends A ? 1 : 2) extends <G>() => G extends B ? 1 : 2 ? true : false;
+
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+
+type IsNull<T> = [T] extends [null] ? true : false;
+
+type IsUnknown<T> = unknown extends T // `T` can be `unknown` or `any`
+  ? IsNull<T> extends false // `any` can be `null`, but `unknown` can't be
+    ? true
+    : false
+  : false;
+
+type ObjectValue<T, K> = K extends keyof T
+  ? T[K]
+  : ToString<K> extends keyof T
+    ? T[ToString<K>]
+    : K extends `${infer NumberK extends number}`
+      ? NumberK extends keyof T
+        ? T[NumberK]
+        : never
+      : never;
+
+type ToString<T> = T extends string | number ? `${T}` : never;
+
+type KeysOfUnion<ObjectType> = ObjectType extends unknown ? keyof ObjectType : never;
+
+type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
+
+type ExactObject<ParameterType, InputType> = {
+  [Key in keyof ParameterType]: Exact<ParameterType[Key], ObjectValue<InputType, Key>>;
+} & Record<Exclude<keyof InputType, KeysOfUnion<ParameterType>>, never>;
+
+export type Exact<ParameterType, InputType> =
+  // Before distributing, check if the two types are equal and if so, return the parameter type immediately
+  IsEqual<ParameterType, InputType> extends true
+    ? ParameterType
+    : // If the parameter is a primitive, return it as is immediately to avoid it being converted to a complex type
+      ParameterType extends Primitive
+      ? ParameterType
+      : // If the parameter is an unknown, return it as is immediately to avoid it being converted to a complex type
+        IsUnknown<ParameterType> extends true
+        ? unknown
+        : // If the parameter is a Function, return it as is because this type is not capable of handling function, leave it to TypeScript
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+          ParameterType extends Function
+          ? ParameterType
+          : // Convert union of array to array of union: A[] & B[] => (A & B)[]
+            ParameterType extends unknown[]
+            ? Array<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+            : // In TypeScript, Array is a subtype of ReadonlyArray, so always test Array before ReadonlyArray.
+              ParameterType extends readonly unknown[]
+              ? ReadonlyArray<Exact<ArrayElement<ParameterType>, ArrayElement<InputType>>>
+              : ExactObject<ParameterType, InputType>;
+// End of borrow from  https://github.com/sindresorhus/type-fest/blob/main/source/union-to-intersection.d.ts
+
+export type RemovePrefix<Prefix extends string, Keys extends string> = {
+  [k in Keys]: k extends `${Prefix}${infer Suffix}` ? Suffix : never;
+}[Keys];
+
 export function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
@@ -153,7 +231,7 @@ export function deepFreeze<T>(object: T): T {
     if (value && typeof value === 'object') {
       try {
         deepFreeze(value);
-      } catch (err) {
+      } catch (_err) {
         // This is okay, there are some typed arrays that cannot be frozen (encodingKeys)
       }
     } else if (typeof value === 'function') {

package/src/workflow-options.ts

@@ -2,60 +2,147 @@ import type { temporal } from '@temporalio/proto';
 import { SearchAttributes, Workflow } from './interfaces';
 import { RetryPolicy } from './retry-policy';
 import { Duration } from './time';
-import { checkExtends } from './type-helpers';
+import { makeProtoEnumConverters } from './internal-workflow';
 
-// Avoid importing the proto implementation to reduce workflow bundle size
-// Copied from temporal.api.enums.v1.WorkflowIdReusePolicy
 /**
+ * Defines what happens when trying to start a Workflow with the same ID as a *Closed* Workflow.
+ *
+ * See {@link WorkflowOptions.workflowIdConflictPolicy} for what happens when trying to start a
+ * Workflow with the same ID as a *Running* Workflow.
+ *
  * Concept: {@link https://docs.temporal.io/concepts/what-is-a-workflow-id-reuse-policy/ | Workflow Id Reuse Policy}
  *
- * Whether a Workflow can be started with a Workflow Id of a Closed Workflow.
+ * *Note: It is not possible to have two actively running Workflows with the same ID.*
  *
- * *Note: A Workflow can never be started with a Workflow Id of a Running Workflow.*
  */
-export enum WorkflowIdReusePolicy {
-  /**
-   * No need to use this.
-   *
-   * (If a `WorkflowIdReusePolicy` is set to this, or is not set at all, the default value will be used.)
-   */
-  WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED = 0,
-
+export const WorkflowIdReusePolicy = {
   /**
    * The Workflow can be started if the previous Workflow is in a Closed state.
    * @default
    */
-  WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE = 1,
+  ALLOW_DUPLICATE: 'ALLOW_DUPLICATE',
 
   /**
    * The Workflow can be started if the previous Workflow is in a Closed state that is not Completed.
    */
-  WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY = 2,
+  ALLOW_DUPLICATE_FAILED_ONLY: 'ALLOW_DUPLICATE_FAILED_ONLY',
 
   /**
    * The Workflow cannot be started.
    */
-  WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE = 3,
+  REJECT_DUPLICATE: 'REJECT_DUPLICATE',
 
   /**
-   * Terminate the current workflow if one is already running.
+   * Terminate the current Workflow if one is already running; otherwise allow reusing the Workflow ID.
+   *
+   * @deprecated Use {@link WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE} instead, and
+   *             set `WorkflowOptions.workflowIdConflictPolicy` to
+   *             {@link WorkflowIdConflictPolicy.WORKFLOW_ID_CONFLICT_POLICY_TERMINATE_EXISTING}.
+   *             When using this option, `WorkflowOptions.workflowIdConflictPolicy` must be left unspecified.
    */
-  WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING = 4,
-}
+  TERMINATE_IF_RUNNING: 'TERMINATE_IF_RUNNING', // eslint-disable-line deprecation/deprecation
+
+  /// Anything below this line has been deprecated
+
+  /**
+   * No need to use this. If a `WorkflowIdReusePolicy` is set to this, or is not set at all, the default value will be used.
+   *
+   * @deprecated Either leave property `undefined`, or use {@link ALLOW_DUPLICATE} instead.
+   */
+  WORKFLOW_ID_REUSE_POLICY_UNSPECIFIED: undefined, // eslint-disable-line deprecation/deprecation
+
+  /** @deprecated Use {@link ALLOW_DUPLICATE} instead. */
+  WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE: 'ALLOW_DUPLICATE', // eslint-disable-line deprecation/deprecation
+
+  /** @deprecated Use {@link ALLOW_DUPLICATE_FAILED_ONLY} instead. */
+  WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY: 'ALLOW_DUPLICATE_FAILED_ONLY', // eslint-disable-line deprecation/deprecation
+
+  /** @deprecated Use {@link REJECT_DUPLICATE} instead. */
+  WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE: 'REJECT_DUPLICATE', // eslint-disable-line deprecation/deprecation
+
+  /** @deprecated Use {@link TERMINATE_IF_RUNNING} instead. */
+  WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING: 'TERMINATE_IF_RUNNING', // eslint-disable-line deprecation/deprecation
+} as const;
+export type WorkflowIdReusePolicy = (typeof WorkflowIdReusePolicy)[keyof typeof WorkflowIdReusePolicy];
+
+export const [encodeWorkflowIdReusePolicy, decodeWorkflowIdReusePolicy] = makeProtoEnumConverters<
+  temporal.api.enums.v1.WorkflowIdReusePolicy,
+  typeof temporal.api.enums.v1.WorkflowIdReusePolicy,
+  keyof typeof temporal.api.enums.v1.WorkflowIdReusePolicy,
+  typeof WorkflowIdReusePolicy,
+  'WORKFLOW_ID_REUSE_POLICY_'
+>(
+  {
+    [WorkflowIdReusePolicy.ALLOW_DUPLICATE]: 1,
+    [WorkflowIdReusePolicy.ALLOW_DUPLICATE_FAILED_ONLY]: 2,
+    [WorkflowIdReusePolicy.REJECT_DUPLICATE]: 3,
+    [WorkflowIdReusePolicy.TERMINATE_IF_RUNNING]: 4, // eslint-disable-line deprecation/deprecation
+    UNSPECIFIED: 0,
+  } as const,
+  'WORKFLOW_ID_REUSE_POLICY_'
+);
+
+/**
+ * Defines what happens when trying to start a Workflow with the same ID as a *Running* Workflow.
+ *
+ * See {@link WorkflowOptions.workflowIdReusePolicy} for what happens when trying to start a Workflow
+ * with the same ID as a *Closed* Workflow.
+ *
+ * *Note: It is never possible to have two _actively running_ Workflows with the same ID.*
+ */
+export type WorkflowIdConflictPolicy = (typeof WorkflowIdConflictPolicy)[keyof typeof WorkflowIdConflictPolicy];
+export const WorkflowIdConflictPolicy = {
+  /**
+   * Do not start a new Workflow. Instead raise a `WorkflowExecutionAlreadyStartedError`.
+   */
+  FAIL: 'FAIL',
 
-checkExtends<temporal.api.enums.v1.WorkflowIdReusePolicy, WorkflowIdReusePolicy>();
-checkExtends<WorkflowIdReusePolicy, temporal.api.enums.v1.WorkflowIdReusePolicy>();
+  /**
+   * Do not start a new Workflow. Instead return a Workflow Handle for the already Running Workflow.
+   */
+  USE_EXISTING: 'USE_EXISTING',
+
+  /**
+   * Start a new Workflow, terminating the current workflow if one is already running.
+   */
+  TERMINATE_EXISTING: 'TERMINATE_EXISTING',
+} as const;
+
+export const [encodeWorkflowIdConflictPolicy, decodeWorkflowIdConflictPolicy] = makeProtoEnumConverters<
+  temporal.api.enums.v1.WorkflowIdConflictPolicy,
+  typeof temporal.api.enums.v1.WorkflowIdConflictPolicy,
+  keyof typeof temporal.api.enums.v1.WorkflowIdConflictPolicy,
+  typeof WorkflowIdConflictPolicy,
+  'WORKFLOW_ID_CONFLICT_POLICY_'
+>(
+  {
+    [WorkflowIdConflictPolicy.FAIL]: 1,
+    [WorkflowIdConflictPolicy.USE_EXISTING]: 2,
+    [WorkflowIdConflictPolicy.TERMINATE_EXISTING]: 3,
+    UNSPECIFIED: 0,
+  } as const,
+  'WORKFLOW_ID_CONFLICT_POLICY_'
+);
 
 export interface BaseWorkflowOptions {
   /**
-   * Whether a Workflow can be started with a Workflow Id of a Closed Workflow.
+   * Defines what happens when trying to start a Workflow with the same ID as a *Closed* Workflow.
    *
-   * *Note: A Workflow can never be started with a Workflow Id of a Running Workflow.*
+   * *Note: It is not possible to have two actively running Workflows with the same ID.*
    *
    * @default {@link WorkflowIdReusePolicy.WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE}
    */
   workflowIdReusePolicy?: WorkflowIdReusePolicy;
 
+  /**
+   * Defines what happens when trying to start a Workflow with the same ID as a *Running* Workflow.
+   *
+   * *Note: It is not possible to have two actively running Workflows with the same ID.*
+   *
+   * @default {@link WorkflowIdConflictPolicy.WORKFLOW_ID_CONFLICT_POLICY_UNSPECIFIED}
+   */
+  workflowIdConflictPolicy?: WorkflowIdConflictPolicy;
+
   /**
    * Controls how a Workflow Execution is retried.
    *