ts-procedures 5.10.0 → 5.12.0

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

@@ -39,76 +39,103 @@ describe('emitIndexFile', () => {
     expect(output).toContain("import type { ClientInstance } from 'ts-procedures/client'")
   })
 
-  it('imports each bind function using the camelCase scope name', () => {
+  it('imports each scope as a namespace using the camelCase scope name', () => {
     const output = emitIndexFile([usersGroup, billingGroup])
-    expect(output).toContain("import { bindUsersScope } from './users'")
-    expect(output).toContain("import { bindBillingScope } from './billing'")
+    expect(output).toContain("import * as users from './users'")
+    expect(output).toContain("import * as billing from './billing'")
   })
 
-  it('re-exports from each scope file', () => {
+  it('does not emit `export *` re-exports', () => {
     const output = emitIndexFile([usersGroup, billingGroup])
-    expect(output).toContain("export * from './users'")
-    expect(output).toContain("export * from './billing'")
+    expect(output).not.toContain('export *')
   })
 
-  it('generates createScopeBindings with correct scope property names', () => {
-    const output = emitIndexFile([usersGroup, billingGroup])
-    expect(output).toContain('export function createScopeBindings(client: ClientInstance)')
-    expect(output).toContain('users: bindUsersScope(client)')
-    expect(output).toContain('billing: bindBillingScope(client)')
+  it('uses the scopeKey for import paths and camelCase for the local alias', () => {
+    const output = emitIndexFile([adminUsersGroup])
+    expect(output).toContain("import * as adminUsers from './admin-users'")
   })
 
-  it('uses camelCase as the property key in createScopeBindings', () => {
-    const output = emitIndexFile([adminUsersGroup])
-    expect(output).toContain('adminUsers: bindAdminUsersScope(client)')
+  it('generates the factory using the default service name (Api)', () => {
+    const output = emitIndexFile([usersGroup, billingGroup])
+    expect(output).toContain('export function createApiBindings(client: ClientInstance)')
+    expect(output).toContain('users: users.bindUsersScope(client)')
+    expect(output).toContain('billing: billing.bindBillingScope(client)')
   })
 
-  it('uses the scopeKey as the import path (not camelCase)', () => {
+  it('uses camelCase as the binding property key', () => {
     const output = emitIndexFile([adminUsersGroup])
-    expect(output).toContain("import { bindAdminUsersScope } from './admin-users'")
-    expect(output).toContain("export * from './admin-users'")
+    expect(output).toContain('adminUsers: adminUsers.bindAdminUsersScope(client)')
   })
 
-  it('handles a single scope group', () => {
-    const output = emitIndexFile([usersGroup])
-    expect(output).toContain('bindUsersScope')
-    expect(output).toContain('users: bindUsersScope(client)')
+  it('places imports before the namespace block before the factory', () => {
+    const output = emitIndexFile([usersGroup, billingGroup], { namespaceTypes: true })
+    const importIdx = output.indexOf("import * as users")
+    const namespaceIdx = output.indexOf('export namespace Api')
+    const factoryIdx = output.indexOf('export function createApiBindings')
+    expect(importIdx).toBeLessThan(namespaceIdx)
+    expect(namespaceIdx).toBeLessThan(factoryIdx)
   })
 
-  it('places imports before re-exports before createScopeBindings', () => {
-    const output = emitIndexFile([usersGroup, billingGroup])
-    const importIdx = output.indexOf("import { bindUsersScope }")
-    const reExportIdx = output.indexOf("export * from './users'")
-    const bindIdx = output.indexOf('export function createScopeBindings')
-    expect(importIdx).toBeLessThan(reExportIdx)
-    expect(reExportIdx).toBeLessThan(bindIdx)
-  })
+  describe('service namespace (namespaceTypes: true)', () => {
+    it('emits a service namespace named after the default Api', () => {
+      const output = emitIndexFile([usersGroup, billingGroup], { namespaceTypes: true })
+      expect(output).toContain('export namespace Api {')
+      expect(output).toContain('export import Users = users.Users')
+      expect(output).toContain('export import Billing = billing.Billing')
+    })
 
-  describe('serviceName', () => {
-    it('uses createScopeBindings when serviceName is not provided', () => {
-      const output = emitIndexFile([usersGroup])
-      expect(output).toContain('export function createScopeBindings(client: ClientInstance)')
+    it('emits a service namespace named after a provided serviceName', () => {
+      const output = emitIndexFile([usersGroup], { namespaceTypes: true, serviceName: 'UsersApi' })
+      expect(output).toContain('export namespace UsersApi {')
+      expect(output).toContain('export import Users = users.Users')
+      expect(output).toContain('export function createUsersApiBindings(client: ClientInstance)')
     })
 
-    it('uses create${ServiceName}Bindings when serviceName is provided', () => {
-      const output = emitIndexFile([usersGroup], { serviceName: 'Auth' })
-      expect(output).toContain('export function createAuthBindings(client: ClientInstance)')
-      expect(output).not.toContain('createScopeBindings')
+    it('PascalCases each scope when re-exporting', () => {
+      const output = emitIndexFile([adminUsersGroup], { namespaceTypes: true })
+      expect(output).toContain('export import AdminUsers = adminUsers.AdminUsers')
     })
 
-    it('PascalCases a kebab-case serviceName', () => {
-      const output = emitIndexFile([usersGroup], { serviceName: 'auth-service' })
+    it('PascalCases a kebab-case serviceName for both namespace and factory', () => {
+      const output = emitIndexFile([usersGroup], { namespaceTypes: true, serviceName: 'auth-service' })
+      expect(output).toContain('export namespace AuthService {')
       expect(output).toContain('export function createAuthServiceBindings(client: ClientInstance)')
     })
 
-    it('PascalCases an underscore-separated serviceName', () => {
-      const output = emitIndexFile([usersGroup], { serviceName: 'users_api' })
-      expect(output).toContain('export function createUsersApiBindings(client: ClientInstance)')
+    it('folds errors into the service namespace as `Errors` when hasErrors is true', () => {
+      const output = emitIndexFile([usersGroup], {
+        namespaceTypes: true,
+        hasErrors: true,
+        serviceName: 'UsersApi',
+      })
+      expect(output).toContain("import * as _errorsModule from './_errors'")
+      expect(output).toContain('export import Errors = _errorsModule.UsersApiErrors')
     })
 
-    it('preserves already-PascalCased serviceName', () => {
-      const output = emitIndexFile([usersGroup, billingGroup], { serviceName: 'UsersApi' })
-      expect(output).toContain('export function createUsersApiBindings(client: ClientInstance)')
+    it('omits the errors import and re-export when hasErrors is false', () => {
+      const output = emitIndexFile([usersGroup], { namespaceTypes: true, hasErrors: false })
+      expect(output).not.toContain("from './_errors'")
+      expect(output).not.toContain('Errors')
+    })
+  })
+
+  describe('namespaceTypes: false', () => {
+    it('skips the service namespace block entirely', () => {
+      const output = emitIndexFile([usersGroup, billingGroup])
+      expect(output).not.toContain('export namespace')
+      expect(output).not.toContain('export import')
+    })
+
+    it('still imports scopes and emits the factory', () => {
+      const output = emitIndexFile([usersGroup, billingGroup])
+      expect(output).toContain("import * as users from './users'")
+      expect(output).toContain('export function createApiBindings(client: ClientInstance)')
+      expect(output).toContain('users: users.bindUsersScope(client)')
+    })
+
+    it('does not import errors even when hasErrors is true', () => {
+      const output = emitIndexFile([usersGroup], { hasErrors: true })
+      expect(output).not.toContain("from './_errors'")
     })
   })
 

package/src/codegen/emit-index.ts

@@ -2,10 +2,7 @@ import type { ScopeGroup } from './group-routes.js'
 import { CODEGEN_HEADER } from './constants.js'
 import { toPascalCase } from './naming.js'
 
-/** Derives the bind function name from a camelCase scope identifier. */
-function bindFunctionName(camelCase: string): string {
-  return `bind${toPascalCase(camelCase)}Scope`
-}
+const ERRORS_MODULE_ALIAS = '_errorsModule'
 
 // ---------------------------------------------------------------------------
 // emitIndexFile
@@ -14,40 +11,66 @@ function bindFunctionName(camelCase: string): string {
 export interface EmitIndexOptions {
   clientImportPath?: string
   hasErrors?: boolean
+  namespaceTypes?: boolean
   serviceName?: string
 }
 
 /**
- * Generates a barrel index file that re-exports all scope files and provides
- * a factory function (`createScopeBindings`, or `create${ServiceName}Bindings`
- * when `serviceName` is set).
+ * Generates a barrel index file that exposes every scope through a single
+ * service namespace (named after `serviceName`, defaulting to `Api`) and a
+ * `create${ServiceName}Bindings` factory.
+ *
+ * The service namespace is only emitted when `namespaceTypes` is on, since
+ * scope files only export top-level namespaces in that mode.
  */
 export function emitIndexFile(groups: ScopeGroup[], options?: EmitIndexOptions): string {
-  const { clientImportPath = 'ts-procedures/client', hasErrors = false, serviceName } = options ?? {}
-  const factoryName = serviceName ? `create${toPascalCase(serviceName)}Bindings` : 'createScopeBindings'
-  const bindImports = groups
-    .map((g) => `import { ${bindFunctionName(g.camelCase)} } from './${g.scopeKey}'`)
-    .join('\n')
+  const {
+    clientImportPath = 'ts-procedures/client',
+    hasErrors = false,
+    namespaceTypes = false,
+    serviceName = 'Api',
+  } = options ?? {}
+
+  const servicePascal = toPascalCase(serviceName)
+  const factoryName = `create${servicePascal}Bindings`
+  const errorsExportedName = `${servicePascal}Errors`
 
-  const scopeReExports = groups
-    .map((g) => `export * from './${g.scopeKey}'`)
+  const scopeImports = groups
+    .map((g) => `import * as ${g.camelCase} from './${g.scopeKey}'`)
     .join('\n')
 
-  const errorsReExport = hasErrors ? `export * from './_errors'` : ''
+  const errorsImport = namespaceTypes && hasErrors
+    ? `import * as ${ERRORS_MODULE_ALIAS} from './_errors'`
+    : ''
 
-  const reExports = [scopeReExports, errorsReExport].filter(Boolean).join('\n')
+  const importsBlock = [scopeImports, errorsImport].filter(Boolean).join('\n')
+
+  let namespaceBlock = ''
+  if (namespaceTypes) {
+    const namespaceMembers = groups.map(
+      (g) => `  export import ${toPascalCase(g.camelCase)} = ${g.camelCase}.${toPascalCase(g.camelCase)}`,
+    )
+    if (hasErrors) {
+      namespaceMembers.push(`  export import Errors = ${ERRORS_MODULE_ALIAS}.${errorsExportedName}`)
+    }
+    namespaceBlock = [
+      `export namespace ${servicePascal} {`,
+      namespaceMembers.join('\n'),
+      '}',
+      '',
+    ].join('\n')
+  }
 
   const scopeBindings = groups
-    .map((g) => `    ${g.camelCase}: ${bindFunctionName(g.camelCase)}(client),`)
+    .map((g) => `    ${g.camelCase}: ${g.camelCase}.bind${toPascalCase(g.camelCase)}Scope(client),`)
     .join('\n')
 
   return [
     CODEGEN_HEADER,
     `import type { ClientInstance } from '${clientImportPath}'`,
-    bindImports,
-    '',
-    reExports,
+    importsBlock,
     '',
+    namespaceBlock,
     `export function ${factoryName}(client: ClientInstance) {`,
     '  return {',
     scopeBindings,

package/src/codegen/pipeline.test.ts

@@ -114,14 +114,14 @@ describe('generateClient pipeline', () => {
     expect(content).toContain('CreateInvoice')
   })
 
-  it('index.ts exports from both scope files and has createScopeBindings', async () => {
+  it('index.ts imports both scope namespaces and emits the default Api factory', async () => {
     tmpDir = makeTmpDir()
     await generateClient({ envelope, outDir: tmpDir })
 
     const content = readFileSync(join(tmpDir, 'index.ts'), 'utf-8')
-    expect(content).toContain("from './users'")
-    expect(content).toContain("from './billing'")
-    expect(content).toContain('createScopeBindings')
+    expect(content).toContain("import * as users from './users'")
+    expect(content).toContain("import * as billing from './billing'")
+    expect(content).toContain('createApiBindings')
   })
 
   it('creates outDir if it does not exist', async () => {

package/src/codegen/pipeline.ts

@@ -28,10 +28,9 @@ export interface GeneratedFile {
 }
 
 export async function runPipeline(options: PipelineOptions): Promise<GeneratedFile[]> {
-  const { envelope, outDir, ajsc: ajscOpts, dryRun = false, namespaceTypes = false, selfContained = false, serviceName } = options
-  if (serviceName != null) {
-    validateServiceName(serviceName)
-  }
+  const { envelope, outDir, ajsc: ajscOpts, dryRun = false, namespaceTypes = false, selfContained = false } = options
+  const serviceName = options.serviceName ?? 'Api'
+  validateServiceName(serviceName)
   const clientImportPath = selfContained ? './_types' : options.clientImportPath
   if (selfContained && options.clientImportPath != null) {
     console.warn('[ts-procedures-codegen] --self-contained overrides --client-import-path; using ./_types')
@@ -72,7 +71,7 @@ export async function runPipeline(options: PipelineOptions): Promise<GeneratedFi
     files.push({ path: join(outDir, '_errors.ts'), code: errorsWithHash })
   }
 
-  const rawIndexCode = emitIndexFile(groupArray, { clientImportPath, hasErrors, serviceName })
+  const rawIndexCode = emitIndexFile(groupArray, { clientImportPath, hasErrors, namespaceTypes, serviceName })
   const indexLines = rawIndexCode.split('\n')
   indexLines.splice(1, 0, hashComment)
   const indexCode = indexLines.join('\n')