@temporal-contract/worker 0.0.5 → 0.0.7

package/dist/errors-DjSZg-93.cjs

@@ -0,0 +1,227 @@
+
+//#region src/errors.ts
+/**
+* Base error class for worker errors
+*/
+var WorkerError = class extends Error {
+	constructor(message, cause) {
+		super(message, { cause });
+		this.name = "WorkerError";
+		if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Error thrown when an activity definition is not found in the contract
+*/
+var ActivityDefinitionNotFoundError = class extends WorkerError {
+	constructor(activityName, availableDefinitions = []) {
+		const available = availableDefinitions.length > 0 ? availableDefinitions.join(", ") : "none";
+		super(`Activity definition not found for: "${activityName}". Available activities: ${available}`);
+		this.activityName = activityName;
+		this.availableDefinitions = availableDefinitions;
+		this.name = "ActivityDefinitionNotFoundError";
+	}
+};
+/**
+* Error thrown when activity input validation fails
+*/
+var ActivityInputValidationError = class extends WorkerError {
+	constructor(activityName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Activity "${activityName}" input validation failed: ${message}`);
+		this.activityName = activityName;
+		this.issues = issues;
+		this.name = "ActivityInputValidationError";
+	}
+};
+/**
+* Error thrown when activity output validation fails
+*/
+var ActivityOutputValidationError = class extends WorkerError {
+	constructor(activityName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Activity "${activityName}" output validation failed: ${message}`);
+		this.activityName = activityName;
+		this.issues = issues;
+		this.name = "ActivityOutputValidationError";
+	}
+};
+/**
+* Error thrown when workflow input validation fails
+*/
+var WorkflowInputValidationError = class extends WorkerError {
+	constructor(workflowName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Workflow "${workflowName}" input validation failed: ${message}`);
+		this.workflowName = workflowName;
+		this.issues = issues;
+		this.name = "WorkflowInputValidationError";
+	}
+};
+/**
+* Error thrown when workflow output validation fails
+*/
+var WorkflowOutputValidationError = class extends WorkerError {
+	constructor(workflowName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Workflow "${workflowName}" output validation failed: ${message}`);
+		this.workflowName = workflowName;
+		this.issues = issues;
+		this.name = "WorkflowOutputValidationError";
+	}
+};
+/**
+* Error thrown when signal input validation fails
+*/
+var SignalInputValidationError = class extends WorkerError {
+	constructor(signalName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Signal "${signalName}" input validation failed: ${message}`);
+		this.signalName = signalName;
+		this.issues = issues;
+		this.name = "SignalInputValidationError";
+	}
+};
+/**
+* Error thrown when query input validation fails
+*/
+var QueryInputValidationError = class extends WorkerError {
+	constructor(queryName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Query "${queryName}" input validation failed: ${message}`);
+		this.queryName = queryName;
+		this.issues = issues;
+		this.name = "QueryInputValidationError";
+	}
+};
+/**
+* Error thrown when query output validation fails
+*/
+var QueryOutputValidationError = class extends WorkerError {
+	constructor(queryName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Query "${queryName}" output validation failed: ${message}`);
+		this.queryName = queryName;
+		this.issues = issues;
+		this.name = "QueryOutputValidationError";
+	}
+};
+/**
+* Error thrown when update input validation fails
+*/
+var UpdateInputValidationError = class extends WorkerError {
+	constructor(updateName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Update "${updateName}" input validation failed: ${message}`);
+		this.updateName = updateName;
+		this.issues = issues;
+		this.name = "UpdateInputValidationError";
+	}
+};
+/**
+* Error thrown when update output validation fails
+*/
+var UpdateOutputValidationError = class extends WorkerError {
+	constructor(updateName, issues) {
+		const message = issues.map((issue) => issue.message).join("; ");
+		super(`Update "${updateName}" output validation failed: ${message}`);
+		this.updateName = updateName;
+		this.issues = issues;
+		this.name = "UpdateOutputValidationError";
+	}
+};
+/**
+* Error thrown when a child workflow is not found in the contract
+*/
+var ChildWorkflowNotFoundError = class extends WorkerError {
+	constructor(workflowName, availableWorkflows = []) {
+		const available = availableWorkflows.length > 0 ? availableWorkflows.join(", ") : "none";
+		super(`Child workflow not found: "${workflowName}". Available workflows: ${available}`);
+		this.workflowName = workflowName;
+		this.availableWorkflows = availableWorkflows;
+		this.name = "ChildWorkflowNotFoundError";
+	}
+};
+/**
+* Generic error for child workflow operations
+*/
+var ChildWorkflowError = class extends WorkerError {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "ChildWorkflowError";
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'ActivityDefinitionNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ActivityDefinitionNotFoundError;
+  }
+});
+Object.defineProperty(exports, 'ActivityInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return ActivityInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'ActivityOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return ActivityOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'ChildWorkflowError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowError;
+  }
+});
+Object.defineProperty(exports, 'ChildWorkflowNotFoundError', {
+  enumerable: true,
+  get: function () {
+    return ChildWorkflowNotFoundError;
+  }
+});
+Object.defineProperty(exports, 'QueryInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return QueryInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'QueryOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return QueryOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'SignalInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return SignalInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'UpdateInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return UpdateInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'UpdateOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return UpdateOutputValidationError;
+  }
+});
+Object.defineProperty(exports, 'WorkflowInputValidationError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowInputValidationError;
+  }
+});
+Object.defineProperty(exports, 'WorkflowOutputValidationError', {
+  enumerable: true,
+  get: function () {
+    return WorkflowOutputValidationError;
+  }
+});

package/dist/worker.cjs

@@ -0,0 +1,65 @@
+let _temporalio_worker = require("@temporalio/worker");
+let node_url = require("node:url");
+let node_path = require("node:path");
+
+//#region src/worker.ts
+/**
+* Create a typed Temporal worker with contract-based configuration
+*
+* This helper simplifies worker creation by:
+* - Using the contract's task queue automatically
+* - Providing type-safe configuration
+*
+* @example
+* ```ts
+* import { NativeConnection } from '@temporalio/worker';
+* import { createWorker } from '@temporal-contract/worker/worker';
+* import { activities } from './activities';
+* import myContract from './contract';
+*
+* const connection = await NativeConnection.connect({
+*   address: 'localhost:7233',
+* });
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: require.resolve('./workflows'),
+*   activities,
+* });
+*
+* await worker.run();
+* ```
+*/
+async function createWorker(options) {
+	const { contract, activities, ...workerOptions } = options;
+	return await _temporalio_worker.Worker.create({
+		...workerOptions,
+		activities,
+		taskQueue: contract.taskQueue
+	});
+}
+/**
+* Helper to create a workflowsPath from a file URL
+*
+* Useful for creating the workflowsPath option when using ES modules
+*
+* @example
+* ```ts
+* import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+*   activities,
+* });
+* ```
+*/
+function workflowsPathFromURL(baseURL, relativePath) {
+	return (0, node_url.fileURLToPath)(new URL(`${relativePath}${(0, node_path.extname)(baseURL)}`, baseURL));
+}
+
+//#endregion
+exports.createWorker = createWorker;
+exports.workflowsPathFromURL = workflowsPathFromURL;

package/dist/worker.d.cts

@@ -0,0 +1,68 @@
+import { t as ActivitiesHandler } from "./activity-Csptpwgf.cjs";
+import { ContractDefinition } from "@temporal-contract/contract";
+import { Worker, WorkerOptions } from "@temporalio/worker";
+
+//#region src/worker.d.ts
+
+/**
+ * Options for creating a Temporal worker
+ */
+interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+  /**
+   * The contract definition for this worker
+   */
+  contract: TContract;
+  /**
+   * Activities handler for this worker
+   */
+  activities: ActivitiesHandler<TContract>;
+}
+/**
+ * Create a typed Temporal worker with contract-based configuration
+ *
+ * This helper simplifies worker creation by:
+ * - Using the contract's task queue automatically
+ * - Providing type-safe configuration
+ *
+ * @example
+ * ```ts
+ * import { NativeConnection } from '@temporalio/worker';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
+ *
+ * const connection = await NativeConnection.connect({
+ *   address: 'localhost:7233',
+ * });
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities,
+ * });
+ *
+ * await worker.run();
+ * ```
+ */
+declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
+/**
+ * Helper to create a workflowsPath from a file URL
+ *
+ * Useful for creating the workflowsPath option when using ES modules
+ *
+ * @example
+ * ```ts
+ * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   activities,
+ * });
+ * ```
+ */
+declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
+//#endregion
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };

package/dist/worker.d.mts

@@ -0,0 +1,68 @@
+import { t as ActivitiesHandler } from "./activity-UOnp_bSX.mjs";
+import { Worker, WorkerOptions } from "@temporalio/worker";
+import { ContractDefinition } from "@temporal-contract/contract";
+
+//#region src/worker.d.ts
+
+/**
+ * Options for creating a Temporal worker
+ */
+interface CreateWorkerOptions<TContract extends ContractDefinition> extends Omit<WorkerOptions, "activities" | "taskQueue"> {
+  /**
+   * The contract definition for this worker
+   */
+  contract: TContract;
+  /**
+   * Activities handler for this worker
+   */
+  activities: ActivitiesHandler<TContract>;
+}
+/**
+ * Create a typed Temporal worker with contract-based configuration
+ *
+ * This helper simplifies worker creation by:
+ * - Using the contract's task queue automatically
+ * - Providing type-safe configuration
+ *
+ * @example
+ * ```ts
+ * import { NativeConnection } from '@temporalio/worker';
+ * import { createWorker } from '@temporal-contract/worker/worker';
+ * import { activities } from './activities';
+ * import myContract from './contract';
+ *
+ * const connection = await NativeConnection.connect({
+ *   address: 'localhost:7233',
+ * });
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: require.resolve('./workflows'),
+ *   activities,
+ * });
+ *
+ * await worker.run();
+ * ```
+ */
+declare function createWorker<TContract extends ContractDefinition>(options: CreateWorkerOptions<TContract>): Promise<Worker>;
+/**
+ * Helper to create a workflowsPath from a file URL
+ *
+ * Useful for creating the workflowsPath option when using ES modules
+ *
+ * @example
+ * ```ts
+ * import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+ *
+ * const worker = await createWorker({
+ *   contract: myContract,
+ *   connection,
+ *   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+ *   activities,
+ * });
+ * ```
+ */
+declare function workflowsPathFromURL(baseURL: string, relativePath: string): string;
+//#endregion
+export { CreateWorkerOptions, createWorker, workflowsPathFromURL };

package/dist/worker.mjs

@@ -0,0 +1,64 @@
+import { Worker } from "@temporalio/worker";
+import { fileURLToPath } from "node:url";
+import { extname } from "node:path";
+
+//#region src/worker.ts
+/**
+* Create a typed Temporal worker with contract-based configuration
+*
+* This helper simplifies worker creation by:
+* - Using the contract's task queue automatically
+* - Providing type-safe configuration
+*
+* @example
+* ```ts
+* import { NativeConnection } from '@temporalio/worker';
+* import { createWorker } from '@temporal-contract/worker/worker';
+* import { activities } from './activities';
+* import myContract from './contract';
+*
+* const connection = await NativeConnection.connect({
+*   address: 'localhost:7233',
+* });
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: require.resolve('./workflows'),
+*   activities,
+* });
+*
+* await worker.run();
+* ```
+*/
+async function createWorker(options) {
+	const { contract, activities, ...workerOptions } = options;
+	return await Worker.create({
+		...workerOptions,
+		activities,
+		taskQueue: contract.taskQueue
+	});
+}
+/**
+* Helper to create a workflowsPath from a file URL
+*
+* Useful for creating the workflowsPath option when using ES modules
+*
+* @example
+* ```ts
+* import { workflowsPathFromURL } from '@temporal-contract/worker/worker';
+*
+* const worker = await createWorker({
+*   contract: myContract,
+*   connection,
+*   workflowsPath: workflowsPathFromURL(import.meta.url, './workflows'),
+*   activities,
+* });
+* ```
+*/
+function workflowsPathFromURL(baseURL, relativePath) {
+	return fileURLToPath(new URL(`${relativePath}${extname(baseURL)}`, baseURL));
+}
+
+//#endregion
+export { createWorker, workflowsPathFromURL };