ts-procedures 7.0.0 → 7.1.0

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

@@ -178,6 +178,40 @@ describe('jsonSchemaToExtractedTypes', () => {
     expect(result!.body).not.toContain('export type Root')
     expect(result!.body).toContain('id: string')
   })
+
+  // Bug repro (downstream): codegen emits `Cannot find name 'RootType'`.
+  // ajsc with inlineTypes:false renders an array-root schema as TWO blocks:
+  //   export type RootType = { ... };
+  //   export type Root = Array<RootType>;
+  // The current parser uses `block.startsWith('export type Root')` which
+  // matches BOTH `Root` and `RootType`, swallowing the `RootType` declaration
+  // and leaving the body's `Array<RootType>` reference dangling.
+  it('preserves the RootType items declaration when the root schema is an array of objects', async () => {
+    const schema = {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          name: { type: 'string' },
+        },
+        required: ['id', 'name'],
+      },
+    }
+    const result = await jsonSchemaToExtractedTypes(schema)
+    expect(result).not.toBeUndefined()
+    // The body should be `Array<RootType>` (or equivalent referencing a named items type)
+    expect(result!.body).toMatch(/^Array<\w+>$/)
+
+    // The items type must be present in declarations so the body reference resolves.
+    // Extract the referenced name from the body and assert a matching declaration exists.
+    const refName = result!.body.match(/^Array<(\w+)>$/)?.[1]
+    expect(refName).toBeDefined()
+    const hasItemsDecl = result!.declarations.some((d) =>
+      new RegExp(`^export\\s+type\\s+${refName}\\s*=`).test(d)
+    )
+    expect(hasItemsDecl).toBe(true)
+  })
 })
 
 describe('jsonSchemaToTypeString (prefix stripping)', () => {

package/src/codegen/emit-types.ts

@@ -133,13 +133,16 @@ export async function jsonSchemaToExtractedTypes(
   const declarations: string[] = []
   let body = ''
 
+  // Match `export type Root =` strictly — `Root` must be followed by `=` (with
+  // optional whitespace), so sibling extracted names like `RootType` (which
+  // ajsc emits for an `Array<RootType>` root schema) fall through to the
+  // declarations branch instead of being eaten as the body.
+  const rootDeclPattern = /^export\s+type\s+Root\s*=\s*/
+
   for (const block of blocks) {
-    if (block.startsWith('export type Root')) {
+    if (rootDeclPattern.test(block)) {
       // Strip "export type Root = " prefix and trailing ";"
-      body = block
-        .replace(/^export\s+type\s+Root\s*=\s*/, '')
-        .replace(/;\s*$/, '')
-        .trim()
+      body = block.replace(rootDeclPattern, '').replace(/;\s*$/, '').trim()
     } else {
       // Sub-type or enum declaration — remove trailing ";" for consistency
       declarations.push(block.replace(/;\s*$/, ''))
@@ -156,3 +159,78 @@ export async function jsonSchemaToExtractedTypes(
 
   return { declarations, body }
 }
+
+/**
+ * Returns the declared name of an `export type|enum|interface X = …` block,
+ * or `undefined` if none can be parsed. Used by `renameExtractedTypes` to
+ * detect collisions between ajsc-extracted sub-types and reserved identifiers.
+ */
+export function extractedDeclName(decl: string): string | undefined {
+  const m = decl.match(/^export\s+(?:type|enum|interface)\s+(\w+)/)
+  return m?.[1]
+}
+
+/**
+ * Rewrites an {@link ExtractedTypeOutput} to avoid identifier collisions.
+ *
+ * ajsc with `inlineTypes: false` derives sub-type names from the parent
+ * property's name — so a schema property literally called `params` produces
+ * `export type Params = {…}`. When that collides with the route's own
+ * `Params` shortName (or any other reserved name), the resulting namespace
+ * has duplicate `export type Params` declarations and won't compile.
+ *
+ * This helper takes:
+ *   - `result`: the raw ajsc output for one schema
+ *   - `taken`: a set of names that are NOT free to use (mutated as renames
+ *     are applied so subsequent calls share the same allocation map)
+ *
+ * For every extracted declaration whose name is already in `taken`, a unique
+ * alias is generated (`Params` → `ParamsInner`, then `ParamsInner2`, …) so
+ * the renamed type reads like a real, intentional name (not a placeholder).
+ * The declaration is rewritten with the new name and every word-boundary
+ * occurrence in `result.body` is substituted so the body keeps referencing
+ * the renamed type.
+ */
+export function renameExtractedTypes(
+  result: ExtractedTypeOutput,
+  taken: Set<string>,
+): ExtractedTypeOutput {
+  let body = result.body
+  const declarations: string[] = []
+
+  for (const decl of result.declarations) {
+    const name = extractedDeclName(decl)
+    if (name == null) {
+      declarations.push(decl)
+      continue
+    }
+    if (!taken.has(name)) {
+      taken.add(name)
+      declarations.push(decl)
+      continue
+    }
+
+    // Allocate a unique alias. `Inner` reads as an intentional name (the
+    // sub-type referenced *by* the conflicting outer type) rather than the
+    // `_` suffix which looks like a forgotten placeholder.
+    let alias = `${name}Inner`
+    let suffix = 2
+    while (taken.has(alias)) {
+      alias = `${name}Inner${suffix}`
+      suffix += 1
+    }
+    taken.add(alias)
+
+    // Rewrite the declaration's leading identifier.
+    const renamedDecl = decl.replace(
+      new RegExp(`^(export\\s+(?:type|enum|interface)\\s+)${name}\\b`),
+      `$1${alias}`,
+    )
+    declarations.push(renamedDecl)
+
+    // Patch every word-boundary occurrence of the old name in the body.
+    body = body.replace(new RegExp(`\\b${name}\\b`, 'g'), alias)
+  }
+
+  return { declarations, body }
+}

package/src/codegen/resolve-envelope.test.ts

@@ -53,6 +53,17 @@ describe('resolveEnvelope', () => {
     await expect(resolveEnvelope({ envelope: empty })).rejects.toThrow(/routes/)
   })
 
+  // Defensive (downstream bug repro): forgetting `builder.build()` is a common
+  // cause of an empty routes array because hono-rpc/hono-api/hono-stream/express-rpc
+  // builders only populate their `_docs` array inside `build()`. The current
+  // error message says "Register at least one procedure", which led the
+  // downstream dev to look in the wrong place. The message should mention
+  // `.build()` as a likely cause so the next person hits the right fix faster.
+  it('empty-routes error message mentions builder.build() as a likely cause', async () => {
+    const empty: DocEnvelope = { basePath: '', headers: [], errors: [], routes: [] }
+    await expect(resolveEnvelope({ envelope: empty })).rejects.toThrow(/\.build\(\)/)
+  })
+
   it('throws when routes array is empty (file input)', async () => {
     const dir = await mkdtemp(join(tmpdir(), 'ts-proc-test-'))
     const filePath = join(dir, 'empty.json')

package/src/codegen/resolve-envelope.ts

@@ -53,7 +53,10 @@ export async function resolveEnvelope(input: ResolveInput): Promise<DocEnvelope>
 
   if (envelope.routes.length === 0) {
     throw new Error(
-      '[ts-procedures-codegen] DocEnvelope has an empty "routes" array. Register at least one procedure before generating.'
+      '[ts-procedures-codegen] DocEnvelope has an empty "routes" array. ' +
+      'Common causes: (1) you forgot to call `builder.build()` before passing ' +
+      'the builder to `DocRegistry.from(...)` — hono/express builders only populate ' +
+      '`docs` inside `build()`; (2) no procedures registered with the builder.'
     )
   }
 

package/src/codegen/test-helpers/run-tsc.ts

@@ -0,0 +1,56 @@
+import { execSync } from 'node:child_process'
+import { writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * Default tsconfig used by codegen e2e tests when none is supplied.
+ * Mirrors what consumers running `tsc --strict` typically use, plus the
+ * codegen output's expected module/target settings.
+ */
+export const DEFAULT_E2E_TSCONFIG = {
+  compilerOptions: {
+    strict: true,
+    target: 'ES2022',
+    module: 'ES2022',
+    moduleResolution: 'bundler',
+    noEmit: true,
+    skipLibCheck: true,
+  },
+  include: ['**/*.ts'],
+} as const
+
+/**
+ * Runs `tsc --noEmit` on the given tsconfig and throws an `AssertionError`-style
+ * message that includes captured stderr/stdout when compilation fails. Returns
+ * silently on success.
+ *
+ * Replaces the previously-duplicated try/execSync/stderr-format dance that
+ * appeared in 5+ places in `e2e.test.ts` — keeps tests focused on what they
+ * generated, not how they shell out to tsc.
+ *
+ * `tsconfigInline` is written to `tmpDir/tsconfig.json` automatically; pass
+ * `tsconfigPath` instead to point at an existing file.
+ */
+export function runTsc(args: {
+  tmpDir: string
+  tsconfigInline?: Record<string, unknown>
+  tsconfigPath?: string
+}): void {
+  const tsconfigPath = args.tsconfigPath ?? join(args.tmpDir, 'tsconfig.json')
+  if (args.tsconfigInline != null) {
+    writeFileSync(tsconfigPath, JSON.stringify(args.tsconfigInline))
+  }
+
+  const tscPath = join(process.cwd(), 'node_modules', '.bin', 'tsc')
+  try {
+    execSync(`${tscPath} --noEmit --project ${tsconfigPath}`, { stdio: 'pipe' })
+  } catch (err) {
+    const e = err as { stdout?: Buffer; stderr?: Buffer; message?: string }
+    const stdout = e.stdout?.toString() ?? ''
+    const stderr = e.stderr?.toString() ?? ''
+    const combined = [stdout, stderr].filter(Boolean).join('\n').trim()
+    throw new Error(
+      `[runTsc] tsc failed for ${tsconfigPath}:\n${combined || (e.message ?? '(no output)')}`,
+    )
+  }
+}