jax-hono 1.1.0 → 1.1.1

package/build/generate-registry.ts

@@ -39,6 +39,12 @@ type PluginFile = EnabledPlugin & {
   filePath: string
 }
 
+type ControllerExportInfo = {
+  defaultClass: boolean
+  namedClasses: string[]
+  namedValues: string[]
+}
+
 const controllerGroups: ControllerGroup[] = [
   { name: 'api', dirs: ['api', 'controllers/api', 'controller/api', 'modules'], suffix: '.api' },
   { name: 'backend', dirs: ['backend', 'controllers/backend', 'controller/backend', 'modules'], suffix: '.backend' },
@@ -211,6 +217,11 @@ function getFilesFromDirs(dirs: string[]) {
   return uniqueSorted(dirs.flatMap((dirName) => walkFiles(join(srcDir, dirName))))
 }
 
+function isRootDirIndex(filePath: string, dirs: string[]) {
+  return basename(filePath) === 'index.ts'
+    && dirs.some((dirName) => dirname(filePath) === join(srcDir, dirName))
+}
+
 function getEnabledPluginFiles(suffix: string) {
   return getEnabledPlugins().flatMap((plugin) => {
     return walkFiles(plugin.rootDir)
@@ -240,8 +251,47 @@ function isModuleFeatureFile(filePath: string, suffix: string) {
   return !isFileInDir(filePath, 'modules') || isSuffixedModuleFile(filePath, suffix)
 }
 
-function hasDefaultExport(filePath: string) {
-  return /\bexport\s+default\b/.test(readFileSync(filePath, 'utf8'))
+function getControllerExportInfo(filePath: string): ControllerExportInfo {
+  const source = readFileSync(filePath, 'utf8')
+  const classNames = new Set(
+    [...source.matchAll(/\b(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g)]
+      .map((match) => match[1]),
+  )
+  const defaultIdentifier = source.match(/\bexport\s+default\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\b/)?.[1]
+  const defaultClass = /\bexport\s+default\s+(?:abstract\s+)?class\b/.test(source)
+    || Boolean(defaultIdentifier && classNames.has(defaultIdentifier))
+  const namedClasses = [...source.matchAll(/\bexport\s+(?:abstract\s+)?class\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g)]
+    .map((match) => match[1])
+    .sort((left, right) => left.localeCompare(right))
+  const namedValues = [
+    ...source.matchAll(/\bexport\s+(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g),
+    ...source.matchAll(/\bexport\s+(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/g),
+  ]
+    .map((match) => match[1])
+    .filter((name) => !namedClasses.includes(name))
+    .sort((left, right) => left.localeCompare(right))
+
+  return { defaultClass, namedClasses, namedValues }
+}
+
+function hasControllerExport(info: ControllerExportInfo) {
+  return info.defaultClass || info.namedClasses.length > 0 || info.namedValues.length > 0
+}
+
+function getControllerClassExport(info: ControllerExportInfo) {
+  if (info.defaultClass) {
+    return 'default'
+  }
+
+  return info.namedClasses.find((name) => name.endsWith('Controller')) ?? info.namedClasses[0]
+}
+
+function toControllerNamedExportsObject(namespaceName: string, names: string[]) {
+  if (names.length === 0) {
+    return '{}'
+  }
+
+  return `{\n${indentObject(names.map((name) => `${toObjectKey(name)}: ${namespaceName}.${name},`).join('\n'), 2)}\n}`
 }
 
 function indentObject(content: string, spaces = 2) {
@@ -291,32 +341,37 @@ function generateControllersRegistry() {
   const imports: string[] = []
   const controllerExports: string[] = []
   const groupLines: string[] = []
+  let usesCreateController = false
 
   for (const group of controllerGroups) {
     const projectEntries = getFilesFromDirs(group.dirs)
       .filter((filePath) => basename(filePath) !== 'index.ts')
       .filter((filePath) => !group.suffix || isModuleFeatureFile(filePath, group.suffix))
-      .filter(hasDefaultExport)
-      .map((filePath, index) => {
+      .map((filePath) => ({ filePath, exportInfo: getControllerExportInfo(filePath) }))
+      .filter(({ exportInfo }) => hasControllerExport(exportInfo))
+      .map(({ filePath, exportInfo }, index) => {
         const baseDir = group.dirs.find((dirName) => {
           return isFileInDir(filePath, dirName)
         }) ?? group.dirs[0]
         const modulePath = toModulePath(baseDir, filePath, group.suffix ? [group.suffix] : [])
         const importName = toIdentifier([group.name, modulePath, String(index), 'Controller'])
+        const namespaceName = toIdentifier([group.name, modulePath, String(index), 'ControllerExports'])
         const exportName = toLowerCamelIdentifier(group.name === 'controller' ? [modulePath] : [group.name, modulePath], 'Controller')
 
-        return { modulePath, importName, exportName, filePath }
+        return { modulePath, importName, namespaceName, exportName, filePath, exportInfo }
       })
     const pluginEntries = group.name === 'controller'
       ? getEnabledPluginFiles('.controller')
         .filter(({ filePath }) => basename(filePath) !== 'index.ts')
-        .filter(({ filePath }) => hasDefaultExport(filePath))
-        .map(({ name, rootDir, filePath }, index) => {
+        .map((item) => ({ ...item, exportInfo: getControllerExportInfo(item.filePath) }))
+        .filter(({ exportInfo }) => hasControllerExport(exportInfo))
+        .map(({ name, rootDir, filePath, exportInfo }, index) => {
           const modulePath = toPluginModulePath(name, rootDir, filePath, ['.controller'])
           const importName = toIdentifier([group.name, 'plugin', modulePath, String(index), 'Controller'])
+          const namespaceName = toIdentifier([group.name, 'plugin', modulePath, String(index), 'ControllerExports'])
           const exportName = toLowerCamelIdentifier([modulePath], 'Controller')
 
-          return { modulePath, importName, exportName, filePath }
+          return { modulePath, importName, namespaceName, exportName, filePath, exportInfo }
         })
       : []
     const entries = [...projectEntries, ...pluginEntries]
@@ -341,8 +396,33 @@ function generateControllersRegistry() {
         return true
       })
 
-    imports.push(...entries.map((entry) => `import ${entry.importName} from '${toImportPath(entry.filePath)}'`))
-    controllerExports.push(...entries.map((entry) => `export const ${entry.exportName} = createController(${entry.importName})`))
+    imports.push(...entries.flatMap((entry) => {
+      const importPath = toImportPath(entry.filePath)
+      const classExport = getControllerClassExport(entry.exportInfo)
+      const defaultImport = classExport === 'default'
+        ? [`import ${entry.importName} from '${importPath}'`]
+        : []
+
+      return [
+        ...defaultImport,
+        `import * as ${entry.namespaceName} from '${importPath}'`,
+      ]
+    }))
+    controllerExports.push(...entries.map((entry) => {
+      const classExport = getControllerClassExport(entry.exportInfo)
+      const namedExports = toControllerNamedExportsObject(entry.namespaceName, entry.exportInfo.namedValues)
+
+      if (!classExport) {
+        return `export const ${entry.exportName} = ${namedExports}`
+      }
+
+      usesCreateController = true
+      const controllerExport = classExport === 'default'
+        ? entry.importName
+        : `${entry.namespaceName}.${classExport}`
+
+      return `export const ${entry.exportName} = createController(${controllerExport}, ${namedExports})`
+    }))
 
     if (entries.length === 0) {
       continue
@@ -360,7 +440,7 @@ function generateControllersRegistry() {
     }
   }
 
-  const helperImport = imports.length > 0
+  const helperImport = usesCreateController
     ? `import { createController } from 'jax-hono/core/controller'\n`
     : ''
   const content = `${generatedHeader}
@@ -442,9 +522,10 @@ ${entries.join('\n')}
 }
 
 function generateServicesRegistry() {
+  const serviceDirs = ['services', 'service']
   const files = [
-    ...getFilesFromDirs(['services', 'service'])
-      .filter((filePath) => basename(filePath) !== 'index.ts')
+    ...getFilesFromDirs(serviceDirs)
+      .filter((filePath) => !isRootDirIndex(filePath, serviceDirs))
       .map((filePath) => ({ filePath })),
   ]
   const imports: string[] = []
@@ -454,7 +535,7 @@ function generateServicesRegistry() {
   files.forEach((item) => {
     const { filePath } = item
     const source = readFileSync(filePath, 'utf8')
-    const namedServiceObjects = [...source.matchAll(/\bexport\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*Service)\b/g)]
+    const namedServiceObjects = [...source.matchAll(/\bexport\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*(?:Service|Adapters))\b/g)]
       .map((match) => match[1])
       .sort((left, right) => left.localeCompare(right))
 

package/core/controller.ts

@@ -5,6 +5,9 @@ import type { GeneratedPlugins, GeneratedServices } from './generated';
 const controllerContextStorage = new AsyncLocalStorage<Context>();
 type ControllerConstructor<T extends Controller> = new (...args: any[]) => T;
 type ControllerExport<T extends Controller> = T | ControllerConstructor<T>;
+type ControllerNamedExports = Record<string, unknown>;
+type ControllerResult<T extends Controller, TNamedExports extends ControllerNamedExports> =
+  T & Omit<TNamedExports, 'default'>;
 
 const bodyCache = new WeakMap<Context, unknown>();
 
@@ -22,8 +25,33 @@ export function getJaxContext() {
   return context;
 }
 
-export function createController<T extends Controller>(controller: ControllerExport<T>) {
-  return typeof controller === 'function' ? new controller() : controller;
+export function createController<T extends Controller>(
+  controller: ControllerExport<T>,
+): T;
+export function createController<T extends Controller, TNamedExports extends ControllerNamedExports>(
+  controller: ControllerExport<T>,
+  namedExports: TNamedExports,
+): ControllerResult<T, TNamedExports>;
+export function createController<T extends Controller>(
+  controller: ControllerExport<T>,
+  namedExports: ControllerNamedExports = {},
+): T & ControllerNamedExports {
+  const instance = (typeof controller === 'function' ? new controller() : controller) as T & ControllerNamedExports;
+
+  for (const [name, value] of Object.entries(namedExports)) {
+    if (name === 'default') {
+      continue;
+    }
+
+    Object.defineProperty(instance, name, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value,
+    });
+  }
+
+  return instance;
 }
 
 export abstract class Controller {

package/package.json

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