@temporal-contract/contract 0.0.3 → 0.0.4

package/dist/index.cjs

@@ -189,9 +189,125 @@ const defineContract = (definition) => {
 	return definition;
 };
 
+//#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

@@ -349,4 +349,228 @@ declare const defineWorkflow: <TWorkflow extends WorkflowDefinition>(definition:
  */
 declare const defineContract: <TContract extends ContractDefinition>(definition: TContract) => TContract;
 //#endregion
-export { type ActivityDefinition, type ActivityHandler, type AnySchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+//#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 ActivityHandler, type AnySchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferNexusOperationInput, type ClientInferNexusOperationInvoker, type ClientInferNexusOperationOutput, type ClientInferNexusServiceOperations, type ClientInferNexusServices, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, 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 WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferNexusOperationHandler, type WorkerInferNexusOperationInput, type WorkerInferNexusOperationOutput, type WorkerInferNexusServiceHandlers, type WorkerInferNexusServices, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineNexusOperation, defineNexusService, defineQuery, defineSignal, defineUpdate, defineWorkflow };

package/dist/index.d.mts

@@ -349,4 +349,228 @@ declare const defineWorkflow: <TWorkflow extends WorkflowDefinition>(definition:
  */
 declare const defineContract: <TContract extends ContractDefinition>(definition: TContract) => TContract;
 //#endregion
-export { type ActivityDefinition, type ActivityHandler, type AnySchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, type ContractDefinition, type InferActivityNames, type InferContractWorkflows, type InferWorkflowNames, type QueryDefinition, type SignalDefinition, type UpdateDefinition, type WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+//#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 ActivityHandler, type AnySchema, type ClientInferActivities, type ClientInferActivity, type ClientInferInput, type ClientInferNexusOperationInput, type ClientInferNexusOperationInvoker, type ClientInferNexusOperationOutput, type ClientInferNexusServiceOperations, type ClientInferNexusServices, type ClientInferOutput, type ClientInferQuery, type ClientInferSignal, type ClientInferUpdate, type ClientInferWorkflow, type ClientInferWorkflowActivities, type ClientInferWorkflowContextActivities, type ClientInferWorkflowQueries, type ClientInferWorkflowSignals, type ClientInferWorkflowUpdates, type ClientInferWorkflows, 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 WorkerInferActivities, type WorkerInferActivity, type WorkerInferInput, type WorkerInferNexusOperationHandler, type WorkerInferNexusOperationInput, type WorkerInferNexusOperationOutput, type WorkerInferNexusServiceHandlers, type WorkerInferNexusServices, type WorkerInferOutput, type WorkerInferQuery, type WorkerInferSignal, type WorkerInferUpdate, type WorkerInferWorkflow, type WorkerInferWorkflowActivities, type WorkerInferWorkflowContextActivities, type WorkerInferWorkflowQueries, type WorkerInferWorkflowSignals, type WorkerInferWorkflowUpdates, type WorkerInferWorkflows, type WorkflowActivityHandler, type WorkflowDefinition, defineActivity, defineContract, defineNexusOperation, defineNexusService, defineQuery, defineSignal, defineUpdate, defineWorkflow };

package/dist/index.mjs

@@ -190,4 +190,118 @@ const defineContract = (definition) => {
 };
 
 //#endregion
-export { defineActivity, defineContract, defineQuery, defineSignal, defineUpdate, defineWorkflow };
+//#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 };

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@temporal-contract/contract",
-  "version": "0.0.3",
-  "type": "module",
+  "version": "0.0.4",
   "description": "Contract builder for temporal-contract",
+  "keywords": [
+    "temporal",
+    "typescript",
+    "contract"
+  ],
   "homepage": "https://github.com/btravers/temporal-contract#readme",
   "bugs": {
     "url": "https://github.com/btravers/temporal-contract/issues"
@@ -12,16 +16,9 @@
     "url": "https://github.com/btravers/temporal-contract.git",
     "directory": "packages/contract"
   },
-  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
   "license": "MIT",
-  "keywords": [
-    "temporal",
-    "typescript",
-    "contract"
-  ],
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
+  "author": "Benoit TRAVERS <benoit.travers.frgmail.com>",
+  "type": "module",
   "exports": {
     ".": {
       "import": {
@@ -35,6 +32,9 @@
     },
     "./package.json": "./package.json"
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "files": [
     "dist"
   ],
@@ -45,17 +45,17 @@
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.15",
     "arktype": "2.1.28",
-    "tsdown": "0.17.2",
+    "tsdown": "0.17.3",
     "typescript": "5.9.3",
     "valibot": "1.2.0",
     "vitest": "4.0.15",
-    "@temporal-contract/tsconfig": "0.0.3"
+    "@temporal-contract/tsconfig": "0.0.4"
   },
   "scripts": {
-    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
     "build": "tsdown src/index.ts --format cjs,esm --dts --clean",
-    "typecheck": "tsc --noEmit",
+    "dev": "tsdown src/index.ts --format cjs,esm --dts --watch",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
   }
 }