nestjs-temporal-core 3.2.6 → 3.2.8

package/README.md

@@ -4,11 +4,11 @@
 
 A comprehensive NestJS integration framework for Temporal.io that provides enterprise-ready workflow orchestration with automatic discovery, declarative decorators, and robust monitoring capabilities.
 
-![Statements](https://img.shields.io/badge/statements-99.9%25-brightgreen.svg?style=flat)
-![Branches](https://img.shields.io/badge/branches-95.26%25-brightgreen.svg?style=flat)
-![Functions](https://img.shields.io/badge/functions-100%25-brightgreen.svg?style=flat)
-![Lines](https://img.shields.io/badge/lines-100%25-brightgreen.svg?style=flat)
-[![Coverage](https://codecov.io/gh/harsh-simform/nestjs-temporal-core/graph/badge.svg)](https://codecov.io/gh/harsh-simform/nestjs-temporal-core)
+![Statements](https://img.shields.io/badge/statements-99.62%25-brightgreen.svg?style=flat)
+![Branches](https://img.shields.io/badge/branches-94.26%25-brightgreen.svg?style=flat)
+![Functions](https://img.shields.io/badge/functions-98.01%25-brightgreen.svg?style=flat)
+![Lines](https://img.shields.io/badge/lines-99.75%25-brightgreen.svg?style=flat)
+[![codecov](https://codecov.io/gh/harsh-simform/nestjs-temporal-core/branch/main/graph/badge.svg?token=BYSE45L6DI)](https://codecov.io/gh/harsh-simform/nestjs-temporal-core)
 
 [Documentation](https://harsh-simform.github.io/nestjs-temporal-core/) • [NPM](https://www.npmjs.com/package/nestjs-temporal-core) • [GitHub](https://github.com/harsh-simform/nestjs-temporal-core) • [Example Project](https://github.com/harsh-simform/nestjs-temporal-core-example)
 
@@ -32,6 +32,8 @@ A comprehensive NestJS integration framework for Temporal.io that provides enter
   - [Activities](#activities)
   - [Workflows](#workflows)
   - [Signals and Queries](#signals-and-queries)
+  - [Typed Workflow Proxy](#typed-workflow-proxy)
+  - [Signal-with-Start](#signal-with-start)
 - [API Reference](#api-reference)
 - [Examples](#examples)
 - [Advanced Usage](#advanced-usage)
@@ -66,6 +68,8 @@ NestJS Temporal Core bridges NestJS's powerful dependency injection system with
 - **Automatic Discovery** - Runtime discovery and registration of activities with zero configuration
 - **Schedule Management** - Programmatic schedule creation, updates, and monitoring
 - **Health Monitoring** - Built-in health checks and comprehensive status reporting
+- **Typed Workflow Proxy** - Generic `IWorkflowProxy<T>` that infers start args, signal args, and query return types from your workflow function signature
+- **Signal-with-Start** - Atomic "ensure running + signal" on both the low-level client service and the high-level `TemporalService`
 
 ### Enterprise Features
 
@@ -842,6 +846,234 @@ export class OrderService {
 
 [🔝 Back to top](#table-of-contents)
 
+### Typed Workflow Proxy
+
+The typed workflow proxy gives you end-to-end type safety when interacting with a specific workflow. Instead of passing workflow names and args as strings/`unknown[]`, you get a generic `IWorkflowProxy<T>` where `T` is your workflow function type — all method signatures are inferred from `T`.
+
+**What it solves:**
+
+```typescript
+// Before: string names, unknown args, manual casts on query results
+const handle = await this.temporal.startWorkflow('orderWorkflow', [orderId, customerId]);
+const status = await this.temporal.queryWorkflow<OrderStatus>(workflowId, 'getStatus');
+```
+
+```typescript
+// After: fully typed against the workflow signature
+const handle = await this.orderProxy.start([orderId, customerId]);   // args typed as Parameters<typeof orderWorkflow>
+const status = await this.orderProxy.query(workflowId, statusQuery); // return type inferred from QueryDefinition
+```
+
+If you rename a workflow parameter or change its return type, every call site becomes a compile error until fixed.
+
+#### 1. Define signal/query definitions in your workflow file
+
+```typescript
+// workflows/order.workflow.ts
+import { defineSignal, defineQuery, setHandler, condition } from '@temporalio/workflow';
+
+export interface OrderStatus {
+  orderId: string;
+  state: 'pending' | 'approved' | 'shipped' | 'cancelled';
+}
+
+export const approveSignal = defineSignal<[string]>('approve');             // signal takes one string arg
+export const cancelSignal = defineSignal<[string]>('cancel');
+export const statusQuery = defineQuery<OrderStatus>('getStatus');           // query returns OrderStatus
+
+export async function orderWorkflow(orderId: string, customerId: number): Promise<OrderStatus> {
+  let status: OrderStatus = { orderId, state: 'pending' };
+
+  setHandler(approveSignal, (approver) => {
+    status = { ...status, state: 'approved' };
+  });
+  setHandler(cancelSignal, (reason) => {
+    status = { ...status, state: 'cancelled' };
+  });
+  setHandler(statusQuery, () => status);
+
+  await condition(() => status.state !== 'pending');
+  return status;
+}
+```
+
+#### 2. Register a typed proxy as a NestJS provider
+
+```typescript
+// order.module.ts
+import { Module } from '@nestjs/common';
+import { createWorkflowToken, createWorkflowProvider } from 'nestjs-temporal-core';
+import { orderWorkflow } from './workflows/order.workflow';
+import { OrderService } from './order.service';
+
+export const ORDER_WORKFLOW = createWorkflowToken('orderWorkflow');
+
+@Module({
+  providers: [
+    OrderService,
+    createWorkflowProvider<typeof orderWorkflow>(ORDER_WORKFLOW, {
+      workflowType: 'orderWorkflow',
+      taskQueue: 'orders',
+    }),
+  ],
+  exports: [ORDER_WORKFLOW],
+})
+export class OrderModule {}
+```
+
+#### 3. Inject and use — fully typed
+
+```typescript
+// order.service.ts
+import { Injectable, Inject } from '@nestjs/common';
+import { IWorkflowProxy } from 'nestjs-temporal-core';
+import {
+  orderWorkflow,
+  approveSignal,
+  cancelSignal,
+  statusQuery,
+  OrderStatus,
+} from './workflows/order.workflow';
+import { ORDER_WORKFLOW } from './order.module';
+
+@Injectable()
+export class OrderService {
+  constructor(
+    @Inject(ORDER_WORKFLOW)
+    private readonly orderProxy: IWorkflowProxy<typeof orderWorkflow>,
+  ) {}
+
+  async createOrder(orderId: string, customerId: number) {
+    // start() args are typed as Parameters<typeof orderWorkflow> = [string, number]
+    const handle = await this.orderProxy.start([orderId, customerId], {
+      workflowId: `order-${orderId}`,
+    });
+    return { workflowId: handle.workflowId };
+  }
+
+  async approve(workflowId: string, approver: string) {
+    // signal() infers TArgs from approveSignal — passing a number here is a compile error
+    await this.orderProxy.signal(workflowId, approveSignal, approver);
+  }
+
+  async getStatus(workflowId: string): Promise<OrderStatus> {
+    // query() return type is inferred from statusQuery
+    return this.orderProxy.query(workflowId, statusQuery);
+  }
+
+  async waitForCompletion(workflowId: string): Promise<OrderStatus> {
+    const handle = await this.orderProxy.getHandle(workflowId);
+    // handle.result() is Promise<OrderStatus>, not Promise<unknown>
+    return handle.result();
+  }
+
+  async cancelOrder(orderId: string, reason: string) {
+    // signalWithStart: atomically starts the workflow and signals it
+    await this.orderProxy.signalWithStart(
+      cancelSignal,
+      [reason],                  // signal args — typed
+      [orderId, 0],              // workflow args — typed as Parameters<typeof orderWorkflow>
+      { workflowId: `order-${orderId}` },
+    );
+  }
+}
+```
+
+#### Alternative: use `WorkflowProxyFactory` directly
+
+If you don't want a token-bound provider, inject the factory and create proxies on demand:
+
+```typescript
+import { Injectable } from '@nestjs/common';
+import { WorkflowProxyFactory, IWorkflowProxy } from 'nestjs-temporal-core';
+import { orderWorkflow } from './workflows/order.workflow';
+
+@Injectable()
+export class OrderService {
+  private readonly orderProxy: IWorkflowProxy<typeof orderWorkflow>;
+
+  constructor(factory: WorkflowProxyFactory) {
+    this.orderProxy = factory.createProxy<typeof orderWorkflow>({
+      workflowType: 'orderWorkflow',
+      taskQueue: 'orders',
+    });
+  }
+}
+```
+
+`WorkflowProxyFactory` is registered globally by `TemporalModule`, so no imports are needed in feature modules.
+
+#### Proxy method reference
+
+| Method | Purpose | Typing |
+|---|---|---|
+| `start(args, options?)` | Start a new workflow execution | `args` typed as `Parameters<T>`; returns `WorkflowHandleWithMetadata<T>` |
+| `getHandle(workflowId, runId?)` | Get a handle to an existing execution | Returns `WorkflowHandle<T>`; `result()` returns `Promise<WorkflowResultType<T>>` |
+| `signal(workflowId, signalDef, ...args)` | Send a typed signal | `args` typed from `SignalDefinition<TArgs>` |
+| `signalByName(workflowId, signalName, args?)` | Send a signal by string name | Fallback when no `SignalDefinition` is available |
+| `query(workflowId, queryDef, ...args)` | Query with a typed definition | Return type inferred from `QueryDefinition<TResult, TArgs>` |
+| `queryByName<TResult>(workflowId, queryName, args?)` | Query by string name | Caller specifies `TResult` |
+| `signalWithStart(signalDef, signalArgs, workflowArgs, options?)` | Atomic start + signal | Both arg lists fully typed |
+
+[🔝 Back to top](#table-of-contents)
+
+### Signal-with-Start
+
+`signalWithStart` atomically starts a workflow and sends it a signal in one operation. If the workflow is already running, only the signal is delivered — no duplicate start, no race condition.
+
+Use it for **idempotent "ensure running + signal"** patterns, e.g. a cart that should be started on the first item-add and signaled on every subsequent one.
+
+#### Via the typed proxy (recommended)
+
+```typescript
+// in workflows/cart.workflow.ts:
+// export const addItemSignal = defineSignal<[CartItem]>('addItem');
+// export async function cartWorkflow(userId: string) { ... }
+
+await this.cartProxy.signalWithStart(
+  addItemSignal,
+  [{ sku: 'SKU-123', qty: 2 }],   // signal args — typed from SignalDefinition
+  [userId],                        // workflow args — typed as Parameters<typeof cartWorkflow>
+  { workflowId: `cart-${userId}`, taskQueue: 'carts' },
+);
+```
+
+#### Via `TemporalService` (structured result)
+
+```typescript
+const result = await this.temporal.signalWithStart(
+  'cartWorkflow',
+  'addItem',
+  [{ sku: 'SKU-123', qty: 2 }],
+  [userId],
+  { workflowId: `cart-${userId}`, taskQueue: 'carts' },
+);
+
+if (result.success) {
+  this.logger.log(`Signal '${result.signalName}' delivered to ${result.workflowId}`);
+}
+```
+
+#### Via `TemporalClientService` (raw handle)
+
+```typescript
+const handle = await this.clientService.signalWithStart(
+  'orderWorkflow',
+  'approve',
+  ['manager-approval'],
+  [orderId, customerId],
+  {
+    workflowId: `order-${orderId}`,
+    taskQueue: 'orders',
+    workflowIdReusePolicy: 'ALLOW_DUPLICATE',
+    workflowExecutionTimeout: '1h',
+    memo: { source: 'api' },
+  },
+);
+```
+
+[🔝 Back to top](#table-of-contents)
+
 ## API Reference
 
 For detailed API documentation, visit the [Full API Documentation](https://harsh-simform.github.io/nestjs-temporal-core/).
@@ -853,6 +1085,7 @@ The main unified service providing access to all Temporal functionality. See the
 Key methods:
 - `startWorkflow()` - Start a workflow execution
 - `signalWorkflow()` - Send a signal to a running workflow
+- `signalWithStart()` - Atomically start a workflow and send it a signal (see [Signal-with-Start](#signal-with-start))
 - `queryWorkflow()` - Query a running workflow
 - `getWorkflowHandle()` - Get a workflow handle to interact with it
 - `terminateWorkflow()` - Terminate a workflow execution
@@ -862,6 +1095,17 @@ Key methods:
 - `listSchedules()` - List all schedules
 - `deleteSchedule()` - Delete a schedule
 
+### WorkflowProxyFactory
+
+Creates typed `IWorkflowProxy<T>` instances. Registered globally by `TemporalModule`. See [Typed Workflow Proxy](#typed-workflow-proxy) for the full pattern.
+
+- `createProxy<T>(config)` - Create a typed proxy for a workflow function type `T`
+
+### Proxy provider helpers
+
+- `createWorkflowToken(workflowType)` - Generate a unique NestJS injection token for a workflow proxy
+- `createWorkflowProvider<T>(token, config)` - Build a `FactoryProvider` that resolves to `IWorkflowProxy<T>`
+
 [🔝 Back to top](#table-of-contents)
 
 ## Examples
@@ -1313,6 +1557,60 @@ const result = await temporal.registerWorker({
 });
 ```
 
+### Migrating to v3.3.0 (Typed Workflow Proxy + Schedule fixes)
+
+This release is **backward-compatible** — existing code continues to compile and run. The headline additions are a typed workflow proxy, `signalWithStart` on both service layers, and correctness fixes for a few schedule fields that were previously silently ignored.
+
+#### No changes required
+
+Every type that was previously exported is still exported with the same name. Old field shapes continue to compile:
+
+- `spec.timezones?: string[]` on `ScheduleSpec` (deprecated — prefer SDK `timezone` singular, automatically normalized at runtime)
+- `action.retryPolicy?` on schedule actions (deprecated — prefer SDK `retry`, automatically forwarded)
+- `searchAttributes?: Record<string, unknown>` on `ScheduleCreationOptions`
+- `enableSDKTracing?` / `enableOpenTelemetry?` on `WorkerCreateOptions` (deprecated no-ops — had no effect in prior versions either)
+
+#### Runtime behavior fixes
+
+Three schedule fields were previously declared in the API but silently dropped by the SDK because of wrong field names or wrong shapes. They now work as the field name promises:
+
+| Field | Before v3.3.0 | After v3.3.0 |
+|---|---|---|
+| `spec.timezone` on a schedule | Written to `spec.timeZone` (wrong casing) — SDK ignored it, schedules always ran in UTC | Routed to SDK's `timezone` — schedule honors the zone |
+| `description` on `createSchedule()` | Passed as a top-level field SDK ignored | Flows to `state.note` |
+| `searchAttributes` on `createSchedule()` | Cast to `typedSearchAttributes` with the wrong shape | Routed to the correct `searchAttributes` SDK field |
+
+**Action**: if you had set `timezone` on a `@Scheduled` or `createSchedule()` call and configured your schedule times assuming UTC (because the timezone was being ignored), double-check your schedule timing after upgrade — the timezone will now actually apply.
+
+`limitedActions` on `createSchedule()` remains a no-op for backward compatibility; set `state.remainingActions` directly via the SDK if you need that behavior.
+
+#### New APIs in v3.3.0
+
+```typescript
+import {
+  IWorkflowProxy,
+  WorkflowProxyFactory,
+  createWorkflowToken,
+  createWorkflowProvider,
+} from 'nestjs-temporal-core';
+
+// Typed proxy — see "Typed Workflow Proxy" section for the full pattern
+const ORDER_WORKFLOW = createWorkflowToken('orderWorkflow');
+const provider = createWorkflowProvider<typeof orderWorkflow>(ORDER_WORKFLOW, {
+  workflowType: 'orderWorkflow',
+  taskQueue: 'orders',
+});
+
+// Atomic start + signal — see "Signal-with-Start" section
+await temporal.signalWithStart(
+  'cartWorkflow',
+  'addItem',
+  [{ sku: 'SKU-123', qty: 2 }],
+  [userId],
+  { workflowId: `cart-${userId}`, taskQueue: 'carts' },
+);
+```
+
 [🔝 Back to top](#table-of-contents)
 
 ## Requirements

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { TemporalWorkerManagerService } from './services/temporal-worker.service
 export { TemporalDiscoveryService } from './services/temporal-discovery.service';
 export { TemporalMetadataAccessor } from './services/temporal-metadata.service';
 export { TemporalScheduleService } from './services/temporal-schedule.service';
+export { WorkflowProxyFactory, IWorkflowProxy, WorkflowProxy } from './workflow-proxy';
 export * from './utils';
 export * from './interfaces';
 export { DEFAULT_NAMESPACE, DEFAULT_TASK_QUEUE, DEFAULT_CONNECTION_TIMEOUT_MS, TEMPORAL_ACTIVITY, TEMPORAL_ACTIVITY_METHOD, TEMPORAL_SIGNAL_METHOD, TEMPORAL_QUERY_METHOD, WORKFLOW_PARAMS_METADATA, TEMPORAL_CLIENT, TEMPORAL_MODULE_OPTIONS, TEMPORAL_CONNECTION, TIMEOUTS, RETRY_POLICIES, } from './constants';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RETRY_POLICIES = exports.TIMEOUTS = exports.TEMPORAL_CONNECTION = exports.TEMPORAL_MODULE_OPTIONS = exports.TEMPORAL_CLIENT = exports.WORKFLOW_PARAMS_METADATA = exports.TEMPORAL_QUERY_METHOD = exports.TEMPORAL_SIGNAL_METHOD = exports.TEMPORAL_ACTIVITY_METHOD = exports.TEMPORAL_ACTIVITY = exports.DEFAULT_CONNECTION_TIMEOUT_MS = exports.DEFAULT_TASK_QUEUE = exports.DEFAULT_NAMESPACE = exports.TemporalScheduleService = exports.TemporalMetadataAccessor = exports.TemporalDiscoveryService = exports.TemporalWorkerManagerService = exports.TemporalClientService = exports.TemporalService = exports.TemporalHealthController = exports.TemporalHealthModule = exports.TemporalModule = void 0;
+exports.RETRY_POLICIES = exports.TIMEOUTS = exports.TEMPORAL_CONNECTION = exports.TEMPORAL_MODULE_OPTIONS = exports.TEMPORAL_CLIENT = exports.WORKFLOW_PARAMS_METADATA = exports.TEMPORAL_QUERY_METHOD = exports.TEMPORAL_SIGNAL_METHOD = exports.TEMPORAL_ACTIVITY_METHOD = exports.TEMPORAL_ACTIVITY = exports.DEFAULT_CONNECTION_TIMEOUT_MS = exports.DEFAULT_TASK_QUEUE = exports.DEFAULT_NAMESPACE = exports.WorkflowProxy = exports.WorkflowProxyFactory = exports.TemporalScheduleService = exports.TemporalMetadataAccessor = exports.TemporalDiscoveryService = exports.TemporalWorkerManagerService = exports.TemporalClientService = exports.TemporalService = exports.TemporalHealthController = exports.TemporalHealthModule = exports.TemporalModule = void 0;
 require("reflect-metadata");
 __exportStar(require("./decorators"), exports);
 var temporal_module_1 = require("./temporal.module");
@@ -35,6 +35,9 @@ var temporal_metadata_service_1 = require("./services/temporal-metadata.service"
 Object.defineProperty(exports, "TemporalMetadataAccessor", { enumerable: true, get: function () { return temporal_metadata_service_1.TemporalMetadataAccessor; } });
 var temporal_schedule_service_1 = require("./services/temporal-schedule.service");
 Object.defineProperty(exports, "TemporalScheduleService", { enumerable: true, get: function () { return temporal_schedule_service_1.TemporalScheduleService; } });
+var workflow_proxy_1 = require("./workflow-proxy");
+Object.defineProperty(exports, "WorkflowProxyFactory", { enumerable: true, get: function () { return workflow_proxy_1.WorkflowProxyFactory; } });
+Object.defineProperty(exports, "WorkflowProxy", { enumerable: true, get: function () { return workflow_proxy_1.WorkflowProxy; } });
 __exportStar(require("./utils"), exports);
 __exportStar(require("./interfaces"), exports);
 var constants_1 = require("./constants");

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,4BAA0B;AAE1B,+CAA6B;AAG7B,qDAAmD;AAA1C,iHAAA,cAAc,OAAA;AAGvB,0EAAuE;AAA9D,8HAAA,oBAAoB,OAAA;AAC7B,kFAA+E;AAAtE,sIAAA,wBAAwB,OAAA;AAGjC,gEAA8D;AAArD,mHAAA,eAAe,OAAA;AAGxB,8EAA2E;AAAlE,gIAAA,qBAAqB,OAAA;AAG9B,8EAAkF;AAAzE,uIAAA,4BAA4B,OAAA;AAGrC,oFAAiF;AAAxE,sIAAA,wBAAwB,OAAA;AAGjC,kFAAgF;AAAvE,qIAAA,wBAAwB,OAAA;AAGjC,kFAA+E;AAAtE,oIAAA,uBAAuB,OAAA;AAGhC,0CAAwB;AAGxB,+CAA6B;AAG7B,yCAcqB;AAbjB,8GAAA,iBAAiB,OAAA;AACjB,+GAAA,kBAAkB,OAAA;AAClB,0HAAA,6BAA6B,OAAA;AAC7B,8GAAA,iBAAiB,OAAA;AACjB,qHAAA,wBAAwB,OAAA;AACxB,mHAAA,sBAAsB,OAAA;AACtB,kHAAA,qBAAqB,OAAA;AACrB,qHAAA,wBAAwB,OAAA;AACxB,4GAAA,eAAe,OAAA;AACf,oHAAA,uBAAuB,OAAA;AACvB,gHAAA,mBAAmB,OAAA;AACnB,qGAAA,QAAQ,OAAA;AACR,2GAAA,cAAc,OAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,4BAA0B;AAE1B,+CAA6B;AAG7B,qDAAmD;AAA1C,iHAAA,cAAc,OAAA;AAGvB,0EAAuE;AAA9D,8HAAA,oBAAoB,OAAA;AAC7B,kFAA+E;AAAtE,sIAAA,wBAAwB,OAAA;AAGjC,gEAA8D;AAArD,mHAAA,eAAe,OAAA;AAGxB,8EAA2E;AAAlE,gIAAA,qBAAqB,OAAA;AAG9B,8EAAkF;AAAzE,uIAAA,4BAA4B,OAAA;AAGrC,oFAAiF;AAAxE,sIAAA,wBAAwB,OAAA;AAGjC,kFAAgF;AAAvE,qIAAA,wBAAwB,OAAA;AAGjC,kFAA+E;AAAtE,oIAAA,uBAAuB,OAAA;AAGhC,mDAAuF;AAA9E,sHAAA,oBAAoB,OAAA;AAAkB,+GAAA,aAAa,OAAA;AAG5D,0CAAwB;AAGxB,+CAA6B;AAG7B,yCAcqB;AAbjB,8GAAA,iBAAiB,OAAA;AACjB,+GAAA,kBAAkB,OAAA;AAClB,0HAAA,6BAA6B,OAAA;AAC7B,8GAAA,iBAAiB,OAAA;AACjB,qHAAA,wBAAwB,OAAA;AACxB,mHAAA,sBAAsB,OAAA;AACtB,kHAAA,qBAAqB,OAAA;AACrB,qHAAA,wBAAwB,OAAA;AACxB,4GAAA,eAAe,OAAA;AACf,oHAAA,uBAAuB,OAAA;AACvB,gHAAA,mBAAmB,OAAA;AACnB,qGAAA,QAAQ,OAAA;AACR,2GAAA,cAAc,OAAA"}

package/dist/interfaces.d.ts

@@ -1,11 +1,17 @@
 export { RetryPolicy, Duration, SearchAttributes } from '@temporalio/common';
-export { WorkflowHandle, Client, ConnectionOptions as TemporalConnectionOptions, } from '@temporalio/client';
+export { WorkflowHandle, Client, ConnectionOptions as TemporalConnectionOptions, WorkflowIdReusePolicy, } from '@temporalio/client';
 export { Worker } from '@temporalio/worker';
+export type { Workflow, WorkflowResultType } from '@temporalio/workflow';
 import { Type } from '@nestjs/common';
-import { ScheduleClient, ScheduleHandle } from '@temporalio/client';
-import { NativeConnection, Worker } from '@temporalio/worker';
-import { Duration, TypedSearchAttributes } from '@temporalio/common';
+import { ScheduleClient, ScheduleHandle, WorkflowHandle, WorkflowIdReusePolicy, ScheduleOptions as SdkScheduleOptions, ScheduleSpec as SdkScheduleSpec, ScheduleOptionsAction, ScheduleOptionsStartWorkflowAction, ScheduleDescription as SdkScheduleDescription } from '@temporalio/client';
+import { NativeConnection, Worker, WorkerOptions, WorkflowBundleOption } from '@temporalio/worker';
+import { Duration, RetryPolicy, TypedSearchAttributes } from '@temporalio/common';
 import { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
+import type { Workflow } from '@temporalio/workflow';
+export interface WorkflowProxyConfig {
+    workflowType: string;
+    taskQueue?: string;
+}
 export interface ClientConnectionOptions {
     address: string;
     tls?: boolean | TLSConfig;
@@ -23,7 +29,7 @@ export interface RetryPolicyConfig {
 export interface WorkerDefinition {
     taskQueue: string;
     workflowsPath?: string;
-    workflowBundle?: Record<string, unknown>;
+    workflowBundle?: WorkflowBundleOption | Record<string, unknown>;
     activityClasses?: Array<Type<object>>;
     autoStart?: boolean;
     autoRestart?: boolean;
@@ -41,7 +47,7 @@ export interface TemporalOptions extends LoggerConfig {
     taskQueue?: string;
     worker?: {
         workflowsPath?: string;
-        workflowBundle?: Record<string, unknown>;
+        workflowBundle?: WorkflowBundleOption | Record<string, unknown>;
         activityClasses?: Array<Type<object>>;
         autoStart?: boolean;
         autoRestart?: boolean;
@@ -56,43 +62,10 @@ export interface TemporalOptions extends LoggerConfig {
     enableShutdownHooks?: boolean;
     shutdownTimeout?: number;
 }
-export interface WorkerCreateOptions {
-    identity?: string;
-    buildId?: string;
-    useVersioning?: boolean;
-    workerDeploymentOptions?: Record<string, unknown>;
-    shutdownGraceTime?: string | number;
-    shutdownForceTime?: string | number;
-    dataConverter?: Record<string, unknown>;
-    tuner?: Record<string, unknown>;
-    maxConcurrentActivityTaskExecutions?: number;
-    maxConcurrentLocalActivityExecutions?: number;
-    maxConcurrentActivityTaskPolls?: number;
-    enableNonLocalActivities?: boolean;
-    maxActivitiesPerSecond?: number;
-    maxTaskQueueActivitiesPerSecond?: number;
-    maxConcurrentWorkflowTaskExecutions?: number;
-    maxConcurrentWorkflowTaskPolls?: number;
-    nonStickyToStickyPollRatio?: number;
-    maxCachedWorkflows?: number;
-    stickyQueueScheduleToStartTimeout?: string | number;
-    workflowThreadPoolSize?: number;
-    reuseV8Context?: boolean;
-    maxHeartbeatThrottleInterval?: string | number;
-    defaultHeartbeatThrottleInterval?: string | number;
-    debugMode?: boolean;
-    enableLoggingInReplay?: boolean;
-    showStackTraceSources?: boolean;
-    interceptors?: {
-        activityInbound?: unknown[];
-        activity?: unknown[];
-        workflowModules?: string[];
-    };
-    sinks?: Record<string, unknown>;
-    bundlerOptions?: Record<string, unknown>;
+export type WorkerCreateOptions = Omit<WorkerOptions, 'connection' | 'taskQueue' | 'activities' | 'workflowsPath' | 'workflowBundle' | 'namespace'> & {
     enableSDKTracing?: boolean;
     enableOpenTelemetry?: boolean;
-}
+};
 export interface WorkerModuleOptions {
     connection?: {
         address?: string;
@@ -122,6 +95,7 @@ export interface GlobalLoggerConfig extends LoggerConfig {
 export interface LoggerConfig {
     enableLogger?: boolean;
     logLevel?: LogLevel;
+    muteErrors?: boolean;
 }
 export interface TemporalOptionsFactory {
     createTemporalOptions(): Promise<TemporalOptions> | TemporalOptions;
@@ -303,35 +277,27 @@ export interface ActivityContext {
     executionId?: string;
     timestamp?: Date;
 }
-export interface ScheduleSpec {
+export type ScheduleSpec = Omit<SdkScheduleSpec, 'intervals' | 'jitter'> & {
     intervals?: Array<{
-        every: string | number;
+        every: Duration | string | number;
+        offset?: Duration | string | number;
     }>;
-    cronExpressions?: string[];
+    jitter?: Duration | string | number;
     timezones?: string[];
-    startAt?: Date;
-    endAt?: Date;
-    jitter?: string | number;
-}
-export interface ScheduleAction {
-    type: 'startWorkflow';
-    workflowType: string;
-    args?: unknown[];
-    taskQueue: string;
-    workflowId?: string;
-    workflowExecutionTimeout?: Duration;
-    workflowRunTimeout?: Duration;
-    workflowTaskTimeout?: Duration;
-}
+};
+export type ScheduleAction = ScheduleOptionsAction & {
+    retryPolicy?: RetryPolicy | Record<string, unknown>;
+};
 export interface WorkflowStartOptions {
     workflowId?: string;
     taskQueue?: string;
     searchAttributes?: TypedSearchAttributes;
-    memo?: Record<string, string | number | boolean | object>;
-    workflowIdReusePolicy?: 'ALLOW_DUPLICATE' | 'ALLOW_DUPLICATE_FAILED_ONLY' | 'REJECT_DUPLICATE';
+    memo?: Record<string, unknown>;
+    workflowIdReusePolicy?: WorkflowIdReusePolicy;
     workflowExecutionTimeout?: Duration;
     workflowRunTimeout?: Duration;
     workflowTaskTimeout?: Duration;
+    retryPolicy?: RetryPolicy;
 }
 export type HealthStatus = 'healthy' | 'unhealthy' | 'degraded';
 export interface ServiceHealth {
@@ -377,8 +343,8 @@ export interface WorkflowSignalConfig {
     name: string;
     args?: unknown[];
 }
-export type WorkflowHandleWithMetadata = import('@temporalio/client').WorkflowHandle & {
-    handle: import('@temporalio/client').WorkflowHandle;
+export type WorkflowHandleWithMetadata<T extends Workflow = Workflow> = WorkflowHandle<T> & {
+    handle: WorkflowHandle<T>;
 };
 export interface ClientServiceStatus {
     available: boolean;
@@ -396,20 +362,7 @@ export interface GenericClient {
         getHandle: (id: string, runId?: string) => import('@temporalio/client').WorkflowHandle;
     };
 }
-export interface ScheduleDescription {
-    spec: ScheduleSpec;
-    action: ScheduleAction;
-    policies: {
-        overlap: TemporalOverlapPolicy;
-        catchupWindow: number;
-        pauseOnFailure: boolean;
-    };
-    state: {
-        paused: boolean;
-        note?: string;
-        remainingActions?: number;
-    };
-}
+export type ScheduleDescription = SdkScheduleDescription;
 export interface DiscoveryServiceStats {
     methods: number;
     activities: number;
@@ -626,17 +579,19 @@ export interface ScheduleWorkflowOptions {
     workflowExecutionTimeout?: Duration;
     workflowRunTimeout?: Duration;
     workflowTaskTimeout?: Duration;
-    retryPolicy?: Record<string, unknown>;
+    retryPolicy?: RetryPolicy | Record<string, unknown>;
     args?: unknown[];
 }
 export interface ScheduleSpecBuilderResult {
     success: boolean;
-    spec?: Record<string, unknown>;
+    spec?: Partial<ScheduleSpec>;
     error?: Error;
 }
 export interface ScheduleIntervalParseResult {
     success: boolean;
-    interval?: Record<string, unknown>;
+    interval?: {
+        every: Duration;
+    };
     error?: Error;
 }
 export interface TemporalConnection {
@@ -645,24 +600,10 @@ export interface TemporalConnection {
     tls?: boolean | object;
     metadata?: Record<string, string>;
 }
-export interface ScheduleWorkflowAction {
-    type: 'startWorkflow';
-    workflowType: string;
-    taskQueue: string;
-    args?: unknown[];
-    workflowId?: string;
-    workflowExecutionTimeout?: Duration;
-    workflowRunTimeout?: Duration;
-    workflowTaskTimeout?: Duration;
-    retryPolicy?: Record<string, unknown>;
-}
-export interface ScheduleOptions {
-    scheduleId: string;
-    spec: Record<string, unknown>;
-    action: ScheduleWorkflowAction;
-    memo?: Record<string, unknown>;
-    searchAttributes?: Record<string, unknown>;
-}
+export type ScheduleWorkflowAction = ScheduleOptionsStartWorkflowAction<Workflow> & {
+    retryPolicy?: RetryPolicy | Record<string, unknown>;
+};
+export type ScheduleOptions = SdkScheduleOptions;
 export interface WorkerConnectionOptions {
     address: string;
     tls?: boolean | object;
@@ -670,16 +611,11 @@ export interface WorkerConnectionOptions {
     apiKey?: string;
     namespace?: string;
 }
-export interface WorkerConfig {
-    taskQueue: string;
+export type WorkerConfig = WorkerOptions & {
     namespace: string;
     connection: NativeConnection;
     activities: Record<string, Function>;
-    workflowsPath?: string;
-    workflowBundle?: unknown;
-    workerOptions?: Record<string, unknown>;
-    [key: string]: unknown;
-}
+};
 export interface WorkerInitResult {
     success: boolean;
     worker?: Worker;

package/dist/interfaces.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Worker = exports.Client = void 0;
+exports.Worker = exports.WorkflowIdReusePolicy = exports.Client = void 0;
 var client_1 = require("@temporalio/client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+Object.defineProperty(exports, "WorkflowIdReusePolicy", { enumerable: true, get: function () { return client_1.WorkflowIdReusePolicy; } });
 var worker_1 = require("@temporalio/worker");
 Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return worker_1.Worker; } });
 //# sourceMappingURL=interfaces.js.map

package/dist/interfaces.js.map

@@ -1 +1 @@
-{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;;AACA,6CAI4B;AAFxB,gGAAA,MAAM,OAAA;AAGV,6CAA4C;AAAnC,gGAAA,MAAM,OAAA"}
+{"version":3,"file":"interfaces.js","sourceRoot":"","sources":["../src/interfaces.ts"],"names":[],"mappings":";;;AACA,6CAK4B;AAHxB,gGAAA,MAAM,OAAA;AAEN,+GAAA,qBAAqB,OAAA;AAEzB,6CAA4C;AAAnC,gGAAA,MAAM,OAAA"}

package/dist/services/temporal-client.service.d.ts

@@ -11,14 +11,15 @@ export declare class TemporalClientService implements OnModuleInit {
     private healthCheckInterval;
     constructor(temporalClient: Client | null, options: TemporalOptions);
     onModuleInit(): Promise<void>;
-    startWorkflow(workflowType: string, args?: unknown[], options?: WorkflowStartOptions): Promise<WorkflowHandleWithMetadata>;
+    startWorkflow(workflowType: string, args?: readonly unknown[], options?: WorkflowStartOptions): Promise<WorkflowHandleWithMetadata>;
     getWorkflowHandle(workflowId: string, runId?: string): Promise<WorkflowHandle>;
     terminateWorkflow(workflowId: string, reason?: string, runId?: string): Promise<void>;
     cancelWorkflow(workflowId: string, runId?: string): Promise<void>;
-    signalWorkflow(workflowId: string, signalName: string, args?: unknown[], runId?: string): Promise<void>;
-    signalWorkflowHandle(handle: WorkflowHandle, signalName: string, args?: unknown[]): Promise<void>;
-    queryWorkflow<T = unknown>(workflowId: string, queryName: string, args?: unknown[], runId?: string): Promise<T>;
-    queryWorkflowHandle<T = unknown>(handle: WorkflowHandle, queryName: string, args?: unknown[]): Promise<T>;
+    signalWorkflow(workflowId: string, signalName: string, args?: readonly unknown[], runId?: string): Promise<void>;
+    signalWorkflowHandle(handle: WorkflowHandle, signalName: string, args?: readonly unknown[]): Promise<void>;
+    signalWithStart(workflowType: string, signalName: string, signalArgs: readonly unknown[], workflowArgs: readonly unknown[], options?: WorkflowStartOptions): Promise<WorkflowHandleWithMetadata>;
+    queryWorkflow<T = unknown>(workflowId: string, queryName: string, args?: readonly unknown[], runId?: string): Promise<T>;
+    queryWorkflowHandle<T = unknown>(handle: WorkflowHandle, queryName: string, args?: readonly unknown[]): Promise<T>;
     getWorkflowResult<T = unknown>(workflowId: string, runId?: string): Promise<T>;
     isHealthy(): boolean;
     getHealth(): ClientHealthStatus;