ts-procedures 8.0.0 → 8.1.0

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

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest'
-import { jsonSchemaToTypeString, jsonSchemaToTypeBody, jsonSchemaToExtractedTypes } from './emit-types.js'
+import { jsonSchemaToTypeString, jsonSchemaToTypeBody, jsonSchemaToExtractedTypes, renameExtractedTypes, extractedDeclName } from './emit-types.js'
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -212,6 +212,78 @@ describe('jsonSchemaToExtractedTypes', () => {
     )
     expect(hasItemsDecl).toBe(true)
   })
+
+  // Root-cause guard: ajsc glues SIBLING extracted declarations with a single
+  // "\n" inside one block. If they aren't split into separate elements, the
+  // downstream rename/dedup logic only sees the first one -> duplicate
+  // identifiers (TS2300). Each extracted sub-type must occupy its own element.
+  it('returns one declaration per element when a schema yields multiple sub-types', async () => {
+    const schema = {
+      type: 'object',
+      required: ['contact'],
+      properties: {
+        contact: {
+          type: 'object',
+          required: ['name', 'address'],
+          properties: {
+            name: { type: 'string' },
+            address: {
+              type: 'object',
+              required: ['city'],
+              properties: { city: { type: 'string' } },
+            },
+          },
+        },
+      },
+    }
+    const result = await jsonSchemaToExtractedTypes(schema)
+    expect(result).not.toBeUndefined()
+    // Two sub-types are extracted: Contact and Address.
+    const names = result!.declarations.map((d) => extractedDeclName(d))
+    expect(names).toContain('Contact')
+    expect(names).toContain('Address')
+    // Each declaration element holds exactly one `export type|enum|interface`.
+    for (const decl of result!.declarations) {
+      const count = decl.match(/export\s+(?:type|enum|interface)\s+/g)?.length ?? 0
+      expect(count).toBe(1)
+    }
+  })
+})
+
+describe('renameExtractedTypes', () => {
+  it('renames a colliding declaration and patches its references in the body', () => {
+    const result = {
+      declarations: ['export type Address = { city: string; }'],
+      body: '{ address: Address; }',
+    }
+    const out = renameExtractedTypes(result, new Set(['Address']))
+    expect(out.declarations[0]).toContain('export type AddressInner =')
+    expect(out.body).toBe('{ address: AddressInner; }')
+  })
+
+  // Latent correctness guard: extracted sub-types reference each other. When a
+  // referenced sub-type is renamed, the reference inside its SIBLING
+  // declaration must be patched too — otherwise the renamed type silently
+  // resolves to a same-named sub-type from a different schema.
+  it('patches cross-references between sibling declarations on rename', () => {
+    const result = {
+      declarations: [
+        'export type Contact = { address: Address; }',
+        'export type Address = { city: string; }',
+      ],
+      body: '{ contact: Contact; }',
+    }
+    // Both names already taken (as if extracted from a second schema sharing them).
+    const out = renameExtractedTypes(result, new Set(['Contact', 'Address']))
+    // Both declarations renamed.
+    expect(out.declarations[0]).toContain('export type ContactInner =')
+    expect(out.declarations[1]).toContain('export type AddressInner =')
+    // The reference inside ContactInner now points at AddressInner, not the
+    // stale Address (which would belong to the other schema).
+    expect(out.declarations[0]).toContain('address: AddressInner')
+    expect(out.declarations[0]).not.toMatch(/address: Address\b/)
+    expect(out.body).toBe('{ contact: ContactInner; }')
+  })
 })
 
 describe('jsonSchemaToTypeString (prefix stripping)', () => {

package/src/codegen/emit-types.ts

@@ -91,6 +91,45 @@ export interface ExtractedTypeOutput {
   body: string
 }
 
+/**
+ * Splits a block of ajsc output into individual top-level declarations.
+ *
+ * ajsc glues sibling extracted declarations with a single `\n`, but each
+ * declaration may itself span multiple lines (multi-line enums, object bodies
+ * with per-property JSDoc). A simple line/`export`-prefix split would therefore
+ * break multi-line declarations apart. Instead we walk lines tracking brace
+ * depth and close a declaration when depth returns to 0 on a line that ends in
+ * a statement terminator (`;` or `}`). Any leading comment lines (JSDoc) stay
+ * attached to the declaration that follows them.
+ */
+function splitTopLevelDeclarations(block: string): string[] {
+  const decls: string[] = []
+  let current: string[] = []
+  let depth = 0
+
+  const flush = () => {
+    const joined = current.join('\n').trim()
+    if (joined) decls.push(joined)
+    current = []
+  }
+
+  for (const line of block.split('\n')) {
+    current.push(line)
+    for (const ch of line) {
+      if (ch === '{') depth += 1
+      else if (ch === '}') depth -= 1
+    }
+    const trimmed = line.trimEnd()
+    if (depth <= 0 && (trimmed.endsWith(';') || trimmed.endsWith('}'))) {
+      flush()
+      depth = 0
+    }
+  }
+  flush()
+
+  return decls
+}
+
 /**
  * Converts a JSON Schema to extracted TypeScript types using ajsc with
  * `inlineTypes: false`. This produces named sub-types (objects, enums) that
@@ -122,13 +161,23 @@ export async function jsonSchemaToExtractedTypes(
     )
   }
 
-  // ajsc with inlineTypes: false produces blocks separated by blank lines:
+  // ajsc with inlineTypes: false produces output like:
   //   export enum Status { Active = "active" }
   //   export type Contact = { name: string; };
+  //
   //   export type Root = { status: Status; contacts: Array<Contact>; };
   //
-  // The Root type is always the last declaration.
+  // Crucially, *sibling* extracted declarations are joined by a SINGLE "\n"
+  // (one block) while the Root is separated by a blank line ("\n\n"). Splitting
+  // only on blank lines would therefore fuse two or more sibling declarations
+  // into one array element — and every downstream consumer (extractedDeclName,
+  // renameExtractedTypes, the namespace dedup) assumes one declaration per
+  // element, so the non-first siblings would be mis-parsed and emitted twice
+  // (`error TS2300: Duplicate identifier`). We split on blank lines first, then
+  // split each block into individual statements so each element holds exactly
+  // one declaration. The Root type is always the last declaration.
   const blocks = code.split(/\n\n+/).map((b) => b.trim()).filter(Boolean)
+  const rawDecls = blocks.flatMap(splitTopLevelDeclarations)
 
   const declarations: string[] = []
   let body = ''
@@ -139,13 +188,13 @@ export async function jsonSchemaToExtractedTypes(
   // declarations branch instead of being eaten as the body.
   const rootDeclPattern = /^export\s+type\s+Root\s*=\s*/
 
-  for (const block of blocks) {
-    if (rootDeclPattern.test(block)) {
+  for (const decl of rawDecls) {
+    if (rootDeclPattern.test(decl)) {
       // Strip "export type Root = " prefix and trailing ";"
-      body = block.replace(rootDeclPattern, '').replace(/;\s*$/, '').trim()
+      body = decl.replace(rootDeclPattern, '').replace(/;\s*$/, '').trim()
     } else {
       // Sub-type or enum declaration — remove trailing ";" for consistency
-      declarations.push(block.replace(/;\s*$/, ''))
+      declarations.push(decl.replace(/;\s*$/, ''))
     }
   }
 
@@ -188,25 +237,28 @@ export function extractedDeclName(decl: string): string | undefined {
  * 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.
+ * occurrence of the old name is substituted in `result.body` AND in every
+ * sibling declaration. The sibling patch matters because extracted sub-types
+ * reference each other (e.g. `Contact = { address: Address }`): renaming
+ * `Address` → `AddressInner` must update that reference too, otherwise the
+ * renamed type silently resolves to a different schema's sub-type of the same
+ * name (a latent wrong-type bug that only hides when the shapes happen to match).
  */
 export function renameExtractedTypes(
   result: ExtractedTypeOutput,
   taken: Set<string>,
 ): ExtractedTypeOutput {
-  let body = result.body
-  const declarations: string[] = []
+  // Work on a mutable copy so we can patch cross-references after renaming.
+  const declarations = [...result.declarations]
+  const renames = new Map<string, string>()
 
-  for (const decl of result.declarations) {
+  // Pass 1: decide renames and rewrite each declaration's leading identifier.
+  for (let i = 0; i < declarations.length; i += 1) {
+    const decl = declarations[i]!
     const name = extractedDeclName(decl)
-    if (name == null) {
-      declarations.push(decl)
-      continue
-    }
+    if (name == null) continue
     if (!taken.has(name)) {
       taken.add(name)
-      declarations.push(decl)
       continue
     }
 
@@ -220,16 +272,25 @@ export function renameExtractedTypes(
       suffix += 1
     }
     taken.add(alias)
+    renames.set(name, alias)
 
-    // Rewrite the declaration's leading identifier.
-    const renamedDecl = decl.replace(
+    declarations[i] = 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)
+  // Pass 2: patch every reference to a renamed name — in the body and in every
+  // declaration body — so cross-references between sibling sub-types follow the
+  // rename. `\bAddress\b` does not match inside `AddressInner` (no word
+  // boundary between `s` and `I`), so already-renamed identifiers are untouched.
+  let body = result.body
+  for (const [name, alias] of renames) {
+    const re = new RegExp(`\\b${name}\\b`, 'g')
+    body = body.replace(re, alias)
+    for (let i = 0; i < declarations.length; i += 1) {
+      declarations[i] = declarations[i]!.replace(re, alias)
+    }
   }
 
   return { declarations, body }