@temporal-contract/contract 0.0.7 → 0.2.0

package/README.md

@@ -13,18 +13,20 @@ pnpm add @temporal-contract/contract zod
 ## Quick Example
 
 ```typescript
-import { defineContract } from '@temporal-contract/contract';
-import { z } from 'zod';
+import { defineContract } from "@temporal-contract/contract";
+import { z } from "zod";
 
 export const myContract = defineContract({
-  taskQueue: 'orders',
+  taskQueue: "orders",
   workflows: {
     processOrder: {
       input: z.object({ orderId: z.string() }),
       output: z.object({ success: z.boolean() }),
-      activities: { /* ... */ }
-    }
-  }
+      activities: {
+        /* ... */
+      },
+    },
+  },
 });
 ```
 

package/dist/index.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 let zod = require("zod");
 
 //#region src/builder.ts
@@ -227,21 +228,21 @@ function isStandardSchema(value) {
 */
 const identifierSchema = zod.z.string().min(1).regex(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/, "must be a valid JavaScript identifier");
 /**
-* Extract clean error message from Zod validation error
+* Extract a clean, single-line error message from a Zod validation error.
+*
+* Uses `error.issues` directly (compatible with Zod v4+) rather than parsing
+* `error.message` as JSON, which was a Zod v3 implementation detail.
 */
 function getCleanErrorMessage(error) {
-	try {
-		const parsed = JSON.parse(error.message);
-		if (Array.isArray(parsed) && parsed.length > 0) {
-			const firstError = parsed[0];
-			if (firstError?.code === "invalid_key" && firstError?.issues && firstError.issues.length > 0) {
-				const nestedError = firstError.issues[0];
-				if (nestedError?.message) return nestedError.message;
-			}
-			if (firstError?.message) return firstError.message;
-		}
-	} catch {}
-	return error.message;
+	const issues = error.issues;
+	if (!issues || issues.length === 0) return error.message;
+	const firstIssue = issues[0];
+	if (!firstIssue) return error.message;
+	if (firstIssue.code === "invalid_key" && "issues" in firstIssue && Array.isArray(firstIssue.issues) && firstIssue.issues.length > 0) {
+		const nestedMessage = firstIssue.issues[0]?.message;
+		if (nestedMessage) return nestedMessage;
+	}
+	return firstIssue.message ?? error.message;
 }
 /**
 * Schema for validating activity definitions
@@ -300,125 +301,9 @@ const contractValidationSchema = zod.z.object({
 	}
 });
 
-//#endregion
-//#region src/nexus-types.ts
-/**
-* BUILDER FUNCTIONS (Proposed API)
-* These would be added to builder.ts when Nexus support is implemented
-*/
-/**
-* Builder for creating Nexus operation definitions
-*
-* @template TOperation - A NexusOperationDefinition containing input and output schemas
-* @param definition - The Nexus operation definition with typed input/output schemas
-* @returns The same definition with preserved types
-*
-* @example
-* ```typescript
-* const processPayment = defineNexusOperation({
-*   input: z.object({ amount: z.number(), customerId: z.string() }),
-*   output: z.object({ transactionId: z.string(), status: z.enum(['success', 'failed']) }),
-* });
-* ```
-*/
-function defineNexusOperation(definition) {
-	return definition;
-}
-/**
-* Builder for creating Nexus service definitions
-*
-* @template TService - A NexusServiceDefinition containing a record of operations
-* @param definition - The Nexus service definition with typed operations
-* @returns The same definition with preserved types
-*
-* @example
-* ```typescript
-* const PaymentService = defineNexusService({
-*   operations: {
-*     processPayment: defineNexusOperation({ ... }),
-*     refundPayment: defineNexusOperation({ ... }),
-*   },
-* });
-* ```
-*/
-function defineNexusService(definition) {
-	return definition;
-}
-/**
-* USAGE EXAMPLE
-*
-* This example demonstrates the complete type-safe Nexus workflow:
-*
-* ```typescript
-* import { defineContract, defineNexusService, defineNexusOperation } from '@temporal-contract/contract';
-* import { z } from 'zod';
-*
-* // 1. Define contract with Nexus service
-* const paymentContract = defineContract({
-*   taskQueue: 'payments',
-*   workflows: { ... },
-*   nexusServices: {
-*     PaymentService: defineNexusService({
-*       operations: {
-*         processPayment: defineNexusOperation({
-*           input: z.object({
-*             amount: z.number().positive(),
-*             customerId: z.string().uuid(),
-*           }),
-*           output: z.object({
-*             transactionId: z.string(),
-*             status: z.enum(['success', 'failed']),
-*           }),
-*         }),
-*       },
-*     }),
-*   },
-* });
-*
-* // 2. Worker implementation (type-safe handlers)
-* import { createNexusHandlers } from '@temporal-contract/worker';
-*
-* const nexusHandlers = createNexusHandlers(paymentContract, {
-*   PaymentService: {
-*     processPayment: async ({ amount, customerId }) => {
-*       // ✅ Fully typed parameters
-*       // ✅ Input automatically validated
-*       const payment = await processPaymentInDatabase(customerId, amount);
-*       // ✅ Return value validated against schema
-*       return {
-*         transactionId: payment.id,
-*         status: 'success',
-*       };
-*     },
-*   },
-* });
-*
-* // 3. Client usage (type-safe invocation)
-* import { createNexusClient } from '@temporal-contract/client';
-*
-* const nexusClient = createNexusClient<typeof paymentContract>(connection, {
-*   namespace: 'payments-ns',
-* });
-*
-* // ✅ Fully typed invocation
-* const result = await nexusClient.invoke('PaymentService', 'processPayment', {
-*   amount: 100,
-*   customerId: 'cust-123',
-* });
-*
-* // ❌ TypeScript errors caught at compile time
-* await nexusClient.invoke('PaymentService', 'processPayment', {
-*   amount: -50, // Error: amount must be positive
-*   customerId: 'invalid', // Error: customerId must be UUID
-* });
-* ```
-*/
-
 //#endregion
 exports.defineActivity = defineActivity;
 exports.defineContract = defineContract;
-exports.defineNexusOperation = defineNexusOperation;
-exports.defineNexusService = defineNexusService;
 exports.defineQuery = defineQuery;
 exports.defineSignal = defineSignal;
 exports.defineUpdate = defineUpdate;

package/dist/index.d.cts

@@ -1,7 +1,6 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/types.d.ts
-
 /**
  * Base types for validation schemas
  * Any schema that implements the Standard Schema specification
@@ -11,49 +10,49 @@ type AnySchema = StandardSchemaV1;
 /**
  * Definition of an activity
  */
-interface ActivityDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
+type ActivityDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> = {
   readonly input: TInput;
   readonly output: TOutput;
-}
+};
 /**
  * Definition of a signal
  */
-interface SignalDefinition<TInput extends AnySchema = AnySchema> {
+type SignalDefinition<TInput extends AnySchema = AnySchema> = {
   readonly input: TInput;
-}
+};
 /**
  * Definition of a query
  */
-interface QueryDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
+type QueryDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> = {
   readonly input: TInput;
   readonly output: TOutput;
-}
+};
 /**
  * Definition of an update
  */
-interface UpdateDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
+type UpdateDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> = {
   readonly input: TInput;
   readonly output: TOutput;
-}
+};
 /**
  * Definition of a workflow
  */
-interface WorkflowDefinition<TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TSignals extends Record<string, SignalDefinition> = Record<string, SignalDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TUpdates extends Record<string, UpdateDefinition> = Record<string, UpdateDefinition>> {
+type WorkflowDefinition<TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TSignals extends Record<string, SignalDefinition> = Record<string, SignalDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TUpdates extends Record<string, UpdateDefinition> = Record<string, UpdateDefinition>> = {
   readonly input: AnySchema;
   readonly output: AnySchema;
   readonly activities?: TActivities;
   readonly signals?: TSignals;
   readonly queries?: TQueries;
   readonly updates?: TUpdates;
-}
+};
 /**
  * Contract definition containing workflows and optional global activities
  */
-interface ContractDefinition<TWorkflows extends Record<string, WorkflowDefinition> = Record<string, WorkflowDefinition>, TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>> {
+type ContractDefinition<TWorkflows extends Record<string, WorkflowDefinition> = Record<string, WorkflowDefinition>, TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>> = {
   readonly taskQueue: string;
   readonly workflows: TWorkflows;
   readonly activities?: TActivities;
-}
+};
 /**
  * UTILITY TYPES
  */
@@ -283,228 +282,5 @@ declare function defineWorkflow<TWorkflow extends WorkflowDefinition>(definition
  */
 declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
 //#endregion
-//#region src/nexus-types.d.ts
-/**
- * Definition of a Nexus operation
- * Similar to ActivityDefinition but for cross-namespace operations
- *
- * @example
- * ```typescript
- * const processPayment = {
- *   input: z.object({ amount: z.number(), customerId: z.string() }),
- *   output: z.object({ transactionId: z.string(), status: z.enum(['success', 'failed']) }),
- * };
- * ```
- */
-interface NexusOperationDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
-  readonly input: TInput;
-  readonly output: TOutput;
-}
-/**
- * Definition of a Nexus service containing multiple operations
- *
- * @example
- * ```typescript
- * const PaymentService = {
- *   operations: {
- *     processPayment: { input: ..., output: ... },
- *     refundPayment: { input: ..., output: ... },
- *   },
- * };
- * ```
- */
-interface NexusServiceDefinition<TOperations extends Record<string, NexusOperationDefinition> = Record<string, NexusOperationDefinition>> {
-  readonly operations: TOperations;
-}
-/**
- * Extended ContractDefinition that includes Nexus services
- * This would replace the current ContractDefinition when Nexus support is added
- *
- * @example
- * ```typescript
- * const contract = defineContract({
- *   taskQueue: 'payments',
- *   workflows: { ... },
- *   activities: { ... },
- *   nexusServices: {
- *     PaymentService: {
- *       operations: {
- *         processPayment: { input: ..., output: ... },
- *       },
- *     },
- *   },
- * });
- * ```
- */
-interface ContractDefinitionWithNexus<TWorkflows extends Record<string, WorkflowDefinition> = Record<string, WorkflowDefinition>, TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TNexusServices extends Record<string, NexusServiceDefinition> = Record<string, NexusServiceDefinition>> {
-  readonly taskQueue: string;
-  readonly workflows: TWorkflows;
-  readonly activities?: TActivities;
-  readonly nexusServices?: TNexusServices;
-}
-/**
- * WORKER PERSPECTIVE - Nexus operation handler type inference
- * Worker receives the parsed input and returns the raw output
- */
-/**
- * Infer input type from a Nexus operation definition (worker perspective)
- */
-type WorkerInferNexusOperationInput<T extends NexusOperationDefinition> = StandardSchemaV1.InferOutput<T["input"]>;
-/**
- * Infer output type from a Nexus operation definition (worker perspective)
- */
-type WorkerInferNexusOperationOutput<T extends NexusOperationDefinition> = StandardSchemaV1.InferInput<T["output"]>;
-/**
- * Infer the handler function signature for a Nexus operation (worker perspective)
- *
- * @example
- * ```typescript
- * type ProcessPaymentHandler = WorkerInferNexusOperationHandler<typeof processPaymentOperation>;
- * // (args: { amount: number; customerId: string }) => Promise<{ transactionId: string; status: 'success' | 'failed' }>
- * ```
- */
-type WorkerInferNexusOperationHandler<TOperation extends NexusOperationDefinition> = (args: WorkerInferNexusOperationInput<TOperation>) => Promise<WorkerInferNexusOperationOutput<TOperation>>;
-/**
- * Infer all operation handlers for a Nexus service (worker perspective)
- *
- * @example
- * ```typescript
- * type PaymentServiceHandlers = WorkerInferNexusServiceHandlers<typeof PaymentService>;
- * // {
- * //   processPayment: (args: { ... }) => Promise<{ ... }>;
- * //   refundPayment: (args: { ... }) => Promise<{ ... }>;
- * // }
- * ```
- */
-type WorkerInferNexusServiceHandlers<T extends NexusServiceDefinition> = { [K in keyof T["operations"]]: WorkerInferNexusOperationHandler<T["operations"][K]> };
-/**
- * Infer all Nexus service handlers from a contract (worker perspective)
- *
- * @example
- * ```typescript
- * type AllNexusHandlers = WorkerInferNexusServices<typeof myContract>;
- * // {
- * //   PaymentService: { processPayment: ..., refundPayment: ... };
- * //   InventoryService: { reserveItems: ..., releaseItems: ... };
- * // }
- * ```
- */
-type WorkerInferNexusServices<TContract extends ContractDefinitionWithNexus> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? { [K in keyof TContract["nexusServices"]]: WorkerInferNexusServiceHandlers<TContract["nexusServices"][K]> } : {};
-/**
- * CLIENT PERSPECTIVE - Nexus operation client type inference
- * Client sends the raw input and receives the parsed output
- */
-/**
- * Infer input type from a Nexus operation definition (client perspective)
- */
-type ClientInferNexusOperationInput<T extends NexusOperationDefinition> = StandardSchemaV1.InferInput<T["input"]>;
-/**
- * Infer output type from a Nexus operation definition (client perspective)
- */
-type ClientInferNexusOperationOutput<T extends NexusOperationDefinition> = StandardSchemaV1.InferOutput<T["output"]>;
-/**
- * Infer the client function signature for a Nexus operation (client perspective)
- *
- * @example
- * ```typescript
- * type ProcessPaymentClient = ClientInferNexusOperationInvoker<typeof processPaymentOperation>;
- * // (args: { amount: number; customerId: string }) => Promise<{ transactionId: string; status: 'success' | 'failed' }>
- * ```
- */
-type ClientInferNexusOperationInvoker<TOperation extends NexusOperationDefinition> = (args: ClientInferNexusOperationInput<TOperation>) => Promise<ClientInferNexusOperationOutput<TOperation>>;
-/**
- * Infer all operation invokers for a Nexus service (client perspective)
- */
-type ClientInferNexusServiceOperations<T extends NexusServiceDefinition> = { [K in keyof T["operations"]]: ClientInferNexusOperationInvoker<T["operations"][K]> };
-/**
- * Infer all Nexus service operations from a contract (client perspective)
- *
- * @example
- * ```typescript
- * type AllNexusOperations = ClientInferNexusServices<typeof myContract>;
- * // {
- * //   PaymentService: { processPayment: ..., refundPayment: ... };
- * //   InventoryService: { reserveItems: ..., releaseItems: ... };
- * // }
- * ```
- */
-type ClientInferNexusServices<TContract extends ContractDefinitionWithNexus> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? { [K in keyof TContract["nexusServices"]]: ClientInferNexusServiceOperations<TContract["nexusServices"][K]> } : {};
-/**
- * UTILITY TYPES
- */
-/**
- * Extract service names from a contract as a union type
- *
- * @example
- * ```typescript
- * type MyServiceNames = InferNexusServiceNames<typeof myContract>;
- * // "PaymentService" | "InventoryService"
- * ```
- */
-type InferNexusServiceNames<TContract extends ContractDefinitionWithNexus> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? keyof TContract["nexusServices"] & string : never;
-/**
- * Extract operation names from a service as a union type
- *
- * @example
- * ```typescript
- * type PaymentOperations = InferNexusOperationNames<typeof myContract, "PaymentService">;
- * // "processPayment" | "refundPayment"
- * ```
- */
-type InferNexusOperationNames<TContract extends ContractDefinitionWithNexus, TServiceName extends InferNexusServiceNames<TContract>> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? keyof TContract["nexusServices"][TServiceName]["operations"] & string : never;
-/**
- * Infer the handler type for a specific Nexus operation (worker perspective)
- *
- * @example
- * ```typescript
- * const processPayment: NexusOperationHandler<
- *   typeof myContract,
- *   "PaymentService",
- *   "processPayment"
- * > = async ({ amount, customerId }) => {
- *   // Implementation
- *   return { transactionId: 'tx-123', status: 'success' };
- * };
- * ```
- */
-type NexusOperationHandler<TContract extends ContractDefinitionWithNexus, TServiceName extends InferNexusServiceNames<TContract>, TOperationName extends InferNexusOperationNames<TContract, TServiceName>> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? (args: WorkerInferNexusOperationInput<TContract["nexusServices"][TServiceName]["operations"][TOperationName]>) => Promise<WorkerInferNexusOperationOutput<TContract["nexusServices"][TServiceName]["operations"][TOperationName]>> : never;
-/**
- * BUILDER FUNCTIONS (Proposed API)
- * These would be added to builder.ts when Nexus support is implemented
- */
-/**
- * Builder for creating Nexus operation definitions
- *
- * @template TOperation - A NexusOperationDefinition containing input and output schemas
- * @param definition - The Nexus operation definition with typed input/output schemas
- * @returns The same definition with preserved types
- *
- * @example
- * ```typescript
- * const processPayment = defineNexusOperation({
- *   input: z.object({ amount: z.number(), customerId: z.string() }),
- *   output: z.object({ transactionId: z.string(), status: z.enum(['success', 'failed']) }),
- * });
- * ```
- */
-declare function defineNexusOperation<TOperation extends NexusOperationDefinition>(definition: TOperation): TOperation;
-/**
- * Builder for creating Nexus service definitions
- *
- * @template TService - A NexusServiceDefinition containing a record of operations
- * @param definition - The Nexus service definition with typed operations
- * @returns The same definition with preserved types
- *
- * @example
- * ```typescript
- * const PaymentService = defineNexusService({
- *   operations: {
- *     processPayment: defineNexusOperation({ ... }),
- *     refundPayment: defineNexusOperation({ ... }),
- *   },
- * });
- * ```
- */
-declare function defineNexusService<TService extends NexusServiceDefinition>(definition: TService): TService;
-//#endregion
-export { type ActivityDefinition, type AnySchema, type ClientInferNexusOperationInput, type ClientInferNexusOperationInvoker, type ClientInferNexusOperationOutput, type ClientInferNexusServiceOperations, type ClientInferNexusServices, type ContractDefinition, type ContractDefinitionWithNexus, type InferActivityNames, type InferContractWorkflows, type InferNexusOperationNames, type InferNexusServiceNames, type InferWorkflowNames, type NexusOperationDefinition, type NexusOperationHandler, type NexusServiceDefinition, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferNexusOperationHandler, type WorkerInferNexusOperationInput, type WorkerInferNexusOperationOutput, type WorkerInferNexusServiceHandlers, type WorkerInferNexusServices, type WorkflowDefinition, defineActivity, defineContract, defineNexusOperation, defineNexusService, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+export { type ActivityDefinition, type AnySchema, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/builder.ts"],"mappings":";;;;;AAOA;;;KAAY,SAAA,GAAY,gBAAA;;AAKxB;;KAAY,kBAAA,gBACK,SAAA,GAAY,SAAA,kBACX,SAAA,GAAY,SAAA;EAAA,SAEnB,KAAA,EAAO,MAAA;EAAA,SACP,MAAA,EAAQ,OAAA;AAAA;;;;KAMP,gBAAA,gBAAgC,SAAA,GAAY,SAAA;EAAA,SAC7C,KAAA,EAAO,MAAA;AAAA;;;;KAMN,eAAA,gBACK,SAAA,GAAY,SAAA,kBACX,SAAA,GAAY,SAAA;EAAA,SAEnB,KAAA,EAAO,MAAA;EAAA,SACP,MAAA,EAAQ,OAAA;AAAA;;;;KAMP,gBAAA,gBACK,SAAA,GAAY,SAAA,kBACX,SAAA,GAAY,SAAA;EAAA,SAEnB,KAAA,EAAO,MAAA;EAAA,SACP,MAAA,EAAQ,OAAA;AAAA;;;;KAMP,kBAAA,qBACU,MAAA,SAAe,kBAAA,IAAsB,MAAA,SAAe,kBAAA,oBACvD,MAAA,SAAe,gBAAA,IAAoB,MAAA,SAAe,gBAAA,oBAClD,MAAA,SAAe,eAAA,IAAmB,MAAA,SAAe,eAAA,oBACjD,MAAA,SAAe,gBAAA,IAAoB,MAAA,SAAe,gBAAA;EAAA,SAE1D,KAAA,EAAO,SAAA;EAAA,SACP,MAAA,EAAQ,SAAA;EAAA,SACR,UAAA,GAAa,WAAA;EAAA,SACb,OAAA,GAAU,QAAA;EAAA,SACV,OAAA,GAAU,QAAA;EAAA,SACV,OAAA,GAAU,QAAA;AAAA;;AAjCrB;;KAuCY,kBAAA,oBACS,MAAA,SAAe,kBAAA,IAAsB,MAAA,SAAe,kBAAA,uBACnD,MAAA,SAAe,kBAAA,IAAsB,MAAA,SAAe,kBAAA;EAAA,SAE/D,SAAA;EAAA,SACA,SAAA,EAAW,UAAA;EAAA,SACX,UAAA,GAAa,WAAA;AAAA;;;;;;;;;;;;;KAgBZ,kBAAA,mBAAqC,kBAAA,UACzC,SAAA;;;;AAnDR;;;;;;KA8DY,kBAAA,mBAAqC,kBAAA,IAC/C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,UACrC,SAAA;;;;;;;;;KAWA,sBAAA,mBAAyC,kBAAA,IAAsB,SAAA;;;;;AA7G3E;;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;iBC8BgB,cAAA,mBAAiC,kBAAA,CAAA,CAC/C,UAAA,EAAY,SAAA,GACX,SAAA;ADrBH;;;;;;;;;;;;;;;AAOA;;;;;;;;AAPA,iBCgDgB,YAAA,iBAA6B,gBAAA,CAAA,CAAkB,UAAA,EAAY,OAAA,GAAU,OAAA;;;;;;;;;;;;;;;AD9BrF;;;;;;;;;;iBC0DgB,WAAA,gBAA2B,eAAA,CAAA,CAAiB,UAAA,EAAY,MAAA,GAAS,MAAA;;;;;;;;;;;;;AD/CjF;;;;;;;;;;;;;;;;iBC+EgB,YAAA,iBAA6B,gBAAA,CAAA,CAAkB,UAAA,EAAY,OAAA,GAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqCrE,cAAA,mBAAiC,kBAAA,CAAA,CAC/C,UAAA,EAAY,SAAA,GACX,SAAA;;;;;;;;;;;ADrGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA;;;;;;;;;iBCsIgB,cAAA,mBAAiC,kBAAA,CAAA,CAC/C,UAAA,EAAY,SAAA,GACX,SAAA"}

package/dist/index.d.mts

@@ -1,7 +1,6 @@
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
 //#region src/types.d.ts
-
 /**
  * Base types for validation schemas
  * Any schema that implements the Standard Schema specification
@@ -11,49 +10,49 @@ type AnySchema = StandardSchemaV1;
 /**
  * Definition of an activity
  */
-interface ActivityDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
+type ActivityDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> = {
   readonly input: TInput;
   readonly output: TOutput;
-}
+};
 /**
  * Definition of a signal
  */
-interface SignalDefinition<TInput extends AnySchema = AnySchema> {
+type SignalDefinition<TInput extends AnySchema = AnySchema> = {
   readonly input: TInput;
-}
+};
 /**
  * Definition of a query
  */
-interface QueryDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
+type QueryDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> = {
   readonly input: TInput;
   readonly output: TOutput;
-}
+};
 /**
  * Definition of an update
  */
-interface UpdateDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
+type UpdateDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> = {
   readonly input: TInput;
   readonly output: TOutput;
-}
+};
 /**
  * Definition of a workflow
  */
-interface WorkflowDefinition<TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TSignals extends Record<string, SignalDefinition> = Record<string, SignalDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TUpdates extends Record<string, UpdateDefinition> = Record<string, UpdateDefinition>> {
+type WorkflowDefinition<TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TSignals extends Record<string, SignalDefinition> = Record<string, SignalDefinition>, TQueries extends Record<string, QueryDefinition> = Record<string, QueryDefinition>, TUpdates extends Record<string, UpdateDefinition> = Record<string, UpdateDefinition>> = {
   readonly input: AnySchema;
   readonly output: AnySchema;
   readonly activities?: TActivities;
   readonly signals?: TSignals;
   readonly queries?: TQueries;
   readonly updates?: TUpdates;
-}
+};
 /**
  * Contract definition containing workflows and optional global activities
  */
-interface ContractDefinition<TWorkflows extends Record<string, WorkflowDefinition> = Record<string, WorkflowDefinition>, TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>> {
+type ContractDefinition<TWorkflows extends Record<string, WorkflowDefinition> = Record<string, WorkflowDefinition>, TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>> = {
   readonly taskQueue: string;
   readonly workflows: TWorkflows;
   readonly activities?: TActivities;
-}
+};
 /**
  * UTILITY TYPES
  */
@@ -283,228 +282,5 @@ declare function defineWorkflow<TWorkflow extends WorkflowDefinition>(definition
  */
 declare function defineContract<TContract extends ContractDefinition>(definition: TContract): TContract;
 //#endregion
-//#region src/nexus-types.d.ts
-/**
- * Definition of a Nexus operation
- * Similar to ActivityDefinition but for cross-namespace operations
- *
- * @example
- * ```typescript
- * const processPayment = {
- *   input: z.object({ amount: z.number(), customerId: z.string() }),
- *   output: z.object({ transactionId: z.string(), status: z.enum(['success', 'failed']) }),
- * };
- * ```
- */
-interface NexusOperationDefinition<TInput extends AnySchema = AnySchema, TOutput extends AnySchema = AnySchema> {
-  readonly input: TInput;
-  readonly output: TOutput;
-}
-/**
- * Definition of a Nexus service containing multiple operations
- *
- * @example
- * ```typescript
- * const PaymentService = {
- *   operations: {
- *     processPayment: { input: ..., output: ... },
- *     refundPayment: { input: ..., output: ... },
- *   },
- * };
- * ```
- */
-interface NexusServiceDefinition<TOperations extends Record<string, NexusOperationDefinition> = Record<string, NexusOperationDefinition>> {
-  readonly operations: TOperations;
-}
-/**
- * Extended ContractDefinition that includes Nexus services
- * This would replace the current ContractDefinition when Nexus support is added
- *
- * @example
- * ```typescript
- * const contract = defineContract({
- *   taskQueue: 'payments',
- *   workflows: { ... },
- *   activities: { ... },
- *   nexusServices: {
- *     PaymentService: {
- *       operations: {
- *         processPayment: { input: ..., output: ... },
- *       },
- *     },
- *   },
- * });
- * ```
- */
-interface ContractDefinitionWithNexus<TWorkflows extends Record<string, WorkflowDefinition> = Record<string, WorkflowDefinition>, TActivities extends Record<string, ActivityDefinition> = Record<string, ActivityDefinition>, TNexusServices extends Record<string, NexusServiceDefinition> = Record<string, NexusServiceDefinition>> {
-  readonly taskQueue: string;
-  readonly workflows: TWorkflows;
-  readonly activities?: TActivities;
-  readonly nexusServices?: TNexusServices;
-}
-/**
- * WORKER PERSPECTIVE - Nexus operation handler type inference
- * Worker receives the parsed input and returns the raw output
- */
-/**
- * Infer input type from a Nexus operation definition (worker perspective)
- */
-type WorkerInferNexusOperationInput<T extends NexusOperationDefinition> = StandardSchemaV1.InferOutput<T["input"]>;
-/**
- * Infer output type from a Nexus operation definition (worker perspective)
- */
-type WorkerInferNexusOperationOutput<T extends NexusOperationDefinition> = StandardSchemaV1.InferInput<T["output"]>;
-/**
- * Infer the handler function signature for a Nexus operation (worker perspective)
- *
- * @example
- * ```typescript
- * type ProcessPaymentHandler = WorkerInferNexusOperationHandler<typeof processPaymentOperation>;
- * // (args: { amount: number; customerId: string }) => Promise<{ transactionId: string; status: 'success' | 'failed' }>
- * ```
- */
-type WorkerInferNexusOperationHandler<TOperation extends NexusOperationDefinition> = (args: WorkerInferNexusOperationInput<TOperation>) => Promise<WorkerInferNexusOperationOutput<TOperation>>;
-/**
- * Infer all operation handlers for a Nexus service (worker perspective)
- *
- * @example
- * ```typescript
- * type PaymentServiceHandlers = WorkerInferNexusServiceHandlers<typeof PaymentService>;
- * // {
- * //   processPayment: (args: { ... }) => Promise<{ ... }>;
- * //   refundPayment: (args: { ... }) => Promise<{ ... }>;
- * // }
- * ```
- */
-type WorkerInferNexusServiceHandlers<T extends NexusServiceDefinition> = { [K in keyof T["operations"]]: WorkerInferNexusOperationHandler<T["operations"][K]> };
-/**
- * Infer all Nexus service handlers from a contract (worker perspective)
- *
- * @example
- * ```typescript
- * type AllNexusHandlers = WorkerInferNexusServices<typeof myContract>;
- * // {
- * //   PaymentService: { processPayment: ..., refundPayment: ... };
- * //   InventoryService: { reserveItems: ..., releaseItems: ... };
- * // }
- * ```
- */
-type WorkerInferNexusServices<TContract extends ContractDefinitionWithNexus> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? { [K in keyof TContract["nexusServices"]]: WorkerInferNexusServiceHandlers<TContract["nexusServices"][K]> } : {};
-/**
- * CLIENT PERSPECTIVE - Nexus operation client type inference
- * Client sends the raw input and receives the parsed output
- */
-/**
- * Infer input type from a Nexus operation definition (client perspective)
- */
-type ClientInferNexusOperationInput<T extends NexusOperationDefinition> = StandardSchemaV1.InferInput<T["input"]>;
-/**
- * Infer output type from a Nexus operation definition (client perspective)
- */
-type ClientInferNexusOperationOutput<T extends NexusOperationDefinition> = StandardSchemaV1.InferOutput<T["output"]>;
-/**
- * Infer the client function signature for a Nexus operation (client perspective)
- *
- * @example
- * ```typescript
- * type ProcessPaymentClient = ClientInferNexusOperationInvoker<typeof processPaymentOperation>;
- * // (args: { amount: number; customerId: string }) => Promise<{ transactionId: string; status: 'success' | 'failed' }>
- * ```
- */
-type ClientInferNexusOperationInvoker<TOperation extends NexusOperationDefinition> = (args: ClientInferNexusOperationInput<TOperation>) => Promise<ClientInferNexusOperationOutput<TOperation>>;
-/**
- * Infer all operation invokers for a Nexus service (client perspective)
- */
-type ClientInferNexusServiceOperations<T extends NexusServiceDefinition> = { [K in keyof T["operations"]]: ClientInferNexusOperationInvoker<T["operations"][K]> };
-/**
- * Infer all Nexus service operations from a contract (client perspective)
- *
- * @example
- * ```typescript
- * type AllNexusOperations = ClientInferNexusServices<typeof myContract>;
- * // {
- * //   PaymentService: { processPayment: ..., refundPayment: ... };
- * //   InventoryService: { reserveItems: ..., releaseItems: ... };
- * // }
- * ```
- */
-type ClientInferNexusServices<TContract extends ContractDefinitionWithNexus> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? { [K in keyof TContract["nexusServices"]]: ClientInferNexusServiceOperations<TContract["nexusServices"][K]> } : {};
-/**
- * UTILITY TYPES
- */
-/**
- * Extract service names from a contract as a union type
- *
- * @example
- * ```typescript
- * type MyServiceNames = InferNexusServiceNames<typeof myContract>;
- * // "PaymentService" | "InventoryService"
- * ```
- */
-type InferNexusServiceNames<TContract extends ContractDefinitionWithNexus> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? keyof TContract["nexusServices"] & string : never;
-/**
- * Extract operation names from a service as a union type
- *
- * @example
- * ```typescript
- * type PaymentOperations = InferNexusOperationNames<typeof myContract, "PaymentService">;
- * // "processPayment" | "refundPayment"
- * ```
- */
-type InferNexusOperationNames<TContract extends ContractDefinitionWithNexus, TServiceName extends InferNexusServiceNames<TContract>> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? keyof TContract["nexusServices"][TServiceName]["operations"] & string : never;
-/**
- * Infer the handler type for a specific Nexus operation (worker perspective)
- *
- * @example
- * ```typescript
- * const processPayment: NexusOperationHandler<
- *   typeof myContract,
- *   "PaymentService",
- *   "processPayment"
- * > = async ({ amount, customerId }) => {
- *   // Implementation
- *   return { transactionId: 'tx-123', status: 'success' };
- * };
- * ```
- */
-type NexusOperationHandler<TContract extends ContractDefinitionWithNexus, TServiceName extends InferNexusServiceNames<TContract>, TOperationName extends InferNexusOperationNames<TContract, TServiceName>> = TContract["nexusServices"] extends Record<string, NexusServiceDefinition> ? (args: WorkerInferNexusOperationInput<TContract["nexusServices"][TServiceName]["operations"][TOperationName]>) => Promise<WorkerInferNexusOperationOutput<TContract["nexusServices"][TServiceName]["operations"][TOperationName]>> : never;
-/**
- * BUILDER FUNCTIONS (Proposed API)
- * These would be added to builder.ts when Nexus support is implemented
- */
-/**
- * Builder for creating Nexus operation definitions
- *
- * @template TOperation - A NexusOperationDefinition containing input and output schemas
- * @param definition - The Nexus operation definition with typed input/output schemas
- * @returns The same definition with preserved types
- *
- * @example
- * ```typescript
- * const processPayment = defineNexusOperation({
- *   input: z.object({ amount: z.number(), customerId: z.string() }),
- *   output: z.object({ transactionId: z.string(), status: z.enum(['success', 'failed']) }),
- * });
- * ```
- */
-declare function defineNexusOperation<TOperation extends NexusOperationDefinition>(definition: TOperation): TOperation;
-/**
- * Builder for creating Nexus service definitions
- *
- * @template TService - A NexusServiceDefinition containing a record of operations
- * @param definition - The Nexus service definition with typed operations
- * @returns The same definition with preserved types
- *
- * @example
- * ```typescript
- * const PaymentService = defineNexusService({
- *   operations: {
- *     processPayment: defineNexusOperation({ ... }),
- *     refundPayment: defineNexusOperation({ ... }),
- *   },
- * });
- * ```
- */
-declare function defineNexusService<TService extends NexusServiceDefinition>(definition: TService): TService;
-//#endregion
-export { type ActivityDefinition, type AnySchema, type ClientInferNexusOperationInput, type ClientInferNexusOperationInvoker, type ClientInferNexusOperationOutput, type ClientInferNexusServiceOperations, type ClientInferNexusServices, type ContractDefinition, type ContractDefinitionWithNexus, type InferActivityNames, type InferContractWorkflows, type InferNexusOperationNames, type InferNexusServiceNames, type InferWorkflowNames, type NexusOperationDefinition, type NexusOperationHandler, type NexusServiceDefinition, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferNexusOperationHandler, type WorkerInferNexusOperationInput, type WorkerInferNexusOperationOutput, type WorkerInferNexusServiceHandlers, type WorkerInferNexusServices, type WorkflowDefinition, defineActivity, defineContract, defineNexusOperation, defineNexusService, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+export { type ActivityDefinition, type AnySchema, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/builder.ts"],"mappings":";;;;;AAOA;;;KAAY,SAAA,GAAY,gBAAA;;AAKxB;;KAAY,kBAAA,gBACK,SAAA,GAAY,SAAA,kBACX,SAAA,GAAY,SAAA;EAAA,SAEnB,KAAA,EAAO,MAAA;EAAA,SACP,MAAA,EAAQ,OAAA;AAAA;;;;KAMP,gBAAA,gBAAgC,SAAA,GAAY,SAAA;EAAA,SAC7C,KAAA,EAAO,MAAA;AAAA;;;;KAMN,eAAA,gBACK,SAAA,GAAY,SAAA,kBACX,SAAA,GAAY,SAAA;EAAA,SAEnB,KAAA,EAAO,MAAA;EAAA,SACP,MAAA,EAAQ,OAAA;AAAA;;;;KAMP,gBAAA,gBACK,SAAA,GAAY,SAAA,kBACX,SAAA,GAAY,SAAA;EAAA,SAEnB,KAAA,EAAO,MAAA;EAAA,SACP,MAAA,EAAQ,OAAA;AAAA;;;;KAMP,kBAAA,qBACU,MAAA,SAAe,kBAAA,IAAsB,MAAA,SAAe,kBAAA,oBACvD,MAAA,SAAe,gBAAA,IAAoB,MAAA,SAAe,gBAAA,oBAClD,MAAA,SAAe,eAAA,IAAmB,MAAA,SAAe,eAAA,oBACjD,MAAA,SAAe,gBAAA,IAAoB,MAAA,SAAe,gBAAA;EAAA,SAE1D,KAAA,EAAO,SAAA;EAAA,SACP,MAAA,EAAQ,SAAA;EAAA,SACR,UAAA,GAAa,WAAA;EAAA,SACb,OAAA,GAAU,QAAA;EAAA,SACV,OAAA,GAAU,QAAA;EAAA,SACV,OAAA,GAAU,QAAA;AAAA;;AAjCrB;;KAuCY,kBAAA,oBACS,MAAA,SAAe,kBAAA,IAAsB,MAAA,SAAe,kBAAA,uBACnD,MAAA,SAAe,kBAAA,IAAsB,MAAA,SAAe,kBAAA;EAAA,SAE/D,SAAA;EAAA,SACA,SAAA,EAAW,UAAA;EAAA,SACX,UAAA,GAAa,WAAA;AAAA;;;;;;;;;;;;;KAgBZ,kBAAA,mBAAqC,kBAAA,UACzC,SAAA;;;;AAnDR;;;;;;KA8DY,kBAAA,mBAAqC,kBAAA,IAC/C,SAAA,uBAAgC,MAAA,SAAe,kBAAA,UACrC,SAAA;;;;;;;;;KAWA,sBAAA,mBAAyC,kBAAA,IAAsB,SAAA;;;;;AA7G3E;;;;;AAKA;;;;;;;;;;;;;;;;;;;;;;iBC8BgB,cAAA,mBAAiC,kBAAA,CAAA,CAC/C,UAAA,EAAY,SAAA,GACX,SAAA;ADrBH;;;;;;;;;;;;;;;AAOA;;;;;;;;AAPA,iBCgDgB,YAAA,iBAA6B,gBAAA,CAAA,CAAkB,UAAA,EAAY,OAAA,GAAU,OAAA;;;;;;;;;;;;;;;AD9BrF;;;;;;;;;;iBC0DgB,WAAA,gBAA2B,eAAA,CAAA,CAAiB,UAAA,EAAY,MAAA,GAAS,MAAA;;;;;;;;;;;;;AD/CjF;;;;;;;;;;;;;;;;iBC+EgB,YAAA,iBAA6B,gBAAA,CAAA,CAAkB,UAAA,EAAY,OAAA,GAAU,OAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqCrE,cAAA,mBAAiC,kBAAA,CAAA,CAC/C,UAAA,EAAY,SAAA,GACX,SAAA;;;;;;;;;;;ADrGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA;;;;;;;;;iBCsIgB,cAAA,mBAAiC,kBAAA,CAAA,CAC/C,UAAA,EAAY,SAAA,GACX,SAAA"}

package/dist/index.mjs

@@ -227,21 +227,21 @@ function isStandardSchema(value) {
 */
 const identifierSchema = z.string().min(1).regex(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/, "must be a valid JavaScript identifier");
 /**
-* Extract clean error message from Zod validation error
+* Extract a clean, single-line error message from a Zod validation error.
+*
+* Uses `error.issues` directly (compatible with Zod v4+) rather than parsing
+* `error.message` as JSON, which was a Zod v3 implementation detail.
 */
 function getCleanErrorMessage(error) {
-	try {
-		const parsed = JSON.parse(error.message);
-		if (Array.isArray(parsed) && parsed.length > 0) {
-			const firstError = parsed[0];
-			if (firstError?.code === "invalid_key" && firstError?.issues && firstError.issues.length > 0) {
-				const nestedError = firstError.issues[0];
-				if (nestedError?.message) return nestedError.message;
-			}
-			if (firstError?.message) return firstError.message;
-		}
-	} catch {}
-	return error.message;
+	const issues = error.issues;
+	if (!issues || issues.length === 0) return error.message;
+	const firstIssue = issues[0];
+	if (!firstIssue) return error.message;
+	if (firstIssue.code === "invalid_key" && "issues" in firstIssue && Array.isArray(firstIssue.issues) && firstIssue.issues.length > 0) {
+		const nestedMessage = firstIssue.issues[0]?.message;
+		if (nestedMessage) return nestedMessage;
+	}
+	return firstIssue.message ?? error.message;
 }
 /**
 * Schema for validating activity definitions
@@ -301,118 +301,5 @@ const contractValidationSchema = z.object({
 });
 
 //#endregion
-//#region src/nexus-types.ts
-/**
-* BUILDER FUNCTIONS (Proposed API)
-* These would be added to builder.ts when Nexus support is implemented
-*/
-/**
-* Builder for creating Nexus operation definitions
-*
-* @template TOperation - A NexusOperationDefinition containing input and output schemas
-* @param definition - The Nexus operation definition with typed input/output schemas
-* @returns The same definition with preserved types
-*
-* @example
-* ```typescript
-* const processPayment = defineNexusOperation({
-*   input: z.object({ amount: z.number(), customerId: z.string() }),
-*   output: z.object({ transactionId: z.string(), status: z.enum(['success', 'failed']) }),
-* });
-* ```
-*/
-function defineNexusOperation(definition) {
-	return definition;
-}
-/**
-* Builder for creating Nexus service definitions
-*
-* @template TService - A NexusServiceDefinition containing a record of operations
-* @param definition - The Nexus service definition with typed operations
-* @returns The same definition with preserved types
-*
-* @example
-* ```typescript
-* const PaymentService = defineNexusService({
-*   operations: {
-*     processPayment: defineNexusOperation({ ... }),
-*     refundPayment: defineNexusOperation({ ... }),
-*   },
-* });
-* ```
-*/
-function defineNexusService(definition) {
-	return definition;
-}
-/**
-* USAGE EXAMPLE
-*
-* This example demonstrates the complete type-safe Nexus workflow:
-*
-* ```typescript
-* import { defineContract, defineNexusService, defineNexusOperation } from '@temporal-contract/contract';
-* import { z } from 'zod';
-*
-* // 1. Define contract with Nexus service
-* const paymentContract = defineContract({
-*   taskQueue: 'payments',
-*   workflows: { ... },
-*   nexusServices: {
-*     PaymentService: defineNexusService({
-*       operations: {
-*         processPayment: defineNexusOperation({
-*           input: z.object({
-*             amount: z.number().positive(),
-*             customerId: z.string().uuid(),
-*           }),
-*           output: z.object({
-*             transactionId: z.string(),
-*             status: z.enum(['success', 'failed']),
-*           }),
-*         }),
-*       },
-*     }),
-*   },
-* });
-*
-* // 2. Worker implementation (type-safe handlers)
-* import { createNexusHandlers } from '@temporal-contract/worker';
-*
-* const nexusHandlers = createNexusHandlers(paymentContract, {
-*   PaymentService: {
-*     processPayment: async ({ amount, customerId }) => {
-*       // ✅ Fully typed parameters
-*       // ✅ Input automatically validated
-*       const payment = await processPaymentInDatabase(customerId, amount);
-*       // ✅ Return value validated against schema
-*       return {
-*         transactionId: payment.id,
-*         status: 'success',
-*       };
-*     },
-*   },
-* });
-*
-* // 3. Client usage (type-safe invocation)
-* import { createNexusClient } from '@temporal-contract/client';
-*
-* const nexusClient = createNexusClient<typeof paymentContract>(connection, {
-*   namespace: 'payments-ns',
-* });
-*
-* // ✅ Fully typed invocation
-* const result = await nexusClient.invoke('PaymentService', 'processPayment', {
-*   amount: 100,
-*   customerId: 'cust-123',
-* });
-*
-* // ❌ TypeScript errors caught at compile time
-* await nexusClient.invoke('PaymentService', 'processPayment', {
-*   amount: -50, // Error: amount must be positive
-*   customerId: 'invalid', // Error: customerId must be UUID
-* });
-* ```
-*/
-
-//#endregion
-export { defineActivity, defineContract, defineNexusOperation, defineNexusService, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+export { defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/builder.ts"],"sourcesContent":["import { z } from \"zod\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type {\n  ActivityDefinition,\n  ContractDefinition,\n  QueryDefinition,\n  SignalDefinition,\n  UpdateDefinition,\n  WorkflowDefinition,\n} from \"./types.js\";\n\n// Exported builders first (classic functions for hoisting)\n\n/**\n * Define a Temporal activity with type-safe input and output schemas.\n *\n * Activities are the building blocks of Temporal workflows that execute business logic\n * and interact with external services. This function preserves TypeScript types while\n * providing a consistent structure for activity definitions.\n *\n * @template TActivity - The activity definition type with input/output schemas\n * @param definition - The activity definition containing input and output schemas\n * @returns The same definition with preserved types for type inference\n *\n * @example\n * ```typescript\n * import { defineActivity } from '@temporal-contract/contract';\n * import { z } from 'zod';\n *\n * export const sendEmail = defineActivity({\n *   input: z.object({\n *     to: z.string().email(),\n *     subject: z.string(),\n *     body: z.string(),\n *   }),\n *   output: z.object({\n *     messageId: z.string(),\n *     sentAt: z.date(),\n *   }),\n * });\n * ```\n */\nexport function defineActivity<TActivity extends ActivityDefinition>(\n  definition: TActivity,\n): TActivity {\n  return definition;\n}\n\n/**\n * Define a Temporal signal with type-safe input schema.\n *\n * Signals are asynchronous messages sent to running workflows to update their state\n * or trigger certain behaviors. This function ensures type safety for signal payloads.\n *\n * @template TSignal - The signal definition type with input schema\n * @param definition - The signal definition containing input schema\n * @returns The same definition with preserved types for type inference\n *\n * @example\n * ```typescript\n * import { defineSignal } from '@temporal-contract/contract';\n * import { z } from 'zod';\n *\n * export const approveOrder = defineSignal({\n *   input: z.object({\n *     orderId: z.string(),\n *     approvedBy: z.string(),\n *   }),\n * });\n * ```\n */\nexport function defineSignal<TSignal extends SignalDefinition>(definition: TSignal): TSignal {\n  return definition;\n}\n\n/**\n * Define a Temporal query with type-safe input and output schemas.\n *\n * Queries allow you to read the current state of a running workflow without\n * modifying it. They are synchronous and should not perform any mutations.\n *\n * @template TQuery - The query definition type with input/output schemas\n * @param definition - The query definition containing input and output schemas\n * @returns The same definition with preserved types for type inference\n *\n * @example\n * ```typescript\n * import { defineQuery } from '@temporal-contract/contract';\n * import { z } from 'zod';\n *\n * export const getOrderStatus = defineQuery({\n *   input: z.object({ orderId: z.string() }),\n *   output: z.object({\n *     status: z.enum(['pending', 'processing', 'completed', 'failed']),\n *     updatedAt: z.date(),\n *   }),\n * });\n * ```\n */\nexport function defineQuery<TQuery extends QueryDefinition>(definition: TQuery): TQuery {\n  return definition;\n}\n\n/**\n * Define a Temporal update with type-safe input and output schemas.\n *\n * Updates are similar to signals but return a value and wait for the workflow\n * to process them before completing. They provide a synchronous way to modify\n * workflow state and get immediate feedback.\n *\n * @template TUpdate - The update definition type with input/output schemas\n * @param definition - The update definition containing input and output schemas\n * @returns The same definition with preserved types for type inference\n *\n * @example\n * ```typescript\n * import { defineUpdate } from '@temporal-contract/contract';\n * import { z } from 'zod';\n *\n * export const updateOrderQuantity = defineUpdate({\n *   input: z.object({\n *     orderId: z.string(),\n *     newQuantity: z.number().positive(),\n *   }),\n *   output: z.object({\n *     success: z.boolean(),\n *     totalPrice: z.number(),\n *   }),\n * });\n * ```\n */\nexport function defineUpdate<TUpdate extends UpdateDefinition>(definition: TUpdate): TUpdate {\n  return definition;\n}\n\n/**\n * Define a Temporal workflow with type-safe input, output, and associated operations.\n *\n * Workflows are durable functions that orchestrate activities, handle timeouts,\n * and manage long-running processes. This function provides type safety for the\n * entire workflow definition including activities, signals, queries, and updates.\n *\n * @template TWorkflow - The workflow definition type with all associated schemas\n * @param definition - The workflow definition containing input, output, and operations\n * @returns The same definition with preserved types for type inference\n *\n * @example\n * ```typescript\n * import { defineWorkflow, defineActivity, defineSignal } from '@temporal-contract/contract';\n * import { z } from 'zod';\n *\n * export const processOrder = defineWorkflow({\n *   input: z.object({ orderId: z.string() }),\n *   output: z.object({ success: z.boolean() }),\n *   activities: {\n *     validatePayment: defineActivity({\n *       input: z.object({ orderId: z.string() }),\n *       output: z.object({ valid: z.boolean() }),\n *     }),\n *   },\n *   signals: {\n *     cancel: defineSignal({\n *       input: z.object({ reason: z.string() }),\n *     }),\n *   },\n * });\n * ```\n */\nexport function defineWorkflow<TWorkflow extends WorkflowDefinition>(\n  definition: TWorkflow,\n): TWorkflow {\n  return definition;\n}\n\n/**\n * Define a complete Temporal contract with type-safe workflows and activities.\n *\n * A contract is the central definition that ties together your Temporal application's\n * workflows and activities. It provides:\n * - Type safety across client, worker, and workflow code\n * - Automatic validation at runtime\n * - Compile-time verification of implementations\n * - Clear API boundaries and documentation\n *\n * The contract validates the structure and ensures:\n * - Task queue is specified\n * - At least one workflow is defined\n * - Valid JavaScript identifiers are used\n * - No conflicts between global and workflow-specific activities\n * - All schemas implement the Standard Schema specification\n *\n * @template TContract - The contract definition type\n * @param definition - The complete contract definition\n * @returns The same definition with preserved types for type inference\n * @throws {Error} If the contract structure is invalid\n *\n * @example\n * ```typescript\n * import { defineContract } from '@temporal-contract/contract';\n * import { z } from 'zod';\n *\n * export const myContract = defineContract({\n *   taskQueue: 'orders',\n *   workflows: {\n *     processOrder: {\n *       input: z.object({ orderId: z.string() }),\n *       output: z.object({ success: z.boolean() }),\n *       activities: {\n *         chargePayment: {\n *           input: z.object({ amount: z.number() }),\n *           output: z.object({ transactionId: z.string() }),\n *         },\n *       },\n *     },\n *   },\n *   // Optional global activities shared across workflows\n *   activities: {\n *     logEvent: {\n *       input: z.object({ message: z.string() }),\n *       output: z.void(),\n *     },\n *   },\n * });\n * ```\n */\nexport function defineContract<TContract extends ContractDefinition>(\n  definition: TContract,\n): TContract {\n  // Validate entire contract structure with Zod (including activity conflicts)\n  const validationResult = contractValidationSchema.safeParse(definition);\n\n  if (!validationResult.success) {\n    const cleanMessage = getCleanErrorMessage(validationResult.error);\n    throw new Error(`Contract validation failed: ${cleanMessage}`);\n  }\n\n  return definition;\n}\n\n/**\n * Check if a value is a Standard Schema compatible schema\n */\nfunction isStandardSchema(value: unknown): value is StandardSchemaV1 {\n  // Standard Schema can be either an object or a function (e.g., ArkType)\n  if (\n    (typeof value !== \"object\" && typeof value !== \"function\") ||\n    value === null ||\n    !(\"~standard\" in value)\n  ) {\n    return false;\n  }\n\n  const standard = (value as Record<string, unknown>)[\"~standard\"];\n\n  return (\n    typeof standard === \"object\" &&\n    standard !== null &&\n    (standard as Record<string, unknown>)[\"version\"] === 1 &&\n    typeof (standard as Record<string, unknown>)[\"validate\"] === \"function\"\n  );\n}\n\n/**\n * Schema for validating JavaScript identifiers (workflow names, activity names, etc.)\n * Allows: letters, digits, underscore, dollar sign\n * Must start with: letter, underscore, or dollar sign\n */\nconst identifierSchema = z\n  .string()\n  .min(1)\n  .regex(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/, \"must be a valid JavaScript identifier\");\n\n/**\n * Extract a clean, single-line error message from a Zod validation error.\n *\n * Uses `error.issues` directly (compatible with Zod v4+) rather than parsing\n * `error.message` as JSON, which was a Zod v3 implementation detail.\n */\nfunction getCleanErrorMessage(error: z.ZodError): string {\n  const issues = error.issues;\n  if (!issues || issues.length === 0) {\n    return error.message;\n  }\n\n  const firstIssue = issues[0];\n  if (!firstIssue) {\n    return error.message;\n  }\n\n  // For record key validation errors (invalid_key), surface the nested issue message\n  if (\n    firstIssue.code === \"invalid_key\" &&\n    \"issues\" in firstIssue &&\n    Array.isArray((firstIssue as { issues?: unknown[] }).issues) &&\n    (firstIssue as { issues: { message?: string }[] }).issues.length > 0\n  ) {\n    const nestedMessage = (firstIssue as { issues: { message?: string }[] }).issues[0]?.message;\n    if (nestedMessage) {\n      return nestedMessage;\n    }\n  }\n\n  return firstIssue.message ?? error.message;\n}\n\n/**\n * Schema for validating activity definitions\n * Checks that input and output are Standard Schema compatible schemas\n */\nconst activityDefinitionSchema = z.object({\n  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n});\n\n/**\n * Schema for validating signal definitions\n */\nconst signalDefinitionSchema = z.object({\n  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n});\n\n/**\n * Schema for validating query definitions\n */\nconst queryDefinitionSchema = z.object({\n  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n});\n\n/**\n * Schema for validating update definitions\n */\nconst updateDefinitionSchema = z.object({\n  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n});\n\n/**\n * Schema for validating workflow definitions\n */\nconst workflowDefinitionSchema = z.object({\n  input: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"input must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n  output: z.custom<StandardSchemaV1>((val) => isStandardSchema(val), {\n    message: \"output must be a Standard Schema compatible schema (e.g., Zod, Valibot, ArkType)\",\n  }),\n  activities: z.record(identifierSchema, activityDefinitionSchema).optional(),\n  signals: z.record(identifierSchema, signalDefinitionSchema).optional(),\n  queries: z.record(identifierSchema, queryDefinitionSchema).optional(),\n  updates: z.record(identifierSchema, updateDefinitionSchema).optional(),\n});\n\n/**\n * Schema for validating a contract definition structure\n */\nconst contractValidationSchema = z\n  .object({\n    taskQueue: z.string().trim().min(1, \"taskQueue cannot be empty\"),\n    workflows: z\n      .record(identifierSchema, workflowDefinitionSchema)\n      .refine((workflows) => Object.keys(workflows).length > 0, {\n        message: \"at least one workflow is required\",\n      }),\n    activities: z.record(identifierSchema, activityDefinitionSchema).optional(),\n  })\n  .superRefine((contract, ctx) => {\n    // Check for conflicts between global and workflow-specific activities\n    if (!contract.activities) {\n      return;\n    }\n\n    for (const [workflowName, workflow] of Object.entries(contract.workflows)) {\n      if (workflow.activities) {\n        for (const activityName of Object.keys(workflow.activities)) {\n          if (activityName in contract.activities) {\n            ctx.addIssue({\n              code: z.ZodIssueCode.custom,\n              message: `workflow \"${workflowName}\" has activity \"${activityName}\" that conflicts with a global activity. Consider renaming the workflow-specific activity or removing the global activity \"${activityName}\".`,\n            });\n            return;\n          }\n        }\n      }\n    }\n  });\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temporal-contract/contract",
-  "version": "0.0.7",
+  "version": "0.2.0",
   "description": "Contract builder for temporal-contract",
   "keywords": [
     "contract",
@@ -40,19 +40,23 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "1.1.0",
-    "zod": "4.2.1"
+    "zod": "4.3.6"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "4.0.16",
+    "@vitest/coverage-v8": "4.0.18",
     "arktype": "2.1.29",
-    "tsdown": "0.18.1",
+    "tsdown": "0.20.3",
+    "typedoc": "0.28.17",
+    "typedoc-plugin-markdown": "4.10.0",
     "typescript": "5.9.3",
     "valibot": "1.2.0",
-    "vitest": "4.0.16",
-    "@temporal-contract/tsconfig": "0.0.7"
+    "vitest": "4.0.18",
+    "@temporal-contract/tsconfig": "0.2.0",
+    "@temporal-contract/typedoc": "0.1.0"
   },
   "scripts": {
     "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
+    "build:docs": "typedoc",
     "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
     "test": "vitest run",
     "test:watch": "vitest",