ts-procedures 7.3.0 → 8.1.0

package/src/codegen/e2e.test.ts

@@ -3,8 +3,9 @@ import { generateClient } from './index.js'
 import { mkdirSync, rmSync, readFileSync, writeFileSync, existsSync } from 'node:fs'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
-import type { DocEnvelope, RPCHttpRouteDoc, APIHttpRouteDoc, StreamHttpRouteDoc, ErrorDoc } from '../implementations/types.js'
+import type { DocEnvelope, RPCHttpRouteDoc, APIHttpRouteDoc, StreamHttpRouteDoc, HttpStreamRouteDoc, ErrorDoc } from '../implementations/types.js'
 import { runTsc } from './test-helpers/run-tsc.js'
+import { Type } from 'typebox'
 
 // ---------------------------------------------------------------------------
 // Fixtures
@@ -39,20 +40,24 @@ const apiRoute: APIHttpRouteDoc = {
   method: 'put',
   scope: 'users',
   jsonSchema: {
-    pathParams: {
-      type: 'object',
-      properties: { id: { type: 'string' } },
-      required: ['id'],
-    },
-    body: {
-      type: 'object',
-      properties: { name: { type: 'string' } },
-      required: ['name'],
+    req: {
+      pathParams: {
+        type: 'object',
+        properties: { id: { type: 'string' } },
+        required: ['id'],
+      },
+      body: {
+        type: 'object',
+        properties: { name: { type: 'string' } },
+        required: ['name'],
+      },
     },
-    response: {
-      type: 'object',
-      properties: { id: { type: 'string' }, name: { type: 'string' } },
-      required: ['id', 'name'],
+    res: {
+      body: {
+        type: 'object',
+        properties: { id: { type: 'string' }, name: { type: 'string' } },
+        required: ['id', 'name'],
+      },
     },
   },
 }
@@ -94,6 +99,34 @@ const streamRoute: StreamHttpRouteDoc = {
   },
 }
 
+const httpStreamRoute: HttpStreamRouteDoc = {
+  kind: 'http-stream',
+  name: 'WatchUsers',
+  scope: 'users',
+  method: 'get',
+  path: '/users/watch',
+  fullPath: '/api/users/watch',
+  streamMode: 'sse',
+  jsonSchema: {
+    req: {
+      query: {
+        type: 'object',
+        properties: { status: { type: 'string' } },
+      },
+    },
+    yield: {
+      type: 'object',
+      properties: { id: { type: 'string' }, event: { type: 'string' } },
+      required: ['id', 'event'],
+    },
+    returnType: {
+      type: 'object',
+      properties: { count: { type: 'number' } },
+      required: ['count'],
+    },
+  },
+}
+
 const procedureErrorDoc: ErrorDoc = {
   name: 'ProcedureError',
   statusCode: 500,
@@ -129,7 +162,7 @@ const envelope: DocEnvelope = {
   basePath: '/api',
   headers: [],
   errors: [procedureErrorDoc, validationErrorDoc],
-  routes: [rpcRoute, apiRoute, streamRoute],
+  routes: [rpcRoute, apiRoute, streamRoute, httpStreamRoute],
 }
 
 // ---------------------------------------------------------------------------
@@ -189,20 +222,20 @@ describe('E2E: generateClient full pipeline', () => {
 
   // ── users.ts — API route ───────────────────────────────────────────────────
 
-  it('users.ts contains UpdateUserParams type', async () => {
+  it('users.ts contains UpdateUserReq type (structured request type)', async () => {
     tmpDir = makeTmpDir()
     await generateClient({ envelope, outDir: tmpDir })
 
     const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
-    expect(content).toContain('UpdateUserParams')
+    expect(content).toContain('UpdateUserReq')
   })
 
-  it('users.ts contains UpdateUserResponse type', async () => {
+  it('users.ts contains UpdateUserResponseBody type', async () => {
     tmpDir = makeTmpDir()
     await generateClient({ envelope, outDir: tmpDir })
 
     const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
-    expect(content).toContain('UpdateUserResponse')
+    expect(content).toContain('UpdateUserResponseBody')
   })
 
   it('users.ts API callable uses fullPath in the path field', async () => {
@@ -289,6 +322,44 @@ describe('E2E: generateClient full pipeline', () => {
     expect(yieldTypeBody).not.toContain('retry')
   })
 
+  // ── users.ts — http-stream route ──────────────────────────────────────────
+
+  it('users.ts contains WatchUsers callable using client.stream with kind http-stream', async () => {
+    tmpDir = makeTmpDir()
+    await generateClient({ envelope, outDir: tmpDir })
+
+    const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
+    expect(content).toContain('client.stream')
+    expect(content).toContain("kind: 'http-stream'")
+  })
+
+  it('users.ts http-stream callable passes params: req (not bare req shorthand)', async () => {
+    tmpDir = makeTmpDir()
+    await generateClient({ envelope, outDir: tmpDir })
+
+    const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
+    // Must be 'params: req,' not just 'req,' — the shorthand drops channel info
+    expect(content).toContain('params: req,')
+    expect(content).not.toMatch(/^\s+req,\s*$/m)
+  })
+
+  it('users.ts http-stream callable uses fullPath', async () => {
+    tmpDir = makeTmpDir()
+    await generateClient({ envelope, outDir: tmpDir })
+
+    const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
+    expect(content).toContain("path: '/api/users/watch'")
+  })
+
+  it('users.ts http-stream callable returns TypedStream', async () => {
+    tmpDir = makeTmpDir()
+    await generateClient({ envelope, outDir: tmpDir })
+
+    const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
+    expect(content).toContain('TypedStream<')
+    expect(content).toContain("streamMode: 'sse'")
+  })
+
   // ── index.ts ───────────────────────────────────────────────────────────────
 
   it('index.ts contains the default Api bindings factory', async () => {
@@ -520,7 +591,7 @@ const typedAdapter: ClientAdapter = {
   async stream(req) {
     const trace: string | undefined = req.meta?.traceId
     void trace
-    return { status: 200, headers: {}, body: (async function*() {})() }
+    return { status: 200, headers: new Headers(), body: (async function*() {})() }
   },
 }
 
@@ -735,7 +806,9 @@ void run
       const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
       expect(content).toContain('export namespace Users {')
       expect(content).toContain('export namespace GetUser {')
-      expect(content).toContain('export namespace UpdateUser {')
+      // API routes now emit Req/Response sub-namespaces instead of a bare UpdateUser namespace
+      expect(content).toContain('export namespace Req {')
+      expect(content).toContain('export namespace Response {')
     })
 
     it('users.ts uses qualified type references in callables', async () => {
@@ -743,9 +816,10 @@ void run
       await generateClient({ envelope, outDir: tmpDir, namespaceTypes: true })
 
       const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
-      // New emission: client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>({...})
+      // RPC route still uses Params/Response naming
       expect(content).toContain('client.bindCallable<Users.GetUser.Params, Users.GetUser.Response>')
-      expect(content).toContain('client.bindCallable<Users.UpdateUser.Params, Users.UpdateUser.Response>')
+      // API route uses Req sub-namespace for params and Response.Body for return
+      expect(content).toContain('client.bindCallable<Users.UpdateUser.Req, Users.UpdateUser.Response.Body>')
     })
 
     it('events.ts wraps stream types in namespace', async () => {
@@ -765,7 +839,8 @@ void run
       const content = readFileSync(join(tmpDir, 'users.ts'), 'utf-8')
       expect(content).not.toContain('export type GetUserParams')
       expect(content).not.toContain('export type GetUserResponse')
-      expect(content).not.toContain('export type UpdateUserPathParams')
+      expect(content).not.toContain('export type UpdateUserReqPathParams')
+      expect(content).not.toContain('export type UpdateUserResponseBody')
     })
 
     it('enumStyle: enum produces named enums inside namespace', async () => {
@@ -855,4 +930,357 @@ void run
       })
     })
   })
+
+  // ── Duplicate-identifier bug: type shared between params and returnType ──────
+  //
+  // End-to-end gold-standard guards. ajsc glues sibling extracted sub-types
+  // with a single "\n"; emit-types only renames/dedups the first one, so a
+  // route whose body and response both yield >=2 sub-types emits the non-first
+  // sub-type twice -> `error TS2300: Duplicate identifier`. These compile the
+  // real generated output with tsc.
+  describe('shared nested types across body/response', () => {
+    const contactShape = {
+      type: 'object',
+      required: ['name', 'address'],
+      properties: {
+        name: { type: 'string' },
+        address: {
+          type: 'object',
+          required: ['street', 'city'],
+          properties: { street: { type: 'string' }, city: { type: 'string' } },
+        },
+      },
+    }
+
+    const sharedNestedEnvelope: DocEnvelope = {
+      basePath: '/api',
+      headers: [],
+      errors: [],
+      routes: [
+        {
+          kind: 'rpc',
+          name: 'SaveContact',
+          path: '/contacts/save/1',
+          method: 'post',
+          scope: 'contacts',
+          version: 1,
+          jsonSchema: {
+            body: { type: 'object', required: ['contact'], properties: { contact: contactShape } },
+            response: {
+              type: 'object',
+              required: ['contact', 'savedAt'],
+              properties: { savedAt: { type: 'string' }, contact: contactShape },
+            },
+          },
+        } satisfies RPCHttpRouteDoc,
+      ],
+    }
+
+    it('generated client compiles when a nested object is shared between body and response', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: sharedNestedEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+      })
+
+      runTsc({
+        tmpDir,
+        tsconfigInline: {
+          compilerOptions: {
+            strict: true,
+            target: 'ES2022',
+            module: 'ES2022',
+            moduleResolution: 'bundler',
+            verbatimModuleSyntax: true,
+            noEmit: true,
+            skipLibCheck: true,
+          },
+          include: ['_types.ts', '_client.ts', 'index.ts', 'contacts.ts', '_errors.ts'],
+        },
+      })
+    })
+
+    // Latent correctness guard: same property name (`detail`), DIFFERENT shape
+    // in body vs response. If the rename leaves the response's sub-type pointing
+    // at the body's `Detail`, a consumer that reads the response-only field fails
+    // to compile — catching the silent wrong-reference bug that TS2300 hides when
+    // the shapes happen to be structurally identical.
+    const divergentEnvelope: DocEnvelope = {
+      basePath: '/api',
+      headers: [],
+      errors: [],
+      routes: [
+        {
+          kind: 'rpc',
+          name: 'SyncData',
+          path: '/sync/1',
+          method: 'post',
+          scope: 'sync',
+          version: 1,
+          jsonSchema: {
+            body: {
+              type: 'object',
+              required: ['outer'],
+              properties: {
+                outer: {
+                  type: 'object',
+                  required: ['detail'],
+                  properties: {
+                    detail: {
+                      type: 'object',
+                      required: ['fromClient'],
+                      properties: { fromClient: { type: 'string' } },
+                    },
+                  },
+                },
+              },
+            },
+            response: {
+              type: 'object',
+              required: ['outer'],
+              properties: {
+                outer: {
+                  type: 'object',
+                  required: ['detail'],
+                  properties: {
+                    detail: {
+                      type: 'object',
+                      required: ['fromServer'],
+                      properties: { fromServer: { type: 'number' } },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        } satisfies RPCHttpRouteDoc,
+      ],
+    }
+
+    it('response sub-type keeps its own shape when a name collides with a differently-shaped body sub-type', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: divergentEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+      })
+
+      // Consumer asserts the response's `detail` exposes `fromServer: number`
+      // (its own shape) — not the body's `{ fromClient: string }`. Imports the
+      // scope file directly to validate the generated route type precisely.
+      const consumer = `
+import type { Sync } from './sync'
+const r: Sync.SyncData.Response = null as any
+const n: number = r.outer.detail.fromServer
+void n
+`
+      writeFileSync(join(tmpDir, '__consumer.ts'), consumer)
+
+      runTsc({
+        tmpDir,
+        tsconfigInline: {
+          compilerOptions: {
+            strict: true,
+            target: 'ES2022',
+            module: 'ES2022',
+            moduleResolution: 'bundler',
+            verbatimModuleSyntax: true,
+            noEmit: true,
+            skipLibCheck: true,
+          },
+          include: ['_types.ts', '_client.ts', 'index.ts', 'sync.ts', '_errors.ts', '__consumer.ts'],
+        },
+      })
+    })
+  })
+
+  // ── Complex TypeBox-derived schemas (broad duplication / correctness sweep) ──
+  //
+  // Builds realistic schemas with TypeBox, round-trips them to plain JSON Schema
+  // (exactly what lands in a DocEnvelope), and stresses every known collision
+  // vector at once:
+  //   - a deeply-nested object (Product → Manufacturer → Hq/Warehouse → Geo)
+  //     shared between a route's body AND response (forces the response copy to
+  //     rename all of its sub-types and re-point every cross-reference);
+  //   - the same Product reused by a SECOND route in the same scope (separate
+  //     route namespaces must not clash);
+  //   - a sub-type (Geo) referenced by two siblings (Hq + Warehouse) — the
+  //     rename must patch BOTH referrers;
+  //   - shared Filter/Range across an API route's query + body channels;
+  //   - a body property literally named `params`, colliding with the route's
+  //     own `Params` shortName;
+  //   - arrays-of-objects, optionals, literal unions, and records.
+  //
+  // Run under the default (inline-union) mode AND `enumStyle: 'enum'`, where a
+  // 3-literal union explodes into three separate enums (plus ajsc's own
+  // internal renaming) — the largest fused declaration block we emit. The tsc
+  // compile is the authoritative duplicate-identifier (TS2300) and
+  // dangling/wrong-reference guard; the consumer additionally pins deep field
+  // access through the renamed types.
+  describe('complex TypeBox-derived schemas', () => {
+    const clean = (s: unknown): Record<string, unknown> =>
+      JSON.parse(JSON.stringify(s)) as Record<string, unknown>
+
+    const Geo = Type.Object({ lat: Type.Number(), lng: Type.Number() })
+    const Address = Type.Object({ street: Type.String(), city: Type.String(), geo: Geo })
+    const Manufacturer = Type.Object({
+      name: Type.String(),
+      hq: Address,
+      warehouses: Type.Array(Address),
+    })
+    const Variant = Type.Object({
+      sku: Type.String(),
+      price: Type.Number(),
+      inStock: Type.Boolean(),
+    })
+    const Product = Type.Object({
+      id: Type.String(),
+      category: Type.Union([Type.Literal('book'), Type.Literal('food'), Type.Literal('toy')]),
+      status: Type.Optional(Type.Union([Type.Literal('active'), Type.Literal('archived')])),
+      dimensions: Type.Object({ w: Type.Number(), h: Type.Number(), d: Type.Number() }),
+      tags: Type.Array(Type.String()),
+      variants: Type.Array(Variant),
+      manufacturer: Manufacturer,
+    })
+
+    const Range = Type.Object({ min: Type.Number(), max: Type.Number() })
+    const Filter = Type.Object({
+      category: Type.Optional(Type.Union([Type.Literal('book'), Type.Literal('food')])),
+      price: Range,
+    })
+    const SavedSearch = Type.Object({ name: Type.String(), filter: Filter })
+
+    // Route 1: rpc — body + response share Product; body also has a `params`
+    // property colliding with the route's Params shortName.
+    const upsertProduct: RPCHttpRouteDoc = {
+      kind: 'rpc',
+      name: 'UpsertProduct',
+      path: '/catalog/upsert/1',
+      method: 'post',
+      scope: 'catalog',
+      version: 1,
+      jsonSchema: {
+        body: clean(Type.Object({ product: Product, params: Type.Object({ dryRun: Type.Boolean() }) })),
+        response: clean(
+          Type.Object({
+            product: Product,
+            audit: Type.Object({
+              revision: Type.Integer(),
+              editor: Type.Object({ id: Type.String(), name: Type.String() }),
+            }),
+          }),
+        ),
+      },
+    }
+
+    // Route 2: api — query + body share Filter/Range; res reuses Product.
+    const searchCatalog: APIHttpRouteDoc = {
+      kind: 'api',
+      name: 'SearchCatalog',
+      path: '/catalog/search',
+      fullPath: '/api/catalog/search',
+      method: 'post',
+      scope: 'catalog',
+      jsonSchema: {
+        req: {
+          query: clean(Type.Object({ page: Type.Integer(), filter: Type.Optional(Filter) })),
+          body: clean(Type.Object({ saved: Type.Array(SavedSearch) })),
+        },
+        res: {
+          body: clean(
+            Type.Object({
+              items: Type.Array(Product),
+              total: Type.Integer(),
+              byCategory: Type.Record(Type.String(), Type.Integer()),
+            }),
+          ),
+        },
+      },
+    }
+
+    const complexEnvelope: DocEnvelope = {
+      basePath: '/api',
+      headers: [],
+      errors: [],
+      routes: [upsertProduct, searchCatalog],
+    }
+
+    const consumer = `
+import type { Catalog } from './catalog'
+
+// Route 1 response: deep access through the shared-and-renamed Product, plus
+// the sub-type (Geo) shared by two referrers (hq + warehouses[]).
+const up: Catalog.UpsertProduct.Response = null as any
+const lat: number = up.product.manufacturer.hq.geo.lat
+const wlng: number = up.product.manufacturer.warehouses[0]!.geo.lng
+const sku: string = up.product.variants[0]!.sku
+const w: number = up.product.dimensions.w
+const rev: number = up.audit.revision
+const editorName: string = up.audit.editor.name
+void lat; void wlng; void sku; void w; void rev; void editorName
+
+// Route 1 params (body): shared Product + the colliding 'params' property.
+const body: Catalog.UpsertProduct.Params = null as any
+const pid: string = body.product.id
+const dry: boolean = body.params.dryRun
+void pid; void dry
+
+// Route 2 request: Filter/Range shared across query + body channels.
+const req: Catalog.SearchCatalog.Req = null as any
+const page: number = req.query.page
+const qMin: number | undefined = req.query.filter?.price.min
+const bMax: number = req.body.saved[0]!.filter.price.max
+void page; void qMin; void bMax
+
+// Route 2 response: array of the shared Product + a record.
+const res: Catalog.SearchCatalog.Response.Body = null as any
+const total: number = res.total
+const firstSku: string = res.items[0]!.variants[0]!.sku
+const bookCount: number | undefined = res.byCategory['book']
+void total; void firstSku; void bookCount
+`
+
+    const tsconfig = {
+      compilerOptions: {
+        strict: true,
+        target: 'ES2022',
+        module: 'ES2022',
+        moduleResolution: 'bundler',
+        verbatimModuleSyntax: true,
+        noEmit: true,
+        skipLibCheck: true,
+      },
+      include: ['_types.ts', '_client.ts', 'index.ts', 'catalog.ts', '_errors.ts', '__consumer.ts'],
+    }
+
+    it('compiles end-to-end with deep shared/renamed types (default inline-union mode)', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: complexEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+      })
+      writeFileSync(join(tmpDir, '__consumer.ts'), consumer)
+      runTsc({ tmpDir, tsconfigInline: tsconfig })
+    })
+
+    it('compiles end-to-end under enumStyle: enum (union-of-literals explodes into many enums)', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: complexEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+        ajsc: { enumStyle: 'enum' },
+      })
+      // In enum mode `category` becomes enum unions; the deep object access still
+      // holds, so reuse the consumer (it never pins the enum member types).
+      writeFileSync(join(tmpDir, '__consumer.ts'), consumer)
+      runTsc({ tmpDir, tsconfigInline: tsconfig })
+    })
+  })
 })

package/src/codegen/emit-errors.integration.test.ts

@@ -52,7 +52,7 @@ describe('generated _errors.ts — runtime behavior', () => {
         path: '/ping',
         fullPath: '/api/ping',
         method: 'get',
-        jsonSchema: { response: { type: 'object', properties: {} } },
+        jsonSchema: { response: { type: 'object', properties: {} } } as any, // TODO(Phase 8): migrate to new req/res envelope shape
       },
     ],
   }