ts-procedures 6.2.0 → 7.0.0-beta.0

package/src/codegen/emit-scope.ts

@@ -246,28 +246,57 @@ async function emitRpcRoute(route: RPCHttpRouteDoc, ctx: EmitRouteContext): Prom
   const responseTypeName = refs['Response'] ?? 'unknown'
   const scopeStr = Array.isArray(route.scope) ? route.scope.join('-') : route.scope
 
+  // Compute the error union once — used for both the .safe return type and
+  // injectRouteErrors. Use errorUnion !== null (not route.errors?.length) so
+  // we only emit Result<…, Errors> when keys were actually emitted in _errors.ts.
+  const errorUnion = buildErrorUnion(route.errors, ctx)
+  const hasErrors = errorUnion !== null
+  const errorsRef = ctx.namespaceTypes
+    ? `${ctx.scopePascal}.${pascal}.Errors`
+    : `${pascal}Errors`
+  const resultType = hasErrors
+    ? `Result<${responseTypeName}, ${errorsRef}>`
+    : `ResultNoTyped<${responseTypeName}>`
+
+  // When no typed errors, cast Result<T, never> → ResultNoTyped<T> so consumers
+  // see the simpler type in their IDE. The cast is safe: Result<T, never> has an
+  // unreachable `kind: 'typed'` arm that ResultNoTyped intentionally omits.
+  const safeReturn = hasErrors
+    ? `return client.safeCall<${responseTypeName}, ${errorsRef}>({`
+    : `return client.safeCall<${responseTypeName}>({`
+  const safeResultCast = hasErrors ? '' : ` as Promise<${resultType}>`
+
   const callable = [
     `    /** ${route.method.toUpperCase()} ${route.path} */`,
-    `    ${pascal}(params: ${paramsTypeName}, options?: ProcedureCallOptions): Promise<${responseTypeName}> {`,
-    `      return client.call<${responseTypeName}>({`,
-    `        name: '${pascal}',`,
-    `        scope: '${scopeStr}',`,
-    `        path: '${route.path}',`,
-    `        method: '${route.method}',`,
-    `        kind: 'rpc',`,
-    `        params,`,
-    `      }, options)`,
-    `    },`,
+    `    ${pascal}: Object.assign(`,
+    `      function ${pascal}(params: ${paramsTypeName}, options?: ProcedureCallOptions): Promise<${responseTypeName}> {`,
+    `        return client.call<${responseTypeName}>({`,
+    `          name: '${pascal}',`,
+    `          scope: '${scopeStr}',`,
+    `          path: '${route.path}',`,
+    `          method: '${route.method}',`,
+    `          kind: 'rpc',`,
+    `          params,`,
+    `        }, options)`,
+    `      },`,
+    `      {`,
+    `        safe(params: ${paramsTypeName}, options?: ProcedureCallOptions): Promise<${resultType}> {`,
+    `          ${safeReturn}`,
+    `            name: '${pascal}',`,
+    `            scope: '${scopeStr}',`,
+    `            path: '${route.path}',`,
+    `            method: '${route.method}',`,
+    `            kind: 'rpc',`,
+    `            params,`,
+    `          }, options)${safeResultCast}`,
+    `        },`,
+    `      },`,
+    `    ),`,
   ].join('\n')
 
-  const hasErrors = injectRouteErrors(
-    declarations,
-    pascal,
-    buildErrorUnion(route.errors, ctx),
-    ctx.namespaceTypes
-  )
+  const hasErrorsInjected = injectRouteErrors(declarations, pascal, errorUnion, ctx.namespaceTypes)
 
-  return { typeDeclarations: declarations, callable, hasStream: false, hasErrors }
+  return { typeDeclarations: declarations, callable, hasStream: false, hasErrors: hasErrorsInjected }
 }
 
 async function emitApiRoute(route: APIHttpRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
@@ -323,28 +352,61 @@ async function emitApiRoute(route: APIHttpRouteDoc, ctx: EmitRouteContext): Prom
   const responseTypeName = refs['Response'] ?? 'unknown'
   const scopeStr = route.scope ?? 'default'
 
+  // Compute the error union once — used for both the .safe return type and
+  // injectRouteErrors. Use errorUnion !== null (not route.errors?.length) so
+  // we only emit Result<…, Errors> when keys were actually emitted in _errors.ts.
+  const errorUnion = buildErrorUnion(route.errors, ctx)
+  const hasErrors = errorUnion !== null
+  const errorsRef = ctx.namespaceTypes
+    ? `${ctx.scopePascal}.${pascal}.Errors`
+    : `${pascal}Errors`
+  const resultType = hasErrors
+    ? `Result<${responseTypeName}, ${errorsRef}>`
+    : `ResultNoTyped<${responseTypeName}>`
+
+  // When no typed errors, cast Result<T, never> → ResultNoTyped<T> so consumers
+  // see the simpler type in their IDE. The cast is safe: Result<T, never> has an
+  // unreachable `kind: 'typed'` arm that ResultNoTyped intentionally omits.
+  const safeReturn = hasErrors
+    ? `return client.safeCall<${responseTypeName}, ${errorsRef}>({`
+    : `return client.safeCall<${responseTypeName}>({`
+  const safeResultCast = hasErrors ? '' : ` as Promise<${resultType}>`
+
+  // Property key uses route.name verbatim (preserving the prior API
+  // emission contract). Function name uses route.name as well — JS function
+  // names accept any identifier, and matching the property key avoids any
+  // surprise asymmetry in stack traces.
   const callable = [
     `    /** ${route.method.toUpperCase()} ${route.fullPath} */`,
-    `    ${route.name}(params: ${paramsTypeName}, options?: ProcedureCallOptions): Promise<${responseTypeName}> {`,
-    `      return client.call<${responseTypeName}>({`,
-    `        name: '${route.name}',`,
-    `        scope: '${scopeStr}',`,
-    `        path: '${route.fullPath}',`,
-    `        method: '${route.method}',`,
-    `        kind: 'api',`,
-    `        params,`,
-    `      }, options)`,
-    `    },`,
+    `    ${route.name}: Object.assign(`,
+    `      function ${route.name}(params: ${paramsTypeName}, options?: ProcedureCallOptions): Promise<${responseTypeName}> {`,
+    `        return client.call<${responseTypeName}>({`,
+    `          name: '${route.name}',`,
+    `          scope: '${scopeStr}',`,
+    `          path: '${route.fullPath}',`,
+    `          method: '${route.method}',`,
+    `          kind: 'api',`,
+    `          params,`,
+    `        }, options)`,
+    `      },`,
+    `      {`,
+    `        safe(params: ${paramsTypeName}, options?: ProcedureCallOptions): Promise<${resultType}> {`,
+    `          ${safeReturn}`,
+    `            name: '${route.name}',`,
+    `            scope: '${scopeStr}',`,
+    `            path: '${route.fullPath}',`,
+    `            method: '${route.method}',`,
+    `            kind: 'api',`,
+    `            params,`,
+    `          }, options)${safeResultCast}`,
+    `        },`,
+    `      },`,
+    `    ),`,
   ].join('\n')
 
-  const hasErrors = injectRouteErrors(
-    declarations,
-    pascal,
-    buildErrorUnion(route.errors, ctx),
-    ctx.namespaceTypes
-  )
+  const hasErrorsInjected = injectRouteErrors(declarations, pascal, errorUnion, ctx.namespaceTypes)
 
-  return { typeDeclarations: declarations, callable, hasStream: false, hasErrors }
+  return { typeDeclarations: declarations, callable, hasStream: false, hasErrors: hasErrorsInjected }
 }
 
 async function emitStreamRoute(route: StreamHttpRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
@@ -458,8 +520,8 @@ export async function emitScopeFile(
 
   // Build client import line
   const clientImports = hasStream
-    ? `import type { ClientInstance, ProcedureCallOptions, TypedStream } from '${clientImportPath}'`
-    : `import type { ClientInstance, ProcedureCallOptions } from '${clientImportPath}'`
+    ? `import type { ClientInstance, ProcedureCallOptions, TypedStream, Result, ResultNoTyped } from '${clientImportPath}'`
+    : `import type { ClientInstance, ProcedureCallOptions, Result, ResultNoTyped } from '${clientImportPath}'`
 
   // Build _errors import line when at least one route emits an Errors union.
   // Namespace mode uses the qualified `${Service}Errors` namespace; flat mode