ts-procedures 8.0.0 → 8.1.1

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 }

package/src/codegen/test-helpers/golden.ts

@@ -22,7 +22,7 @@ export async function assertGoldenOrUpdate(produced: string, goldenPath: string)
       '// Source hash: <PLACEHOLDER>',
     )
     await writeFile(goldenPath, goldenContent, 'utf-8')
-    // eslint-disable-next-line no-console
+     
     console.log(`[golden-test] Wrote golden: ${goldenPath}`)
     return
   }

package/src/create-http-stream.ts

@@ -1,8 +1,8 @@
 import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError, ProcedureYieldValidationError } from './errors.js'
 import { computeSchema } from './schema/compute-schema.js'
-import { Prettify, TSchemaLib } from './schema/types.js'
+import type { Prettify, TSchemaLib } from './schema/types.js'
 import { captureDefinitionInfo } from './stack-utils.js'
-import {
+import type {
   HttpMethod, TBuilderConfig, TStreamContext,
   THttpStreamProcedureRegistration, TProcedureRegistration, TStreamProcedureRegistration, THttpProcedureRegistration,
 } from './types.js'

package/src/create-http.ts

@@ -1,9 +1,8 @@
 import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError } from './errors.js'
 import { computeSchema } from './schema/compute-schema.js'
-import { Prettify, TSchemaLib } from './schema/types.js'
+import type { Prettify, TSchemaLib } from './schema/types.js'
 import { captureDefinitionInfo } from './stack-utils.js'
-import {
-  HttpMethod,
+import type {
   TBuilderConfig,
   TCreateHttpConfig,
   TLocalContext,

package/src/create-stream.test.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
+ 
 import { describe, expect, it, test } from 'vitest'
 import { Procedures } from './index.js'
 import { v } from 'suretype'

package/src/create-stream.ts

@@ -1,8 +1,8 @@
 import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError, ProcedureYieldValidationError } from './errors.js'
 import { computeSchema } from './schema/compute-schema.js'
-import { Prettify, TSchemaLib } from './schema/types.js'
+import type { Prettify, TSchemaLib } from './schema/types.js'
 import { captureDefinitionInfo } from './stack-utils.js'
-import {
+import type {
   TBuilderConfig,
   THttpProcedureRegistration,
   THttpStreamProcedureRegistration,

package/src/create.test.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
+ 
 import { describe, expect, it, test } from 'vitest'
 import { Procedures } from './index.js'
 import { v } from 'suretype'

package/src/create.ts

@@ -1,8 +1,8 @@
 import { ProcedureError, ProcedureRegistrationError, ProcedureValidationError } from './errors.js'
 import { computeSchema } from './schema/compute-schema.js'
-import { Prettify, TSchemaLib } from './schema/types.js'
+import type { Prettify, TSchemaLib } from './schema/types.js'
 import { captureDefinitionInfo } from './stack-utils.js'
-import {
+import type {
   TBuilderConfig,
   THttpProcedureRegistration,
   THttpStreamProcedureRegistration,

package/src/errors.test.ts

@@ -4,7 +4,7 @@ import {
   ProcedureValidationError,
   ProcedureRegistrationError,
 } from './errors.js'
-import { DefinitionInfo } from './stack-utils.js'
+import type { DefinitionInfo } from './stack-utils.js'
 
 describe('Error Classes', () => {
   test('ProcedureError has correct properties', () => {

package/src/errors.ts

@@ -1,5 +1,6 @@
-import { TSchemaValidationError } from './schema/parser.js'
-import { DefinitionInfo, DefinitionLocation, formatDefinitionInfo } from './stack-utils.js'
+import type { TSchemaValidationError } from './schema/parser.js'
+import type { DefinitionInfo, DefinitionLocation} from './stack-utils.js';
+import { formatDefinitionInfo } from './stack-utils.js'
 import { kebabCase } from 'es-toolkit/string'
 
 export class ProcedureError extends Error {

package/src/implementations/http/hono/index.ts

@@ -1,4 +1,5 @@
-import { Context, Hono } from 'hono'
+import type { Context} from 'hono';
+import { Hono } from 'hono'
 import type {
   AnyHttpRouteDoc,
   ProceduresFactory,

package/src/implementations/http/on-request-error.test.ts

@@ -14,7 +14,7 @@
 import { describe, expect, test, vi } from 'vitest'
 import { Type } from 'typebox'
 import { Procedures } from '../../index.js'
-import { RPCConfig } from '../types.js'
+import type { RPCConfig } from '../types.js'
 import { HonoAppBuilder } from './hono/index.js'
 
 describe('onRequestError — HonoAppBuilder (rpc kind)', () => {

package/src/implementations/http/route-errors.test.ts

@@ -2,7 +2,7 @@
 import { describe, expect, test } from 'vitest'
 import { Type } from 'typebox'
 import { Procedures } from '../../index.js'
-import { APIConfig, RPCConfig } from '../types.js'
+import type { APIConfig, RPCConfig } from '../types.js'
 import { HonoAppBuilder } from './hono/index.js'
 import { DocRegistry } from './doc-registry.js'
 import { defineErrorTaxonomy } from './error-taxonomy.js'

package/src/implementations/types.ts

@@ -1,4 +1,4 @@
-import { Procedures } from '../index.js'
+import type { Procedures } from '../index.js'
 import type { ErrorTaxonomy } from './http/error-taxonomy.js'
 
 /**

package/src/index.test.ts

@@ -1,4 +1,4 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
+ 
 import { describe, expect, it, test } from 'vitest'
 import { Procedures } from './index.js'
 import { v } from 'suretype'

package/src/index.ts

@@ -1,4 +1,4 @@
-import { Prettify, TJSONSchema } from './schema/types.js'
+import type { Prettify } from './schema/types.js'
 import { makeCreate } from './create.js'
 import { makeCreateStream } from './create-stream.js'
 import { makeCreateHttp } from './create-http.js'
@@ -16,7 +16,7 @@ export {
   type TBuilderConfig,
 } from './types.js'
 
-import {
+import type {
   TNoContextProvided,
   TBuilderConfig,
   TProcedureRegistration,

package/src/schema/compute-schema.ts

@@ -1,7 +1,8 @@
-import { schemaParser, TSchemaValidationError } from './parser.js'
+import type { TSchemaValidationError } from './parser.js';
+import { schemaParser } from './parser.js'
 import { ProcedureRegistrationError } from '../errors.js'
-import { TJSONSchema } from './types.js'
-import { DefinitionInfo } from '../stack-utils.js'
+import type { TJSONSchema } from './types.js'
+import type { DefinitionInfo } from '../stack-utils.js'
 
 /**
  * This function is used to compute the JSON schema and validation functions

package/src/schema/extract-json-schema.ts

@@ -1,6 +1,6 @@
 import { extractSingleJsonSchema } from 'suretype'
 import { isSuretypeSchema, isTypeboxSchema } from './resolve-schema-lib.js'
-import { TJSONSchema } from './types.js'
+import type { TJSONSchema } from './types.js'
 
 export function extractJsonSchema(libSchema: unknown): TJSONSchema | undefined {
   if (isTypeboxSchema(libSchema)) {

package/src/schema/parser.ts

@@ -1,7 +1,7 @@
 import { default as addFormats } from 'ajv-formats'
 import * as AJV from 'ajv'
 import { extractJsonSchema } from './extract-json-schema.js'
-import { TJSONSchema } from './types.js'
+import type { TJSONSchema } from './types.js'
 
 export type TSchemaParsed = {
   jsonSchema: {

package/src/schema/resolve-schema-lib.ts

@@ -1,5 +1,5 @@
-import { CoreValidator } from 'suretype'
-import { Type } from 'typebox'
+import type { CoreValidator } from 'suretype'
+import type { Type } from 'typebox'
 
 export type IsTypeboxSchema<TSchema> = TSchema extends {
   static: unknown

package/src/schema/types.ts

@@ -1,5 +1,5 @@
-import { CoreValidator, TypeOf } from 'suretype'
-import { Static, TSchema } from 'typebox'
+import type { CoreValidator, TypeOf } from 'suretype'
+import type { Static, TSchema } from 'typebox'
 
 // Determine if the generic "SchemaLibType" is Suretype's CoreValidator or Typebox's TSchema
 export type TSchemaLib<SchemaLibType> =

package/src/stack-utils.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from 'vitest'
-import { captureDefinitionInfo, formatDefinitionInfo, DefinitionInfo } from './stack-utils.js'
+import type { DefinitionInfo } from './stack-utils.js';
+import { captureDefinitionInfo, formatDefinitionInfo } from './stack-utils.js'
 
 describe('Stack Utils', () => {
   describe('captureDefinitionInfo', () => {

package/src/types.ts

@@ -1,5 +1,5 @@
-import { ProcedureError } from './errors.js'
-import { TJSONSchema } from './schema/types.js'
+import type { ProcedureError } from './errors.js'
+import type { TJSONSchema } from './schema/types.js'
 
 export type TNoContextProvided = unknown