ts-procedures 6.2.0 → 7.0.0-beta.1

package/src/codegen/emit-scope.test.ts

@@ -291,10 +291,10 @@ describe('emitScopeFile', () => {
       expect(output).toContain('export function bindUsersScope(client: ClientInstance)')
     })
 
-    it('callable uses client.call with kind: rpc', async () => {
+    it('callable uses client.bindCallable with kind: rpc', async () => {
       const output = await emitScopeFile(rpcGroup)
       expect(output).toContain("kind: 'rpc'")
-      expect(output).toContain('client.call')
+      expect(output).toContain('client.bindCallable<')
     })
 
     it('callable includes JSDoc with method and path', async () => {
@@ -323,10 +323,10 @@ describe('emitScopeFile', () => {
       expect(output).toContain('export type UpdatePostResponse')
     })
 
-    it('callable uses client.call with kind: api', async () => {
+    it('callable uses client.bindCallable with kind: api', async () => {
       const output = await emitScopeFile(apiGroup)
       expect(output).toContain("kind: 'api'")
-      expect(output).toContain('client.call')
+      expect(output).toContain('client.bindCallable<')
     })
 
     it('callable includes JSDoc with method and fullPath', async () => {
@@ -427,8 +427,8 @@ describe('emitScopeFile', () => {
 
       it('callable references fully qualified namespace types', async () => {
         const output = await emitScopeFile(rpcGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Users.GetUser.Params')
-        expect(output).toContain('Promise<Users.GetUser.Response>')
+        // New emission: GetUser: client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>({...})
+        expect(output).toContain('client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>')
       })
 
       it('still emits the bind function', async () => {
@@ -454,8 +454,8 @@ describe('emitScopeFile', () => {
 
       it('callable references fully qualified namespace types', async () => {
         const output = await emitScopeFile(apiGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Posts.UpdatePost.Params')
-        expect(output).toContain('Promise<Posts.UpdatePost.Response>')
+        // New emission: UpdatePost: client.bindCallable<Posts.UpdatePost.Params, Posts.UpdatePost.Response>({...})
+        expect(output).toContain('client.bindCallable<Posts.UpdatePost.Params, Posts.UpdatePost.Response>')
       })
     })
 
@@ -528,12 +528,14 @@ describe('emitScopeFile', () => {
 
       it('v1 callable has no version suffix', async () => {
         const output = await emitScopeFile(rpcVersionedGroup)
-        expect(output).toContain('GetUser(params: GetUserParams')
+        // New emission: GetUser: client.bindCallable<GetUserParams, GetUserResponse>({...})
+        expect(output).toContain('GetUser: client.bindCallable<GetUserParams, GetUserResponse>')
       })
 
       it('v2 callable uses V2 suffix', async () => {
         const output = await emitScopeFile(rpcVersionedGroup)
-        expect(output).toContain('GetUserV2(params: GetUserV2Params')
+        // New emission: GetUserV2: client.bindCallable<GetUserV2Params, GetUserV2Response>({...})
+        expect(output).toContain('GetUserV2: client.bindCallable<GetUserV2Params, GetUserV2Response>')
       })
 
       it('v1 callable uses its own path', async () => {
@@ -591,14 +593,14 @@ describe('emitScopeFile', () => {
 
       it('v1 callable references unversioned namespace types', async () => {
         const output = await emitScopeFile(rpcVersionedGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Users.GetUser.Params')
-        expect(output).toContain('Promise<Users.GetUser.Response>')
+        // New emission: GetUser: client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>({...})
+        expect(output).toContain('client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>')
       })
 
       it('v2 callable references versioned namespace types', async () => {
         const output = await emitScopeFile(rpcVersionedGroup, { namespaceTypes: true })
-        expect(output).toContain('params: Users.GetUserV2.Params')
-        expect(output).toContain('Promise<Users.GetUserV2.Response>')
+        // New emission: GetUserV2: client.bindCallable<Users.GetUserV2.Params, Users.GetUserV2.Response>({...})
+        expect(output).toContain('client.bindCallable<Users.GetUserV2.Params, Users.GetUserV2.Response>')
       })
     })
   })
@@ -622,3 +624,324 @@ describe('emitScopeFile', () => {
     })
   })
 })
+
+// ---------------------------------------------------------------------------
+// .safe sibling on RPC callables
+// ---------------------------------------------------------------------------
+
+const rpcGroupWithErrors: ScopeGroup = {
+  scopeKey: 'users',
+  camelCase: 'users',
+  routes: [
+    {
+      kind: 'rpc',
+      name: 'GetUser',
+      path: '/users/1',
+      method: 'post',
+      scope: 'users',
+      version: 1,
+      errors: ['NotFound'],
+      jsonSchema: {
+        body: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        response: {
+          type: 'object',
+          properties: { name: { type: 'string' } },
+          required: ['name'],
+        },
+      },
+    } satisfies RPCHttpRouteDoc,
+  ],
+}
+
+const rpcGroupNoErrors: ScopeGroup = {
+  scopeKey: 'users',
+  camelCase: 'users',
+  routes: [
+    {
+      kind: 'rpc',
+      name: 'GetUser',
+      path: '/users/1',
+      method: 'post',
+      scope: 'users',
+      version: 1,
+      jsonSchema: {
+        body: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        response: {
+          type: 'object',
+          properties: { name: { type: 'string' } },
+          required: ['name'],
+        },
+      },
+    } satisfies RPCHttpRouteDoc,
+  ],
+}
+
+describe('emitScopeFile .safe sibling on RPC', () => {
+  it('emits bindCallableTyped for RPC callable when route has errors', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // With errors: uses bindCallableTyped<Params, Response, Errors>
+    expect(out).toContain('client.bindCallableTyped<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
+  })
+
+  it('emits bindCallable for RPC callable when route has no errors', async () => {
+    const out = await emitScopeFile(rpcGroupNoErrors, {
+      namespaceTypes: true,
+      serviceName: 'Api',
+    })
+    // Without errors: uses bindCallable<Params, Response>
+    expect(out).toContain('client.bindCallable<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
+  })
+
+  it('scope files no longer directly import Result/ResultNoTyped (inferred from helper)', async () => {
+    const out = await emitScopeFile(rpcGroupNoErrors, {
+      serviceName: 'Api',
+    })
+    // Result/ResultNoTyped are inferred from ClientInstance.bindCallable return type
+    expect(out).not.toContain('ResultNoTyped')
+    expect(out).not.toMatch(/import.*Result.*from/)
+    expect(out).toContain("from 'ts-procedures/client'")
+  })
+
+  it('namespace mode: uses route Errors namespace alias as third type arg', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in namespace mode is the route's Errors type alias: Scope.Route.Errors
+    expect(out).toContain('client.bindCallableTyped<Users.GetUser.Params, Users.GetUser.Response, Users.GetUser.Errors>')
+  })
+
+  it('flat mode: uses route Errors type alias as third type arg', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      namespaceTypes: false,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in flat mode is the injected GetUserErrors type alias
+    expect(out).toContain('client.bindCallableTyped<GetUserParams, GetUserResponse, GetUserErrors>')
+  })
+
+  it('route with errors uses bindCallableTyped', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.bindCallableTyped<')
+    expect(out).not.toContain('client.bindCallable<')
+  })
+
+  it('route without errors uses bindCallable (not bindCallableTyped)', async () => {
+    const out = await emitScopeFile(rpcGroupNoErrors, {
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.bindCallable<')
+    expect(out).not.toContain('client.bindCallableTyped<')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// .safe sibling on API callables
+// ---------------------------------------------------------------------------
+
+const apiGroupWithErrors: ScopeGroup = {
+  scopeKey: 'posts',
+  camelCase: 'posts',
+  routes: [
+    {
+      kind: 'api',
+      name: 'UpdatePost',
+      path: '/posts/:id',
+      method: 'put',
+      fullPath: '/api/posts/:id',
+      scope: 'posts',
+      errors: ['NotFound'],
+      jsonSchema: {
+        pathParams: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        body: {
+          type: 'object',
+          properties: { title: { type: 'string' } },
+          required: ['title'],
+        },
+        response: {
+          type: 'object',
+          properties: { id: { type: 'string' }, title: { type: 'string' } },
+          required: ['id', 'title'],
+        },
+      },
+    } satisfies APIHttpRouteDoc,
+  ],
+}
+
+const apiGroupNoErrors: ScopeGroup = {
+  scopeKey: 'posts',
+  camelCase: 'posts',
+  routes: [
+    {
+      kind: 'api',
+      name: 'UpdatePost',
+      path: '/posts/:id',
+      method: 'put',
+      fullPath: '/api/posts/:id',
+      scope: 'posts',
+      jsonSchema: {
+        pathParams: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        body: {
+          type: 'object',
+          properties: { title: { type: 'string' } },
+          required: ['title'],
+        },
+        response: {
+          type: 'object',
+          properties: { id: { type: 'string' }, title: { type: 'string' } },
+          required: ['id', 'title'],
+        },
+      },
+    } satisfies APIHttpRouteDoc,
+  ],
+}
+
+describe('emitScopeFile .safe sibling on API', () => {
+  it('emits bindCallableTyped for API callable when route has errors', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // With errors: uses bindCallableTyped<Params, Response, Errors>
+    expect(out).toContain('client.bindCallableTyped<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
+  })
+
+  it('emits bindCallable for API callable when route has no errors', async () => {
+    const out = await emitScopeFile(apiGroupNoErrors, {
+      namespaceTypes: true,
+      serviceName: 'Api',
+    })
+    // Without errors: uses bindCallable<Params, Response>
+    expect(out).toContain('client.bindCallable<')
+    // No Object.assign in generated output
+    expect(out).not.toContain('Object.assign')
+  })
+
+  it('namespace mode: uses route Errors namespace alias as third type arg', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in namespace mode is the route's Errors type alias: Scope.Route.Errors
+    expect(out).toContain('client.bindCallableTyped<Posts.UpdatePost.Params, Posts.UpdatePost.Response, Posts.UpdatePost.Errors>')
+  })
+
+  it('flat mode: uses route Errors type alias as third type arg', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      namespaceTypes: false,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in flat mode is the injected UpdatePostErrors type alias
+    expect(out).toContain('client.bindCallableTyped<UpdatePostParams, UpdatePostResponse, UpdatePostErrors>')
+  })
+
+  it('route with errors uses bindCallableTyped', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.bindCallableTyped<')
+    expect(out).not.toContain('client.bindCallable<')
+  })
+
+  it('route without errors uses bindCallable (not bindCallableTyped)', async () => {
+    const out = await emitScopeFile(apiGroupNoErrors, {
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.bindCallable<')
+    expect(out).not.toContain('client.bindCallableTyped<')
+  })
+
+  it('callable uses fullPath not path in the descriptor', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // The descriptor in the helper call should reference the fullPath
+    expect(out).toContain("path: '/api/posts/:id'")
+    expect(out).not.toContain("path: '/posts/:id'")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Stream callables omit .safe sibling (regression guard for Task 14)
+// ---------------------------------------------------------------------------
+
+describe('emitScopeFile streams omit .safe sibling', () => {
+  it('does not emit .safe on stream callables', async () => {
+    const out = await emitScopeFile(streamGroup, {
+      serviceName: 'Api',
+    })
+
+    // Stream callable should be emitted as a plain method
+    expect(out).toContain('WatchEvents(')
+    // No .safe property on stream callables
+    expect(out).not.toContain('WatchEvents.safe')
+    // Object.assign wrapper is not used for stream routes
+    expect(out).not.toMatch(/WatchEvents\s*:\s*Object\.assign/)
+    // bindCallable helpers are not used for stream routes
+    expect(out).not.toMatch(/WatchEvents\s*:\s*client\.bindCallable/)
+  })
+
+  it('stream callable returns TypedStream, not Result', async () => {
+    const out = await emitScopeFile(streamGroup, {
+      serviceName: 'Api',
+    })
+
+    // Confirm stream callable returns TypedStream
+    expect(out).toContain('TypedStream<')
+    // Should not have Result or ResultNoTyped in the return type signature for streams
+    // (streams have their own three-way failure surface)
+    expect(out).toMatch(/WatchEvents\([^)]*\)\s*:\s*TypedStream/)
+  })
+
+  it('stream callable with namespace types still omits .safe', async () => {
+    const out = await emitScopeFile(streamGroup, {
+      namespaceTypes: true,
+      serviceName: 'Api',
+    })
+
+    // Stream callable should use namespace-qualified types
+    expect(out).toContain('Events.WatchEvents.Params')
+    expect(out).toContain('TypedStream<Events.WatchEvents.Yield, Events.WatchEvents.Return>')
+    // But still no .safe property
+    expect(out).not.toContain('WatchEvents.safe')
+    expect(out).not.toMatch(/WatchEvents\s*:\s*Object\.assign/)
+    // bindCallable helpers are not used for stream routes
+    expect(out).not.toMatch(/WatchEvents\s*:\s*client\.bindCallable/)
+  })
+})

package/src/codegen/emit-scope.ts

@@ -246,28 +246,29 @@ async function emitRpcRoute(route: RPCHttpRouteDoc, ctx: EmitRouteContext): Prom
   const responseTypeName = refs['Response'] ?? 'unknown'
   const scopeStr = Array.isArray(route.scope) ? route.scope.join('-') : route.scope
 
+  const errorUnion = buildErrorUnion(route.errors, ctx)
+  const hasErrors = errorUnion !== null
+  const errorsRef = ctx.namespaceTypes
+    ? `${ctx.scopePascal}.${pascal}.Errors`
+    : `${pascal}Errors`
+  const helperCall = hasErrors
+    ? `client.bindCallableTyped<${paramsTypeName}, ${responseTypeName}, ${errorsRef}>`
+    : `client.bindCallable<${paramsTypeName}, ${responseTypeName}>`
+
   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}: ${helperCall}({`,
+    `      name: '${pascal}',`,
+    `      scope: '${scopeStr}',`,
+    `      path: '${route.path}',`,
+    `      method: '${route.method}',`,
+    `      kind: 'rpc',`,
+    `    }),`,
   ].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 +324,30 @@ async function emitApiRoute(route: APIHttpRouteDoc, ctx: EmitRouteContext): Prom
   const responseTypeName = refs['Response'] ?? 'unknown'
   const scopeStr = route.scope ?? 'default'
 
+  const errorUnion = buildErrorUnion(route.errors, ctx)
+  const hasErrors = errorUnion !== null
+  const errorsRef = ctx.namespaceTypes
+    ? `${ctx.scopePascal}.${pascal}.Errors`
+    : `${pascal}Errors`
+  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}(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}: ${helperCall}({`,
+    `      name: '${route.name}',`,
+    `      scope: '${scopeStr}',`,
+    `      path: '${route.fullPath}',`,
+    `      method: '${route.method}',`,
+    `      kind: 'api',`,
+    `    }),`,
   ].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> {
@@ -456,7 +459,8 @@ 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 } from '${clientImportPath}'`
     : `import type { ClientInstance, ProcedureCallOptions } from '${clientImportPath}'`