create-taserjs 0.0.0

package/src/core/scaffold-engine.ts

@@ -0,0 +1,82 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+import { collectBootBindings, resolveAddons } from '../addons/registry.js'
+import { indexTemplate, taserTsTemplate } from '../frameworks/index.js'
+import { installPackages, resolveUserAgent } from './package-manager.js'
+import { writeProjectConfig } from './project-config.js'
+import { resolvePackages } from './resolve-packages.js'
+import type { ScaffoldOptions, ScaffoldResult } from './types.js'
+import {
+  contextTemplate,
+  gitignoreTemplate,
+  healthRouteTemplate,
+  indexRouteTemplate,
+  packageJsonTemplate,
+  rootLayoutTemplate,
+  starterManifestTemplate,
+  tsconfigTemplate,
+  tsdownConfigTemplate,
+} from '../templates/base.js'
+
+async function write(filePath: string, contents: string): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true })
+  await writeFile(filePath, contents, 'utf8')
+}
+
+export async function scaffoldProject(options: ScaffoldOptions): Promise<ScaffoldResult> {
+  const root = options.targetDir
+  const ctx = {
+    projectName: options.projectName,
+    targetDir: root,
+    framework: options.framework,
+    ...(options.db ? { db: options.db, driver: options.driver } : {}),
+    ...(options.logger ? { logger: options.logger } : {}),
+  }
+
+  const addons = resolveAddons(ctx)
+  const packages = resolvePackages(ctx)
+  const bootBindings = collectBootBindings(ctx)
+
+  await write(path.join(root, 'package.json'), packageJsonTemplate(options.projectName, packages.scripts))
+  await write(path.join(root, 'tsconfig.json'), tsconfigTemplate())
+  await write(path.join(root, 'tsdown.config.ts'), tsdownConfigTemplate())
+  await write(path.join(root, '.gitignore'), gitignoreTemplate())
+  await write(path.join(root, 'src/context.ts'), contextTemplate(bootBindings))
+  await write(path.join(root, 'src/taser.ts'), taserTsTemplate(options.framework))
+  await write(path.join(root, 'src/index.ts'), indexTemplate(options.framework))
+  await write(path.join(root, 'src/routes/$.ts'), rootLayoutTemplate())
+  await write(path.join(root, 'src/routes/index.get.ts'), indexRouteTemplate())
+  await write(path.join(root, 'src/routes/health.get.ts'), healthRouteTemplate(ctx))
+  await write(path.join(root, 'src/routeManifest.gen.ts'), starterManifestTemplate())
+
+  for (const addon of addons) {
+    await addon.apply(ctx, (filePath, contents) => write(path.join(root, filePath), contents))
+  }
+
+  await writeProjectConfig(root, ctx)
+
+  if (options.skipInstall) {
+    return {
+      projectName: ctx.projectName,
+      targetDir: root,
+      framework: ctx.framework,
+      ...(ctx.db ? { db: ctx.db, driver: ctx.driver } : {}),
+      ...(ctx.logger ? { logger: ctx.logger } : {}),
+    }
+  }
+
+  const agent = options.agent ?? resolveUserAgent()
+  await installPackages(agent, root, {
+    dependencies: packages.dependencies,
+    devDependencies: packages.devDependencies,
+  })
+
+  return {
+    projectName: ctx.projectName,
+    targetDir: root,
+    framework: ctx.framework,
+    ...(ctx.db ? { db: ctx.db, driver: ctx.driver } : {}),
+    ...(ctx.logger ? { logger: ctx.logger } : {}),
+  }
+}

package/src/core/types.ts

@@ -0,0 +1,51 @@
+import type { Agent } from 'package-manager-detector'
+
+export type Framework = 'node' | 'express' | 'hono' | 'fastify'
+
+export const FRAMEWORKS: readonly Framework[] = ['node', 'express', 'hono', 'fastify']
+
+export type DbOdm = 'drizzle' | 'prisma' | 'kysely'
+
+export const DB_ODMS: readonly DbOdm[] = ['drizzle', 'prisma', 'kysely']
+
+export type DbDriver = 'postgres' | 'sqlite' | 'mysql'
+
+export const DB_DRIVERS: readonly DbDriver[] = ['postgres', 'sqlite', 'mysql']
+
+export const DEFAULT_DB_DRIVER: DbDriver = 'sqlite'
+
+export type LoggerId = 'pino' | 'winston'
+
+export const LOGGERS: readonly LoggerId[] = ['pino', 'winston']
+
+export type PackageGroups = {
+  dependencies: string[]
+  devDependencies: string[]
+  scripts: Record<string, string>
+}
+
+export type ScaffoldContext = {
+  projectName: string
+  targetDir: string
+  framework: Framework
+  db?: DbOdm
+  driver?: DbDriver
+  logger?: LoggerId
+}
+
+export type ScaffoldOptions = ScaffoldContext & {
+  skipInstall?: boolean
+  agent?: Agent
+}
+
+export type ScaffoldResult = ScaffoldContext
+
+export type CapabilitiesCatalog = {
+  frameworks: Framework[]
+  db: {
+    odms: DbOdm[]
+    drivers: DbDriver[]
+    defaultDriver: DbDriver
+  }
+  loggers: LoggerId[]
+}

package/src/core/validate-project-name.ts

@@ -0,0 +1,59 @@
+import path from 'node:path'
+
+const RESERVED_WINDOWS_NAMES = new Set([
+  'CON',
+  'PRN',
+  'AUX',
+  'NVR',
+  'NULL',
+  'COM1',
+  'COM2',
+  'COM3',
+  'COM4',
+  'COM5',
+  'COM6',
+  'COM7',
+  'COM8',
+  'COM9',
+  'LPT1',
+  'LPT2',
+  'LPT3',
+  'LPT4',
+  'LPT5',
+  'LPT6',
+  'LPT7',
+  'LPT8',
+  'LPT9',
+])
+
+export function validateProjectName(name: string, cwd = process.cwd()): string | undefined {
+  const trimmed = name.trim()
+  if (!trimmed) {
+    return 'Project name is required'
+  }
+
+  if (trimmed.includes('..')) {
+    return 'Project name cannot contain ".."'
+  }
+
+  if (trimmed.includes('/') || trimmed.includes('\\')) {
+    return 'Project name cannot contain path separators'
+  }
+
+  if (trimmed.startsWith('.') || trimmed.endsWith('.')) {
+    return 'Project name cannot start or end with a dot'
+  }
+
+  const baseName = trimmed.split('.')[0]?.toUpperCase()
+  if (baseName && RESERVED_WINDOWS_NAMES.has(baseName)) {
+    return `Project name "${trimmed}" is reserved on Windows`
+  }
+
+  const targetDir = path.resolve(cwd, trimmed)
+  const relative = path.relative(cwd, targetDir)
+  if (relative.startsWith('..') || path.isAbsolute(relative)) {
+    return 'Project name resolves outside the current directory'
+  }
+
+  return undefined
+}

package/src/frameworks/index.ts

@@ -0,0 +1,111 @@
+import type { Framework } from '../core/types.js'
+
+export function indexTemplate(framework: Framework): string {
+  switch (framework) {
+    case 'express':
+      return `import express from 'express'
+import { createExpressHandler } from '@taserjs/adapter-express'
+
+import { routeManifest } from '#src/routeManifest.gen.js'
+import { t } from '#src/taser.js'
+
+const router = t.create(routeManifest)
+
+const taser = createExpressHandler(router)
+const app = express()
+taser.mount('/api{/*splat}', app)
+
+const port = Number(process.env.PORT ?? 3000)
+app.listen(port, () => {
+  console.log(\`Express listening on http://localhost:\${port}\`)
+})
+`
+    case 'hono':
+      return `import { serve } from '@hono/node-server'
+import { Hono } from 'hono'
+
+import { routeManifest } from '#src/routeManifest.gen.js'
+import { t } from '#src/taser.js'
+
+const router = t.create(routeManifest)
+
+const app = new Hono()
+const api = router.base('/api')
+app.all('/api/*', c => api.native(c).fetch(c.req.raw))
+
+const port = Number(process.env.PORT ?? 3000)
+serve({ fetch: app.fetch, port }, () => {
+  console.log(\`Hono listening on http://localhost:\${port}\`)
+})
+`
+    case 'fastify':
+      return `import Fastify from 'fastify'
+import { createFastifyHandler } from '@taserjs/adapter-fastify'
+
+import { routeManifest } from '#src/routeManifest.gen.js'
+import { t } from '#src/taser.js'
+
+const router = t.create(routeManifest)
+
+const taser = createFastifyHandler(router)
+const app = Fastify()
+taser.mount('/api/*', app)
+
+const port = Number(process.env.PORT ?? 3000)
+await app.listen({ port })
+console.log(\`Fastify listening on http://localhost:\${port}\`)
+`
+    case 'node':
+    default:
+      return `import { createServer } from 'node:http'
+import { createNodeHandler } from '@taserjs/adapter-node'
+
+import { routeManifest } from '#src/routeManifest.gen.js'
+import { t } from '#src/taser.js'
+
+const router = t.create(routeManifest)
+
+const taser = createNodeHandler(router)
+const app = createServer()
+taser.mount('/api/*', app)
+
+const port = Number(process.env.PORT ?? 3000)
+app.listen(port, () => {
+  console.log(\`Node listening on http://localhost:\${port}\`)
+})
+`
+  }
+}
+
+export function taserTsTemplate(framework: Framework = 'node'): string {
+  if (framework === 'hono') {
+    return `import type { Context } from 'hono'
+import { createTaserApp, type InferAppContext } from '@taserjs/router'
+
+import { context } from '#src/context.js'
+
+declare module '@taserjs/router' {
+  interface RouterRegister {
+    NativeContext: Context
+  }
+}
+
+export const t = createTaserApp({
+  response: { validate: true },
+}).context(context)
+
+export type AppContext = InferAppContext<typeof context>
+`
+  }
+
+  return `import { createTaserApp, type InferAppContext } from '@taserjs/router'
+
+import { context } from '#src/context.js'
+
+export const t = createTaserApp({
+  response: { validate: true },
+}).context(context)
+
+export type AppContext = InferAppContext<typeof context>
+`
+}

package/src/scaffold.ts

@@ -0,0 +1,3 @@
+export { scaffoldProject } from './core/scaffold-engine.js'
+export { getPackageGroups, resolvePackages } from './core/resolve-packages.js'
+export type { Framework, ScaffoldOptions, ScaffoldResult, PackageGroups } from './core/types.js'

package/src/templates/base.ts

@@ -0,0 +1,209 @@
+import type { BootBinding } from '../addons/types.js'
+import type { ScaffoldContext } from '../core/types.js'
+
+export function packageJsonTemplate(projectName: string, scripts: Record<string, string> = {}): string {
+  const pkg = {
+    name: projectName,
+    version: '1.0.0',
+    private: true,
+    type: 'module',
+    imports: {
+      '#src/*': './src/*',
+    },
+    scripts: {
+      'dev': 'run-p dev:server dev:taser',
+      'dev:server': 'tsx watch src/index.ts',
+      'dev:taser': 'taser watch',
+      'start': 'tsx src/index.ts',
+      'generate': 'taser generate',
+      'build': 'taser generate && tsdown build',
+      'serve': 'node dist/index.js',
+      'typecheck': 'tsc --noEmit -p tsconfig.json',
+      ...scripts,
+    },
+  }
+
+  return `${JSON.stringify(pkg, null, 2)}\n`
+}
+
+export function tsdownConfigTemplate(): string {
+  return `import { defineConfig } from 'tsdown'
+
+export default defineConfig({
+  entry: ['./src/index.ts'],
+  format: 'esm',
+  platform: 'node',
+  target: 'node20',
+  outDir: 'dist',
+  clean: true,
+  sourcemap: true,
+})
+`
+}
+
+export function tsconfigTemplate(): string {
+  return `${JSON.stringify({
+    compilerOptions: {
+      target: 'ES2022',
+      lib: ['ES2022', 'DOM'],
+      module: 'ESNext',
+      moduleResolution: 'bundler',
+      paths: {
+        '#src/*': ['./src/*'],
+      },
+      strict: true,
+      skipLibCheck: true,
+      verbatimModuleSyntax: true,
+      isolatedModules: true,
+      noEmit: true,
+      types: ['node'],
+    },
+    include: ['src'],
+  }, null, 2)}\n`
+}
+
+export function gitignoreTemplate(): string {
+  return `node_modules
+dist
+.DS_Store
+*.log
+.env
+local.db
+drizzle
+`
+}
+
+export function contextTemplate(bindings: BootBinding[]): string {
+  const imports = bindings.map(
+    binding => `import { ${binding.factoryName} } from '${binding.importPath}'`,
+  )
+
+  const bootBody = bindings.length > 0
+    ? bindings.map(binding => `    ${binding.key}: ${binding.factoryName}(),`).join('\n')
+    : ''
+
+  const bootBlock = bindings.length > 0
+    ? `  boot: () => ({\n${bootBody}\n  }),`
+    : ''
+
+  const importBlock = imports.length > 0 ? `${imports.join('\n')}\n\n` : ''
+
+  return `${importBlock}import { createContext } from '@taserjs/router'
+
+export const context = createContext({
+${bootBlock}
+  request: () => ({
+    requestId: crypto.randomUUID(),
+  }),
+})
+`
+}
+
+export function rootLayoutTemplate(): string {
+  return `import { bodyLimit } from '@taserjs/router/body-limit'
+import { secureHeaders } from '@taserjs/router/secure-headers'
+
+import { t } from '#src/taser.js'
+
+export const Middleware = t.middleware('/$')
+  .use(secureHeaders())
+  .use(bodyLimit({ maxSize: 1_000_000 }))
+`
+}
+
+export function indexRouteTemplate(): string {
+  return `import { t } from '#src/taser.js'
+
+export const Route = t.get('/').handler((ctx) => {
+  return ctx.reply.json({ message: 'Welcome to Taser' })
+})
+`
+}
+
+export function healthRouteTemplate(ctx: ScaffoldContext): string {
+  const lines: string[] = []
+
+  if (ctx.logger) {
+    lines.push('  ctx.logger.info(\'health check\')')
+  }
+
+  if (ctx.db) {
+    lines.push('  // ctx.db is available from context boot')
+  }
+
+  const body = lines.length > 0 ? `${lines.join('\n')}\n` : ''
+
+  return `import { t } from '#src/taser.js'
+
+export const Route = t.get('/health').handler((ctx) => {
+${body}  return ctx.reply.json({ ok: true })
+})
+`
+}
+
+/** Minimal placeholder until `taser generate` runs. */
+export function starterManifestTemplate(): string {
+  return `/* eslint-disable */
+// Run \`pnpm generate\` (taser generate) to replace this file.
+import { Middleware as RootSplatLayoutImport } from './routes/$.js'
+import { Route as RootIndexGetRouteImport } from './routes/index.get.js'
+import { Route as HealthGetRouteImport } from './routes/health.get.js'
+
+export const routeManifest = {
+  layouts: {
+    '/$': {
+      middlewares: RootSplatLayoutImport,
+    },
+  },
+  routes: {
+    '/': {
+      GET: {
+        layoutChain: ['/$'],
+        route: RootIndexGetRouteImport,
+      },
+    },
+    '/health': {
+      GET: {
+        layoutChain: ['/$'],
+        route: HealthGetRouteImport,
+      },
+    },
+  },
+} as const
+
+export type RoutePathGen = '/' | '/health'
+export type LayoutIdGen = '/$'
+export type LayoutTreeGen = {
+  '/$': {
+    parent: null
+    middlewares: typeof RootSplatLayoutImport
+  }
+}
+export type RouteByPathMethodGen = {
+  '/': {
+    GET: {
+      parent: '/$'
+      layoutChain: ['/$']
+      route: typeof RootIndexGetRouteImport
+    }
+  }
+  '/health': {
+    GET: {
+      parent: '/$'
+      layoutChain: ['/$']
+      route: typeof HealthGetRouteImport
+    }
+  }
+}
+export type RouteManifest = typeof routeManifest
+
+declare module '@taserjs/router' {
+  interface RouterRegister {
+    RoutePath: RoutePathGen
+    LayoutId: LayoutIdGen
+    LayoutTree: LayoutTreeGen
+    RouteByPathMethod: RouteByPathMethodGen
+  }
+}
+`
+}

package/src/types.ts

@@ -0,0 +1,9 @@
+export type {
+  Framework,
+  DbOdm,
+  DbDriver,
+  LoggerId,
+  ScaffoldOptions,
+  ScaffoldResult,
+  PackageGroups,
+} from './core/types.js'