jax-hono 1.0.0

package/build/generate-registry.ts

@@ -0,0 +1,615 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { basename, join, parse, relative } from 'node:path'
+
+const srcDir = join(import.meta.dir, '../..')
+const generatedDir = join(srcDir, 'jax/generated')
+const moduleExtensions = new Set(['.ts', '.js', '.mjs', '.cjs'])
+const generatedHeader = `// This file is generated by src/jax/build/generate-registry.ts.
+// Do not edit it directly.
+`
+
+type ControllerGroup = {
+  name: string
+  dirs: string[]
+  suffix?: string
+}
+
+type PluginConfigItem =
+  | false
+  | {
+      enable?: boolean
+      package?: string
+      options?: unknown
+    }
+
+type PluginConfig = Record<string, PluginConfigItem>
+
+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' },
+  { name: 'open', dirs: ['open', 'controllers/open', 'controller/open', 'modules'], suffix: '.open' },
+  { name: 'client', dirs: ['client', 'controllers/client', 'controller/client', 'modules'], suffix: '.client' },
+  { name: 'controller', dirs: ['controllers', 'controller'] },
+]
+
+const scopedControllerGroups = new Set(
+  controllerGroups
+    .filter((group) => group.name !== 'controller')
+    .map((group) => group.name),
+)
+
+function walkFiles(dir: string): string[] {
+  if (!existsSync(dir)) {
+    return []
+  }
+
+  const files: string[] = []
+
+  for (const item of readdirSync(dir, { withFileTypes: true })) {
+    const itemPath = join(dir, item.name)
+
+    if (item.isDirectory()) {
+      files.push(...walkFiles(itemPath))
+      continue
+    }
+
+    if (item.isFile() && moduleExtensions.has(parse(item.name).ext)) {
+      files.push(itemPath)
+    }
+  }
+
+  return files
+}
+
+function writeGeneratedFile(fileName: string, content: string) {
+  const outputFile = join(generatedDir, fileName)
+
+  mkdirSync(generatedDir, { recursive: true })
+
+  if (existsSync(outputFile) && readFileSync(outputFile, 'utf8') === content) {
+    return
+  }
+
+  writeFileSync(outputFile, content)
+  console.log(`Generated ${relative(srcDir, outputFile)}.`)
+}
+
+function toImportPath(filePath: string) {
+  const path = relative(srcDir, filePath)
+    .replace(parse(filePath).ext, '')
+    .replaceAll('\\', '/')
+
+  return `@/${path}`
+}
+
+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())
+}
+
+function toPascalCase(value: string) {
+  const camel = toCamelCase(value)
+
+  return camel.charAt(0).toUpperCase() + camel.slice(1)
+}
+
+function toServiceKey(name: string) {
+  const baseName = name.endsWith('Service')
+    ? name.slice(0, -'Service'.length)
+    : name
+
+  return baseName.replace(/^./, (char) => char.toLowerCase())
+}
+
+function toMiddlewareKey(exportName: string) {
+  return exportName.endsWith('Middleware')
+    ? exportName.slice(0, -'Middleware'.length)
+    : exportName
+}
+
+function stripKnownSuffix(modulePath: string, suffixes: string[]) {
+  for (const suffix of suffixes) {
+    if (modulePath.endsWith(suffix)) {
+      return modulePath.slice(0, -suffix.length)
+    }
+  }
+
+  return modulePath
+}
+
+function normalizeModulePath(modulePath: string) {
+  const parts = modulePath.split('/')
+  const last = parts.at(-1)
+  const parent = parts.at(-2)
+
+  return last && parent && last === parent
+    ? parts.slice(0, -1).join('/')
+    : modulePath
+}
+
+function toModulePath(baseDir: string, filePath: string, suffixes: string[] = []) {
+  const modulePath = relative(join(srcDir, baseDir), filePath)
+    .replace(parse(filePath).ext, '')
+    .replaceAll('\\', '/')
+  const withoutIndex = modulePath.endsWith('/index')
+    ? modulePath.slice(0, -'/index'.length)
+    : modulePath
+
+  const stripped = stripKnownSuffix(withoutIndex, suffixes)
+
+  return baseDir === 'modules' ? normalizeModulePath(stripped) : stripped
+}
+
+function uniqueSorted(values: string[]) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right))
+}
+
+function getFilesFromDirs(dirs: string[]) {
+  return uniqueSorted(dirs.flatMap((dirName) => walkFiles(join(srcDir, dirName))))
+}
+
+function isFileInDir(filePath: string, dirName: string) {
+  const rel = relative(join(srcDir, dirName), filePath)
+
+  return rel && !rel.startsWith('..')
+}
+
+function isSuffixedModuleFile(filePath: string, suffix: string) {
+  return relative(srcDir, filePath)
+    .replace(parse(filePath).ext, '')
+    .replaceAll('\\', '/')
+    .endsWith(suffix)
+}
+
+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 indentObject(content: string, spaces = 2) {
+  if (!content) {
+    return ''
+  }
+
+  const indent = ' '.repeat(spaces)
+
+  return content
+    .split('\n')
+    .map((line) => `${indent}${line}`)
+    .join('\n')
+}
+
+function buildNestedObject(entries: { path: string[]; value: string }[]): string {
+  const groups = new Map<string, { path: string[]; value: string }[]>()
+  const leaves: { key: string; value: string }[] = []
+
+  for (const entry of entries) {
+    const [head, ...tail] = entry.path
+
+    if (!head) {
+      continue
+    }
+
+    if (tail.length === 0) {
+      leaves.push({ key: head, value: entry.value })
+      continue
+    }
+
+    groups.set(head, [...(groups.get(head) ?? []), { path: tail, value: entry.value }])
+  }
+
+  const lines = [
+    ...leaves.map((leaf) => `${toObjectKey(leaf.key)}: ${leaf.value},`),
+    ...[...groups.entries()].map(([key, groupEntries]) => {
+      return `${toObjectKey(key)}: {\n${indentObject(buildNestedObject(groupEntries), 2)}\n},`
+    }),
+  ]
+
+  return lines.join('\n')
+}
+
+function generateControllersRegistry() {
+  const used = new Set<string>()
+  const imports: string[] = []
+  const groupLines: string[] = []
+
+  for (const group of controllerGroups) {
+    const entries = getFilesFromDirs(group.dirs)
+      .filter((filePath) => basename(filePath) !== 'index.ts')
+      .filter((filePath) => !group.suffix || isModuleFeatureFile(filePath, group.suffix))
+      .filter(hasDefaultExport)
+      .map((filePath, 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'])
+
+        return { modulePath, importName, filePath }
+      })
+      .filter((entry) => {
+        if (group.name !== 'controller') {
+          return true
+        }
+
+        const [scope] = entry.modulePath.split('/')
+
+        return !scopedControllerGroups.has(scope)
+      })
+      .filter((entry) => {
+        const key = `${group.name}:${entry.modulePath}`
+
+        if (used.has(key)) {
+          return false
+        }
+
+        used.add(key)
+
+        return true
+      })
+
+    imports.push(...entries.map((entry) => `import ${entry.importName} from '${toImportPath(entry.filePath)}'`))
+
+    if (entries.length === 0) {
+      continue
+    }
+
+    const objectBody = indentObject(
+      buildNestedObject(entries.map((entry) => ({
+        path: entry.modulePath.split('/').map(toCamelCase),
+        value: `createController(${entry.importName})`,
+      }))),
+      4,
+    )
+
+    groupLines.push(`  ${group.name}: {\n${objectBody}\n  },`)
+  }
+
+  const helperImport = imports.length > 0
+    ? `import { createController } from '@/jax/core/controller'\n`
+    : ''
+  const content = `${generatedHeader}
+${helperImport}${imports.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')}
+}
+`
+
+  writeGeneratedFile('middlewares.generated.ts', content)
+}
+
+function generateModelsRegistry() {
+  const files = getFilesFromDirs(['models', 'model', 'modules'])
+    .filter((filePath) => isModuleFeatureFile(filePath, '.model'))
+  const imports: string[] = []
+  const entries: string[] = []
+
+  files.forEach((filePath) => {
+    const source = readFileSync(filePath, 'utf8')
+    const exportedModels = [...source.matchAll(/\bexport\s+const\s+([a-zA-Z_$][a-zA-Z0-9_$]*Model)\b/g)]
+      .map((match) => match[1])
+      .sort((left, right) => left.localeCompare(right))
+
+    if (exportedModels.length === 0) {
+      return
+    }
+
+    const modelKey = source.match(/\bexport\s+const\s+modelKey\s*=\s*['"]([a-zA-Z_$][a-zA-Z0-9_$]*)['"]/)?.[1]
+
+    imports.push(`import { ${exportedModels.join(', ')} } from '${toImportPath(filePath)}'`)
+    entries.push(...exportedModels.map((name) => {
+      const key = exportedModels.length === 1 && modelKey
+        ? modelKey
+        : name.slice(0, -'Model'.length)
+
+      return `  ${key}: ${name},`
+    }))
+  })
+
+  const content = `${generatedHeader}
+${imports.join('\n')}
+
+export const models = {
+${entries.join('\n')}
+}
+
+export type Models = typeof models
+`
+
+  writeGeneratedFile('models.generated.ts', content)
+}
+
+function generateServicesRegistry() {
+  const files = getFilesFromDirs(['services', 'service', 'modules'])
+    .filter((filePath) => isModuleFeatureFile(filePath, '.service'))
+  const imports: string[] = []
+  const entries: string[] = []
+
+  files.forEach((filePath) => {
+    const source = readFileSync(filePath, 'utf8')
+    const namedServiceClasses = [...source.matchAll(/\bexport\s+class\s+([a-zA-Z_$][a-zA-Z0-9_$]*Service)\b/g)]
+      .map((match) => match[1])
+      .sort((left, right) => left.localeCompare(right))
+    const defaultServiceClass = source.match(/\bexport\s+default\s+class(?:\s+([a-zA-Z_$][a-zA-Z0-9_$]*))?/)
+    const defaultServiceName = defaultServiceClass
+      ? defaultServiceClass[1] ?? `${toPascalCase(toModulePath('services', filePath))}Service`
+      : ''
+    const defaultImportName = defaultServiceName
+      ? toIdentifier([defaultServiceName, 'Default'])
+      : ''
+
+    if (namedServiceClasses.length === 0 && !defaultServiceName) {
+      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')}
+  }
+}
+
+export type Services = ReturnType<typeof createServices>
+`
+
+  writeGeneratedFile('services.generated.ts', content)
+}
+
+function findBalancedObject(source: string, startIndex: number) {
+  let depth = 0
+  let quote: string | undefined
+  let escaped = false
+  let lineComment = false
+  let blockComment = false
+
+  for (let index = startIndex; index < source.length; index += 1) {
+    const char = source[index]
+    const next = source[index + 1]
+
+    if (lineComment) {
+      if (char === '\n') {
+        lineComment = false
+      }
+      continue
+    }
+
+    if (blockComment) {
+      if (char === '*' && next === '/') {
+        blockComment = false
+        index += 1
+      }
+      continue
+    }
+
+    if (quote) {
+      if (escaped) {
+        escaped = false
+        continue
+      }
+
+      if (char === '\\') {
+        escaped = true
+        continue
+      }
+
+      if (char === quote) {
+        quote = undefined
+      }
+      continue
+    }
+
+    if (char === '/' && next === '/') {
+      lineComment = true
+      index += 1
+      continue
+    }
+
+    if (char === '/' && next === '*') {
+      blockComment = true
+      index += 1
+      continue
+    }
+
+    if (char === '"' || char === '\'' || char === '`') {
+      quote = char
+      continue
+    }
+
+    if (char === '{') {
+      depth += 1
+      continue
+    }
+
+    if (char === '}') {
+      depth -= 1
+
+      if (depth === 0) {
+        return source.slice(startIndex, index + 1)
+      }
+    }
+  }
+
+  return undefined
+}
+
+function extractPluginConfigObject(source: string) {
+  const configCallIndex = source.indexOf('definePluginConfig')
+  const searchStart = configCallIndex >= 0 ? configCallIndex : source.indexOf('export default')
+  const objectStart = searchStart >= 0 ? source.indexOf('{', searchStart) : -1
+
+  if (objectStart < 0) {
+    return undefined
+  }
+
+  return findBalancedObject(source, objectStart)
+}
+
+function readPluginConfig(filePath: string): PluginConfig {
+  if (!existsSync(filePath)) {
+    return {}
+  }
+
+  const objectSource = extractPluginConfigObject(readFileSync(filePath, 'utf8'))
+
+  if (!objectSource) {
+    return {}
+  }
+
+  try {
+    const value = new Function(`return (${objectSource})`)() as unknown
+
+    return value && typeof value === 'object' && !Array.isArray(value)
+      ? (value as PluginConfig)
+      : {}
+  } catch (error) {
+    throw new Error(`Invalid plugin config ${relative(srcDir, filePath)}: ${(error as Error).message}`)
+  }
+}
+
+function normalizePluginPackage(packageName: string, configFile: string) {
+  if (!packageName.startsWith('./') && !packageName.startsWith('../')) {
+    return packageName
+  }
+
+  const normalized = relative(srcDir, join(configFile, '..', packageName))
+    .replaceAll('\\', '/')
+    .replace(/\/index$/, '')
+
+  if (normalized.startsWith('jax/')) {
+    return normalized
+  }
+
+  return `@/${normalized}`
+}
+
+function mergePluginConfig(configs: { filePath: string; config: PluginConfig }[]) {
+  const merged = new Map<string, Exclude<PluginConfigItem, false>>()
+
+  for (const { filePath, config } of configs) {
+    for (const [name, item] of Object.entries(config)) {
+      if (item === false) {
+        merged.delete(name)
+        continue
+      }
+
+      const current = merged.get(name) ?? {}
+      const next = { ...current, ...item }
+
+      if (next.package) {
+        next.package = normalizePluginPackage(next.package, filePath)
+      }
+
+      merged.set(name, next)
+    }
+  }
+
+  return [...merged.entries()]
+    .filter((entry): entry is [string, Exclude<PluginConfigItem, false> & { package: string }] => {
+      const [, item] = entry
+
+      return item.enable === true && typeof item.package === 'string' && item.package.length > 0
+    })
+    .sort(([left], [right]) => left.localeCompare(right))
+}
+
+function serializePluginOptions(options: unknown) {
+  return options === undefined ? '' : `, options: ${JSON.stringify(options)}`
+}
+
+function generatePluginContextRegistry() {
+  const enabledPlugins = mergePluginConfig([
+    { filePath: join(srcDir, 'jax/plugins/config.ts'), config: readPluginConfig(join(srcDir, 'jax/plugins/config.ts')) },
+    { filePath: join(srcDir, 'config/plugin.ts'), config: readPluginConfig(join(srcDir, 'config/plugin.ts')) },
+  ])
+  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)
+}
+
+export function generateRegistry() {
+  generateControllersRegistry()
+  generateMiddlewaresRegistry()
+  generateModelsRegistry()
+  generateServicesRegistry()
+  generatePluginContextRegistry()
+}
+
+if (import.meta.main) {
+  generateRegistry()
+}

package/config.ts

@@ -0,0 +1,76 @@
+import { existsSync } from 'node:fs';
+import { cwd } from 'node:process';
+import merge from 'deepmerge';
+import { config as loadDotenv } from 'dotenv';
+import minimist from 'minimist';
+import { configModules } from './generated/config';
+import type { ProjectConfig } from './generated/config';
+import type { JaxConfig } from './types/config';
+
+type PlainConfig = Record<string, unknown>;
+export type { JaxConfig } from './types/config';
+export type Config = JaxConfig & ProjectConfig;
+
+loadDotenvFile('.env');
+
+const argv = minimist(Bun.argv.slice(2), {
+  string: ['env'],
+  alias: {
+    env: 'e'
+  }
+});
+
+const env = argv.env || Bun.env.APP_ENV || Bun.env.NODE_ENV || 'prod';
+
+console.log('env', env);
+
+loadDotenvFile(`.env.${env}`);
+
+function loadDotenvFile(file: string) {
+  if (existsSync(file)) {
+    loadDotenv({ path: file, override: true });
+  }
+}
+
+function isPlainConfig(value: unknown): value is PlainConfig {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function shouldUseConfigStage(stage: string) {
+  return stage === 'base' || stage === 'default' || stage === env;
+}
+
+function parsePort(value: string | undefined) {
+  const port = Number(value);
+
+  return Number.isInteger(port) && port > 0 ? port : 3000;
+}
+
+export function loadConfig(): Config {
+  const jaxConfig: JaxConfig = {
+    rootDir: cwd(),
+    port: parsePort(Bun.env.PORT),
+    env
+  };
+
+  const configs = configModules
+    .filter((item) => shouldUseConfigStage(item.stage))
+    .map((item) => {
+      if (!isPlainConfig(item.config)) {
+        throw new TypeError(`Config file ${item.name} must export a plain object.`);
+      }
+
+      return item.config;
+    });
+
+  return merge.all<PlainConfig>([jaxConfig, ...configs], {
+    arrayMerge: (_destination, source) => source
+  }) as Config;
+}
+
+const config = loadConfig();
+
+console.log('port', config.port);
+
+export { env };
+export default config;