jax-hono 1.0.16 → 1.0.17

package/build/generate-registry.ts

@@ -91,18 +91,36 @@ function toImportPath(filePath: string) {
   return path
 }
 
-function toIdentifier(parts: string[]) {
-  const value = parts
-    .join('_')
+function toIdentifier(parts: string[]) {
+  const value = parts
+    .join('_')
     .replace(/[^a-zA-Z0-9_$]/g, '_')
     .replace(/^([^a-zA-Z_$])/, '_$1')
-
-  return value || 'module'
-}
-
-function toCamelCase(value: string) {
-  return value.replace(/[-_]+([a-zA-Z0-9])/g, (_match, char: string) => char.toUpperCase())
-}
+
+  return value || 'module'
+}
+
+function toLowerCamelIdentifier(parts: string[], suffix = '') {
+  const words = parts
+    .join('/')
+    .split(/[^a-zA-Z0-9_$]+/)
+    .filter(Boolean)
+  const value = words
+    .map((word, index) => {
+      const normalized = toCamelCase(word)
+
+      return index === 0
+        ? normalized.charAt(0).toLowerCase() + normalized.slice(1)
+        : toPascalCase(normalized)
+    })
+    .join('')
+
+  return toIdentifier([`${value}${suffix}`])
+}
+
+function toCamelCase(value: string) {
+  return value.replace(/[-_]+([a-zA-Z0-9])/g, (_match, char: string) => char.toUpperCase())
+}
 
 function toPascalCase(value: string) {
   const camel = toCamelCase(value)
@@ -258,9 +276,10 @@ function buildNestedObject(entries: { path: string[]; value: string }[]): string
   return lines.join('\n')
 }
 
-function generateControllersRegistry() {
+function generateControllersRegistry() {
   const used = new Set<string>()
   const imports: string[] = []
+  const controllerExports: string[] = []
   const groupLines: string[] = []
 
   for (const group of controllerGroups) {
@@ -274,8 +293,9 @@ function generateControllersRegistry() {
         }) ?? group.dirs[0]
         const modulePath = toModulePath(baseDir, filePath, group.suffix ? [group.suffix] : [])
         const importName = toIdentifier([group.name, modulePath, String(index), 'Controller'])
+        const exportName = toLowerCamelIdentifier(group.name === 'controller' ? [modulePath] : [group.name, modulePath], 'Controller')
 
-        return { modulePath, importName, filePath }
+        return { modulePath, importName, exportName, filePath }
       })
     const pluginEntries = group.name === 'controller'
       ? getEnabledPluginFiles('.controller')
@@ -284,8 +304,9 @@ function generateControllersRegistry() {
         .map(({ name, rootDir, filePath }, index) => {
           const modulePath = toPluginModulePath(name, rootDir, filePath, ['.controller'])
           const importName = toIdentifier([group.name, 'plugin', modulePath, String(index), 'Controller'])
+          const exportName = toLowerCamelIdentifier([modulePath], 'Controller')
 
-          return { modulePath, importName, filePath }
+          return { modulePath, importName, exportName, filePath }
         })
       : []
     const entries = [...projectEntries, ...pluginEntries]
@@ -310,15 +331,16 @@ function generateControllersRegistry() {
         return true
       })
 
-    imports.push(...entries.map((entry) => `import ${entry.importName} from '${toImportPath(entry.filePath)}'`))
-
-    if (entries.length === 0) {
-      continue
+    imports.push(...entries.map((entry) => `import ${entry.importName} from '${toImportPath(entry.filePath)}'`))
+    controllerExports.push(...entries.map((entry) => `export const ${entry.exportName} = createController(${entry.importName})`))
+
+    if (entries.length === 0) {
+      continue
     }
 
     const objectBody = buildNestedObject(entries.map((entry) => ({
       path: entry.modulePath.split('/').map(toCamelCase),
-      value: `createController(${entry.importName})`,
+      value: entry.exportName,
     })))
 
     if (group.name === 'controller') {
@@ -331,57 +353,84 @@ function generateControllersRegistry() {
   const helperImport = imports.length > 0
     ? `import { createController } from 'jax-hono/core/controller'\n`
     : ''
-  const content = `${generatedHeader}
-${helperImport}${imports.join('\n')}
-
-export const controllers = {
-${groupLines.join('\n')}
+  const content = `${generatedHeader}
+${helperImport}${imports.join('\n')}
+
+${controllerExports.join('\n')}
+
+export const controllers = {
+${groupLines.join('\n')}
 }
 `
 
   writeGeneratedFile('controllers.generated.ts', content)
 }
 
-function toObjectKey(value: string) {
-  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(value) ? value : JSON.stringify(value)
-}
-
-function generateMiddlewaresRegistry() {
-  const files = getFilesFromDirs(['middlewares', 'middleware', 'modules'])
-    .filter((filePath) => isModuleFeatureFile(filePath, '.middleware'))
-  const imports: string[] = []
-  const entries: string[] = []
-
-  files.forEach((filePath, index) => {
-    const source = readFileSync(filePath, 'utf8')
-    const exportNames = [...source.matchAll(/\bexport\s+(?:const|function)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g)]
-      .map((match) => match[1])
-      .sort((left, right) => left.localeCompare(right))
-
-    if (exportNames.length === 0) {
-      return
-    }
-
-    imports.push(`import { ${exportNames.join(', ')} } from '${toImportPath(filePath)}'`)
-    entries.push(...exportNames.map((name) => `  ${toMiddlewareKey(name)}: ${name},`))
-  })
-
-  const content = `${generatedHeader}
-${imports.join('\n')}
-
-export const middlewares = {
-${entries.join('\n')}
-}
-`
+function toObjectKey(value: string) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(value) ? value : JSON.stringify(value)
+}
+
+function formatExportBlock(names: string[]) {
+  if (names.length === 0) {
+    return ''
+  }
+
+  return `export {\n${names.map((name) => `  ${name},`).join('\n')}\n}\n`
+}
+
+function createGeneratedContent(sections: string[]) {
+  return `${generatedHeader}\n${sections
+    .map((section) => section.trimEnd())
+    .filter((section) => section.trim())
+    .join('\n\n')}\n`
+}
+
+function generateMiddlewaresRegistry() {
+  const files = getFilesFromDirs(['middlewares', 'middleware', 'modules'])
+    .filter((filePath) => isModuleFeatureFile(filePath, '.middleware'))
+  const imports: string[] = []
+  const entries: string[] = []
+  const exportNames = new Set<string>()
 
-  writeGeneratedFile('middlewares.generated.ts', content)
-}
+  files.forEach((filePath) => {
+    const source = readFileSync(filePath, 'utf8')
+    const middlewareNames = [...source.matchAll(/\bexport\s+(?:const|function)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g)]
+      .map((match) => match[1])
+      .sort((left, right) => left.localeCompare(right))
+
+    if (middlewareNames.length === 0) {
+      return
+    }
+
+    imports.push(`import { ${middlewareNames.join(', ')} } from '${toImportPath(filePath)}'`)
+    middlewareNames.forEach((name) => exportNames.add(name))
+    entries.push(...middlewareNames.map((name) => {
+      const key = toMiddlewareKey(name)
+
+      return key === name
+        ? `  ${name},`
+        : `  ${key}: ${name},`
+    }))
+  })
+
+  const exportBlock = formatExportBlock(Array.from(exportNames).sort((left, right) => left.localeCompare(right)))
+  const content = createGeneratedContent([
+    imports.join('\n'),
+    exportBlock,
+    `export const middlewares = {
+${entries.join('\n')}
+}`,
+  ])
+
+  writeGeneratedFile('middlewares.generated.ts', content)
+}
 
 function generateModelsRegistry() {
-  const files = getFilesFromDirs(['models', 'model', 'modules'])
-    .filter((filePath) => isModuleFeatureFile(filePath, '.model'))
-  const imports: string[] = []
-  const entries: string[] = []
+  const files = getFilesFromDirs(['models', 'model', 'modules'])
+    .filter((filePath) => isModuleFeatureFile(filePath, '.model'))
+  const imports: string[] = []
+  const entries: string[] = []
+  const exportNames = new Set<string>()
 
   files.forEach((filePath) => {
     const source = readFileSync(filePath, 'utf8')
@@ -399,25 +448,31 @@ function generateModelsRegistry() {
       filePath,
       ['.model'],
     ))
-
-    imports.push(`import { ${exportedModels.join(', ')} } from '${toImportPath(filePath)}'`)
-    entries.push(...exportedModels.map((name) => {
+
+    imports.push(`import { ${exportedModels.join(', ')} } from '${toImportPath(filePath)}'`)
+    exportedModels.forEach((name) => exportNames.add(name))
+    entries.push(...exportedModels.map((name) => {
       const key = exportedModels.length === 1 && modelKey
         ? modelKey
         : name === `${fileModelName}Model`
           ? fileModelName
           : name
 
-      return `  ${key}: ${name},`
-    }))
-  })
-
-  const content = `${generatedHeader}
-${imports.join('\n')}
-
-export const models = {
-${entries.join('\n')}
-}
+      return key === name
+        ? `  ${name},`
+        : `  ${key}: ${name},`
+    }))
+  })
+
+  const exportBlock = formatExportBlock(Array.from(exportNames).sort((left, right) => left.localeCompare(right)))
+
+  const content = `${generatedHeader}
+${imports.join('\n')}
+
+${exportBlock}
+export const models = {
+${entries.join('\n')}
+}
 
 export type Models = typeof models
 `
@@ -434,6 +489,7 @@ function generateServicesRegistry() {
   ]
   const imports: string[] = []
   const entries: string[] = []
+  const exportNames = new Set<string>()
 
   files.forEach((item) => {
     const { filePath } = item
@@ -456,23 +512,27 @@ function generateServicesRegistry() {
       return
     }
 
-    if (defaultServiceName) {
-      imports.push(`import ${defaultImportName} from '${toImportPath(filePath)}'`)
-      entries.push(`    ${toServiceKey(defaultServiceName)}: new ${defaultImportName}(deps),`)
-    }
-
-    if (namedServiceClasses.length > 0) {
-      imports.push(`import { ${namedServiceClasses.join(', ')} } from '${toImportPath(filePath)}'`)
-      entries.push(...namedServiceClasses.map((name) => `    ${toServiceKey(name)}: new ${name}(deps),`))
-    }
-  })
-
-  const content = `${generatedHeader}
-${imports.join('\n')}
-
-export function createServices(deps: any) {
-  return {
-${entries.join('\n')}
+    if (defaultServiceName) {
+      imports.push(`import ${defaultImportName} from '${toImportPath(filePath)}'`)
+      exportNames.add(`${defaultImportName} as ${defaultServiceName}`)
+      entries.push(`    ${toServiceKey(defaultServiceName)}: new ${defaultImportName}(deps),`)
+    }
+
+    if (namedServiceClasses.length > 0) {
+      imports.push(`import { ${namedServiceClasses.join(', ')} } from '${toImportPath(filePath)}'`)
+      namedServiceClasses.forEach((name) => exportNames.add(name))
+      entries.push(...namedServiceClasses.map((name) => `    ${toServiceKey(name)}: new ${name}(deps),`))
+    }
+  })
+
+  const exportBlock = formatExportBlock(Array.from(exportNames).sort((left, right) => left.localeCompare(right)))
+  const content = `${generatedHeader}
+${imports.join('\n')}
+
+${exportBlock}
+export function createServices(deps: any) {
+  return {
+${entries.join('\n')}
   }
 }
 
@@ -508,19 +568,23 @@ function generateCronsRegistry() {
     })
     .sort((left, right) => left.modulePath.localeCompare(right.modulePath))
 
-  const imports = files.map((item, index) => {
-    return `import * as ${toIdentifier(['cron', item.modulePath, String(index)])} from '${toImportPath(item.filePath)}'`
+  const imports = files.map((item) => {
+    return `import * as ${toLowerCamelIdentifier([item.modulePath], 'Cron')} from '${toImportPath(item.filePath)}'`
   })
-  const entries = files.map((item, index) => {
-    const importName = toIdentifier(['cron', item.modulePath, String(index)])
+  const exportNames = files.map((item) => toLowerCamelIdentifier([item.modulePath], 'Cron'))
+  const entries = files.map((item) => {
+    const importName = toLowerCamelIdentifier([item.modulePath], 'Cron')
 
     return `  { name: ${JSON.stringify(item.modulePath)}, module: ${importName} },`
   })
-  const content = `${generatedHeader}${imports.length > 0 ? `${imports.join('\n')}\n\n` : ''}
-export const cronModules = [
+  const exportBlock = formatExportBlock(exportNames)
+  const content = createGeneratedContent([
+    imports.join('\n'),
+    exportBlock,
+    `export const cronModules = [
 ${entries.join('\n')}
-] as const
-`
+] as const`,
+  ])
 
   writeGeneratedFile('crons.generated.ts', content)
 }
@@ -747,26 +811,30 @@ function serializePluginOptions(options: unknown) {
 
 function generatePluginContextRegistry() {
   const enabledPlugins = getEnabledPluginConfigItems()
-  const imports = enabledPlugins.map(([name, item]) => {
-    return `import ${toIdentifier(['plugin', name])} from ${JSON.stringify(item.package)}`
-  })
-  const moduleEntries = enabledPlugins.map(
-    ([name, item]) =>
-      `  { name: ${JSON.stringify(name)}, module: ${toIdentifier(['plugin', name])}${serializePluginOptions(item.options)} },`,
-  )
-
-  const content = `${generatedHeader}${imports.length > 0 ? `${imports.join('\n')}\n\n` : ''}
-export const plugins = {} as Record<string, unknown>
-
-export type Plugins = typeof plugins
-
-export const pluginModules = [
-${moduleEntries.join('\n')}
-] as const
-`
-
-  writeGeneratedFile('plugins.generated.ts', content)
-}
+  const imports = enabledPlugins.map(([name, item]) => {
+    return `import ${toLowerCamelIdentifier([name], 'Plugin')} from ${JSON.stringify(item.package)}`
+  })
+  const exportNames = enabledPlugins.map(([name]) => toLowerCamelIdentifier([name], 'Plugin'))
+  const moduleEntries = enabledPlugins.map(
+    ([name, item]) =>
+      `  { name: ${JSON.stringify(name)}, module: ${toLowerCamelIdentifier([name], 'Plugin')}${serializePluginOptions(item.options)} },`,
+  )
+  const exportBlock = formatExportBlock(exportNames)
+
+  const content = createGeneratedContent([
+    imports.join('\n'),
+    exportBlock,
+    `export const plugins = {} as Record<string, unknown>
+
+export type Plugins = typeof plugins
+
+export const pluginModules = [
+${moduleEntries.join('\n')}
+] as const`,
+  ])
+
+  writeGeneratedFile('plugins.generated.ts', content)
+}
 
 export function generateRegistry() {
   generateControllersRegistry()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jax-hono",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "Lightweight framework layer on top of Hono, built for Bun",
   "type": "module",
   "main": "./index.ts",