ts-procedures 7.0.0-beta.0 → 7.0.0

package/src/codegen/emit-scope.ts

@@ -246,52 +246,24 @@ 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 helperCall = hasErrors
+    ? `client.bindCallableTyped<${paramsTypeName}, ${responseTypeName}, ${errorsRef}>`
+    : `client.bindCallable<${paramsTypeName}, ${responseTypeName}>`
 
   const callable = [
     `    /** ${route.method.toUpperCase()} ${route.path} */`,
-    `    ${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}`,
-    `        },`,
-    `      },`,
-    `    ),`,
+    `    ${pascal}: ${helperCall}({`,
+    `      name: '${pascal}',`,
+    `      scope: '${scopeStr}',`,
+    `      path: '${route.path}',`,
+    `      method: '${route.method}',`,
+    `      kind: 'rpc',`,
+    `    }),`,
   ].join('\n')
 
   const hasErrorsInjected = injectRouteErrors(declarations, pascal, errorUnion, ctx.namespaceTypes)
@@ -352,56 +324,25 @@ 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 helperCall = hasErrors
+    ? `client.bindCallableTyped<${paramsTypeName}, ${responseTypeName}, ${errorsRef}>`
+    : `client.bindCallable<${paramsTypeName}, ${responseTypeName}>`
+
+  // Property key uses route.name verbatim (preserving the prior API emission contract).
   const callable = [
     `    /** ${route.method.toUpperCase()} ${route.fullPath} */`,
-    `    ${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}`,
-    `        },`,
-    `      },`,
-    `    ),`,
+    `    ${route.name}: ${helperCall}({`,
+    `      name: '${route.name}',`,
+    `      scope: '${scopeStr}',`,
+    `      path: '${route.fullPath}',`,
+    `      method: '${route.method}',`,
+    `      kind: 'api',`,
+    `    }),`,
   ].join('\n')
 
   const hasErrorsInjected = injectRouteErrors(declarations, pascal, errorUnion, ctx.namespaceTypes)
@@ -518,10 +459,11 @@ export async function emitScopeFile(
     if (chunks.hasErrors) scopeHasErrors = true
   }
 
-  // Build client import line
+  // Build client import line — Result/ResultNoTyped are no longer referenced
+  // directly in scope files; the bindCallable helpers infer them from ClientInstance.
   const clientImports = hasStream
-    ? `import type { ClientInstance, ProcedureCallOptions, TypedStream, Result, ResultNoTyped } from '${clientImportPath}'`
-    : `import type { ClientInstance, ProcedureCallOptions, Result, ResultNoTyped } from '${clientImportPath}'`
+    ? `import type { ClientInstance, ProcedureCallOptions, TypedStream } from '${clientImportPath}'`
+    : `import type { ClientInstance, ProcedureCallOptions } 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