@temporalio/client 1.4.3 → 1.5.0

package/src/interceptors.ts

@@ -6,6 +6,7 @@
 
 import { Headers, Next } from '@temporalio/common';
 import { temporal } from '@temporalio/proto';
+import { CompiledScheduleOptions } from './schedule-types';
 import {
   DescribeWorkflowExecutionResponse,
   RequestCancelWorkflowExecutionResponse,
@@ -16,7 +17,7 @@ import { CompiledWorkflowOptions } from './workflow-options';
 
 export { Next, Headers };
 
-/** Input for WorkflowClientCallsInterceptor.start */
+/** Input for WorkflowClientInterceptor.start */
 export interface WorkflowStartInput {
   /** Name of Workflow to start */
   readonly workflowType: string;
@@ -24,7 +25,7 @@ export interface WorkflowStartInput {
   readonly options: CompiledWorkflowOptions;
 }
 
-/** Input for WorkflowClientCallsInterceptor.signal */
+/** Input for WorkflowClientInterceptor.signal */
 export interface WorkflowSignalInput {
   readonly signalName: string;
   readonly args: unknown[];
@@ -32,7 +33,7 @@ export interface WorkflowSignalInput {
   readonly headers: Headers;
 }
 
-/** Input for WorkflowClientCallsInterceptor.signalWithStart */
+/** Input for WorkflowClientInterceptor.signalWithStart */
 export interface WorkflowSignalWithStartInput {
   readonly workflowType: string;
   readonly signalName: string;
@@ -41,7 +42,7 @@ export interface WorkflowSignalWithStartInput {
   readonly options: CompiledWorkflowOptions;
 }
 
-/** Input for WorkflowClientCallsInterceptor.query */
+/** Input for WorkflowClientInterceptor.query */
 export interface WorkflowQueryInput {
   readonly queryType: string;
   readonly args: unknown[];
@@ -50,7 +51,7 @@ export interface WorkflowQueryInput {
   readonly headers: Headers;
 }
 
-/** Input for WorkflowClientCallsInterceptor.terminate */
+/** Input for WorkflowClientInterceptor.terminate */
 export interface WorkflowTerminateInput {
   readonly workflowExecution: WorkflowExecution;
   readonly reason?: string;
@@ -58,13 +59,13 @@ export interface WorkflowTerminateInput {
   readonly firstExecutionRunId?: string;
 }
 
-/** Input for WorkflowClientCallsInterceptor.cancel */
+/** Input for WorkflowClientInterceptor.cancel */
 export interface WorkflowCancelInput {
   readonly workflowExecution: WorkflowExecution;
   readonly firstExecutionRunId?: string;
 }
 
-/** Input for WorkflowClientCallsInterceptor.describe */
+/** Input for WorkflowClientInterceptor.describe */
 export interface WorkflowDescribeInput {
   readonly workflowExecution: WorkflowExecution;
 }
@@ -72,7 +73,7 @@ export interface WorkflowDescribeInput {
 /**
  * Implement any of these methods to intercept WorkflowClient outbound calls
  */
-export interface WorkflowClientCallsInterceptor {
+export interface WorkflowClientInterceptor {
   /**
    * Intercept a service call to startWorkflowExecution
    *
@@ -112,6 +113,10 @@ export interface WorkflowClientCallsInterceptor {
   describe?: (input: WorkflowDescribeInput, next: Next<this, 'describe'>) => Promise<DescribeWorkflowExecutionResponse>;
 }
 
+/** @deprecated: Use WorkflowClientInterceptor instead */
+export type WorkflowClientCallsInterceptor = WorkflowClientInterceptor;
+
+/** @deprecated */
 export interface WorkflowClientCallsInterceptorFactoryInput {
   workflowId: string;
   runId?: string;
@@ -119,23 +124,62 @@ export interface WorkflowClientCallsInterceptorFactoryInput {
 
 /**
  * A function that takes {@link CompiledWorkflowOptions} and returns an interceptor
+ *
+ * @deprecated: Please define interceptors directly, without factory
  */
 export interface WorkflowClientCallsInterceptorFactory {
+  // eslint-disable-next-line deprecation/deprecation
   (input: WorkflowClientCallsInterceptorFactoryInput): WorkflowClientCallsInterceptor;
 }
 
 /**
  * A mapping of interceptor type of a list of factory functions
+ *
+ * @deprecated: Please define interceptors directly, without factory
  */
 export interface WorkflowClientInterceptors {
+  /** @deprecated */
+  // eslint-disable-next-line deprecation/deprecation
   calls?: WorkflowClientCallsInterceptorFactory[];
 }
 
+/**
+ * Implement any of these methods to intercept ScheduleClient outbound calls
+ *
+ * @experimental
+ */
+export interface ScheduleClientInterceptor {
+  /**
+   * Intercept a service call to CreateSchedule
+   */
+  create?: (input: CreateScheduleInput, next: Next<this, 'create'>) => Promise<CreateScheduleOutput>;
+}
+
+/**
+ * Input for {@link ScheduleClientInterceptor.create}
+ *
+ * @experimental
+ */
+export interface CreateScheduleInput {
+  readonly headers: Headers;
+  readonly options: CompiledScheduleOptions;
+}
+
+export type CreateScheduleOutput = {
+  readonly conflictToken: Uint8Array;
+};
+
 /**
  * Interceptors for any high-level SDK client.
  *
- * NOTE: Currently only for {@link WorkflowClient}. More will be added later as needed.
+ * NOTE: Currently only for {@link WorkflowClient} and {@link ScheduleClient}. More will be added later as needed.
  */
 export interface ClientInterceptors {
-  workflow?: WorkflowClientInterceptors;
+  // eslint-disable-next-line deprecation/deprecation
+  workflow?: WorkflowClientInterceptors | WorkflowClientInterceptor[];
+
+  /**
+   * @experimental
+   */
+  schedule?: ScheduleClientInterceptor[];
 }

package/src/iterators-utils.ts

@@ -0,0 +1,116 @@
+import { EventEmitter, on, once } from 'node:events';
+import { AbortController } from 'abort-controller';
+
+export interface MapAsyncOptions {
+  /**
+   * How many items to map concurrently. If set to less than 2 (or not set), then items are not mapped concurrently.
+   *
+   * When items are mapped concurrently, mapped items are returned by the resulting iterator in the order they complete
+   * mapping, not the order in which the corresponding source items were obtained from the source iterator.
+   *
+   * @default 1 (ie. items are not mapped concurrently)
+   */
+  concurrency?: number;
+
+  /**
+   * Maximum number of mapped items to keep in buffer, ready for consumption.
+   *
+   * Ignored unless `concurrency > 1`. No limit applies if set to `undefined`.
+   *
+   * @default unlimited
+   */
+  bufferLimit?: number | undefined;
+}
+
+function toAsyncIterator<A>(iterable: AsyncIterable<A>): AsyncIterator<A> {
+  return iterable[Symbol.asyncIterator]();
+}
+
+/**
+ * Return an async iterable that transforms items from a source iterable by mapping each item
+ * through a mapping function.
+ *
+ * If `concurrency > 1`, then up to `concurrency` items may be mapped concurrently. In that case,
+ * items are returned by the resulting iterator in the order they complete processing, not the order
+ * in which the corresponding source items were obtained from the source iterator.
+ *
+ * @param source the source async iterable
+ * @param mapFn a mapping function to apply on every item of the source iterable
+ */
+export async function* mapAsyncIterable<A, B>(
+  source: AsyncIterable<A>,
+  mapFn: (val: A) => Promise<B>,
+  options?: MapAsyncOptions
+): AsyncIterable<B> {
+  const { concurrency, bufferLimit } = options ?? {};
+
+  if (!concurrency || concurrency < 2) {
+    for await (const x of source) {
+      yield mapFn(x);
+    }
+    return;
+  }
+
+  const sourceIterator = toAsyncIterator(source);
+
+  const emitter = new EventEmitter();
+  const controller = new AbortController();
+  const emitterEventsIterable: AsyncIterable<[B]> = on(emitter, 'result', { signal: controller.signal });
+  const emitterError: Promise<unknown[]> = once(emitter, 'error');
+
+  const bufferLimitSemaphore =
+    typeof bufferLimit === 'number'
+      ? (() => {
+          const releaseEvents: AsyncIterator<void> = toAsyncIterator(
+            on(emitter, 'released', { signal: controller.signal })
+          );
+          let value = bufferLimit + concurrency;
+
+          return {
+            acquire: async () => {
+              while (value <= 0) {
+                await Promise.race([releaseEvents.next(), emitterError]);
+              }
+              value--;
+            },
+            release: () => {
+              value++;
+              emitter.emit('released');
+            },
+          };
+        })()
+      : undefined;
+
+  const mapper = async () => {
+    for (;;) {
+      await bufferLimitSemaphore?.acquire();
+      const val = await Promise.race([sourceIterator.next(), emitterError]);
+
+      if (Array.isArray(val)) return;
+      if ((val as IteratorResult<[B]>)?.done) return;
+
+      emitter.emit('result', await mapFn(val.value));
+    }
+  };
+
+  const mappers = Array(concurrency)
+    .fill(mapper)
+    .map((f: typeof mapper) => f());
+
+  Promise.all(mappers).then(
+    () => controller.abort(),
+    (err) => emitter.emit('error', err)
+  );
+
+  try {
+    for await (const [res] of emitterEventsIterable) {
+      bufferLimitSemaphore?.release();
+      yield res;
+    }
+  } catch (err: unknown) {
+    if ((err as Error)?.name === 'AbortError') {
+      return;
+    }
+    throw err;
+  }
+}