create-taserjs 0.0.0

package/src/addons/registry.ts

@@ -0,0 +1,73 @@
+import { drizzleAddon } from './drizzle/index.js'
+import { kyselyAddon } from './kysely/index.js'
+import { pinoAddon } from './pino/index.js'
+import { prismaAddon } from './prisma/index.js'
+import type { AddonDefinition } from './types.js'
+import { winstonAddon } from './winston/index.js'
+import type { CapabilitiesCatalog, ScaffoldContext } from '../core/types.js'
+import {
+  DB_DRIVERS,
+  DB_ODMS,
+  DEFAULT_DB_DRIVER,
+  FRAMEWORKS,
+  LOGGERS,
+} from '../core/types.js'
+
+const ALL_ADDONS: AddonDefinition[] = [
+  drizzleAddon,
+  prismaAddon,
+  kyselyAddon,
+  pinoAddon,
+  winstonAddon,
+]
+
+const DB_ADDONS = ALL_ADDONS.filter(addon => addon.category === 'database')
+const LOGGER_ADDONS = ALL_ADDONS.filter(addon => addon.category === 'logger')
+
+export function getCapabilitiesCatalog(): CapabilitiesCatalog {
+  return {
+    frameworks: [...FRAMEWORKS],
+    db: {
+      odms: [...DB_ODMS],
+      drivers: [...DB_DRIVERS],
+      defaultDriver: DEFAULT_DB_DRIVER,
+    },
+    loggers: [...LOGGERS],
+  }
+}
+
+export function resolveAddons(ctx: ScaffoldContext): AddonDefinition[] {
+  const selected: AddonDefinition[] = []
+
+  if (ctx.db) {
+    const dbAddon = DB_ADDONS.find(addon => addon.id === ctx.db)
+    if (!dbAddon) {
+      throw new Error(`Unknown database addon "${ctx.db}"`)
+    }
+    selected.push(dbAddon)
+  }
+
+  if (ctx.logger) {
+    const loggerAddon = LOGGER_ADDONS.find(addon => addon.id === ctx.logger)
+    if (!loggerAddon) {
+      throw new Error(`Unknown logger addon "${ctx.logger}"`)
+    }
+    selected.push(loggerAddon)
+  }
+
+  const dbCount = selected.filter(addon => addon.category === 'database').length
+  if (dbCount > 1) {
+    throw new Error('Only one database addon can be selected')
+  }
+
+  const loggerCount = selected.filter(addon => addon.category === 'logger').length
+  if (loggerCount > 1) {
+    throw new Error('Only one logger addon can be selected')
+  }
+
+  return selected
+}
+
+export function collectBootBindings(ctx: ScaffoldContext) {
+  return resolveAddons(ctx).map(addon => addon.bootBinding(ctx))
+}

package/src/addons/types.ts

@@ -0,0 +1,19 @@
+import type { ScaffoldContext } from '../core/types.js'
+
+export type BootBinding = {
+  key: string
+  importPath: string
+  factoryName: string
+}
+
+export type FileWriter = (filePath: string, contents: string) => Promise<void>
+
+export type AddonDefinition = {
+  id: string
+  category: 'database' | 'logger'
+  dependencies: (ctx: ScaffoldContext) => string[]
+  devDependencies: (ctx: ScaffoldContext) => string[]
+  scripts?: (ctx: ScaffoldContext) => Record<string, string>
+  bootBinding: (ctx: ScaffoldContext) => BootBinding
+  apply: (ctx: ScaffoldContext, write: FileWriter) => Promise<void>
+}

package/src/addons/winston/index.ts

@@ -0,0 +1,34 @@
+import type { AddonDefinition } from '../types.js'
+
+export const winstonAddon: AddonDefinition = {
+  id: 'winston',
+  category: 'logger',
+  dependencies() {
+    return ['winston']
+  },
+  devDependencies() {
+    return []
+  },
+  bootBinding() {
+    return {
+      key: 'logger',
+      importPath: './logger.js',
+      factoryName: 'createLogger',
+    }
+  },
+  async apply(_ctx, write) {
+    await write(
+      'src/logger.ts',
+      `import winston from 'winston'
+
+export function createLogger() {
+  return winston.createLogger({
+    level: process.env.LOG_LEVEL ?? 'info',
+    format: winston.format.json(),
+    transports: [new winston.transports.Console()],
+  })
+}
+`,
+    )
+  },
+}

package/src/cli.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util'
+
+import * as p from '@clack/prompts'
+import color from 'picocolors'
+
+import { buildParsedArgsFromCli, runCreateCommand } from './commands/create.js'
+import { printJsonError } from './core/json-output.js'
+
+async function main(): Promise<void> {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      framework: { type: 'string' },
+      db: { type: 'string' },
+      logger: { type: 'string' },
+      y: { type: 'boolean', short: 'y' },
+      noInstall: { type: 'boolean' },
+      json: { type: 'boolean' },
+    },
+    allowPositionals: true,
+  })
+
+  const parsed = buildParsedArgsFromCli(
+    {
+      ...(values.framework !== undefined ? { framework: values.framework } : {}),
+      ...(values.db !== undefined ? { db: values.db } : {}),
+      ...(values.logger !== undefined ? { logger: values.logger } : {}),
+      ...(values.y !== undefined ? { y: values.y } : {}),
+      ...(values.noInstall !== undefined ? { noInstall: values.noInstall } : {}),
+      ...(values.json !== undefined ? { json: values.json } : {}),
+    },
+    positionals,
+  )
+
+  if (!parsed.json) {
+    console.clear()
+    p.intro(color.bgCyan(color.black(' create-taser ')))
+  }
+
+  try {
+    await runCreateCommand(parsed)
+  }
+  catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    if (parsed.json) {
+      printJsonError(message)
+      process.exit(1)
+    }
+    throw error
+  }
+}
+
+main().catch((error: unknown) => {
+  console.error(error)
+  process.exit(1)
+})

package/src/commands/create.ts

@@ -0,0 +1,253 @@
+import path from 'node:path'
+
+import * as p from '@clack/prompts'
+import color from 'picocolors'
+
+import { getCapabilitiesCatalog } from '../addons/registry.js'
+import { printCapabilitiesCatalog, printJsonError, printScaffoldResult } from '../core/json-output.js'
+import {
+  parseDbFlag,
+  parseFrameworkFlag,
+  parseLoggerFlag,
+  type ParsedCreateArgs,
+  resolveScaffoldDefaults,
+} from '../core/parse-options.js'
+import { scaffoldProject } from '../core/scaffold-engine.js'
+import type { DbDriver, DbOdm, Framework, LoggerId, ScaffoldResult } from '../core/types.js'
+import { DB_DRIVERS, DB_ODMS, FRAMEWORKS, LOGGERS } from '../core/types.js'
+import { validateProjectName } from '../core/validate-project-name.js'
+import { resolveUserAgent, runScript } from '../core/package-manager.js'
+
+function isFramework(value: unknown): value is Framework {
+  return typeof value === 'string' && (FRAMEWORKS as readonly string[]).includes(value)
+}
+
+function isDbOdm(value: unknown): value is DbOdm {
+  return typeof value === 'string' && (DB_ODMS as readonly string[]).includes(value)
+}
+
+function isDbDriver(value: unknown): value is DbDriver {
+  return typeof value === 'string' && (DB_DRIVERS as readonly string[]).includes(value)
+}
+
+function isLoggerId(value: unknown): value is LoggerId {
+  return typeof value === 'string' && (LOGGERS as readonly string[]).includes(value)
+}
+
+async function promptInteractiveOptions(
+  args: ParsedCreateArgs,
+): Promise<ParsedCreateArgs> {
+  const projectName = args.projectName
+    ?? await p.text({
+      message: 'Project name',
+      placeholder: 'my-taser-app',
+      defaultValue: 'my-taser-app',
+      validate(value) {
+        return validateProjectName(value)
+      },
+    })
+
+  if (p.isCancel(projectName)) {
+    p.cancel('Scaffold cancelled.')
+    process.exit(0)
+  }
+
+  const framework = args.framework
+    ?? await p.select({
+      message: 'Framework adapter',
+      options: [
+        { value: 'node', label: 'Plain Node.js', hint: 'default' },
+        { value: 'express', label: 'Express' },
+        { value: 'hono', label: 'Hono' },
+        { value: 'fastify', label: 'Fastify' },
+      ],
+      initialValue: 'node',
+    })
+
+  if (p.isCancel(framework) || !isFramework(framework)) {
+    p.cancel('Scaffold cancelled.')
+    process.exit(0)
+  }
+
+  const dbChoice = args.db
+    ?? await p.select({
+      message: 'Database',
+      options: [
+        { value: 'none', label: 'None', hint: 'default' },
+        { value: 'drizzle', label: 'Drizzle' },
+        { value: 'prisma', label: 'Prisma' },
+        { value: 'kysely', label: 'Kysely' },
+      ],
+      initialValue: 'none',
+    })
+
+  if (p.isCancel(dbChoice)) {
+    p.cancel('Scaffold cancelled.')
+    process.exit(0)
+  }
+
+  let db: DbOdm | undefined
+  let driver: DbDriver | undefined
+
+  if (dbChoice !== 'none' && isDbOdm(dbChoice)) {
+    db = dbChoice
+    const driverChoice = args.driver
+      ?? await p.select({
+        message: 'Database driver',
+        options: [
+          { value: 'sqlite', label: 'SQLite', hint: 'default' },
+          { value: 'postgres', label: 'PostgreSQL' },
+          { value: 'mysql', label: 'MySQL' },
+        ],
+        initialValue: 'sqlite',
+      })
+
+    if (p.isCancel(driverChoice) || !isDbDriver(driverChoice)) {
+      p.cancel('Scaffold cancelled.')
+      process.exit(0)
+    }
+    driver = driverChoice
+  }
+
+  const loggerChoice = args.logger
+    ?? await p.select({
+      message: 'Logger',
+      options: [
+        { value: 'none', label: 'None', hint: 'default' },
+        { value: 'pino', label: 'Pino' },
+        { value: 'winston', label: 'Winston' },
+      ],
+      initialValue: 'none',
+    })
+
+  if (p.isCancel(loggerChoice)) {
+    p.cancel('Scaffold cancelled.')
+    process.exit(0)
+  }
+
+  const logger = loggerChoice === 'none' ? undefined : isLoggerId(loggerChoice) ? loggerChoice : undefined
+
+  return {
+    projectName: String(projectName).trim(),
+    framework,
+    yes: args.yes,
+    noInstall: args.noInstall,
+    json: args.json,
+    ...(db ? { db, driver: driver! } : {}),
+    ...(logger ? { logger } : {}),
+  }
+}
+
+export async function runCreateCommand(args: ParsedCreateArgs): Promise<ScaffoldResult | undefined> {
+  if (args.json && !args.projectName) {
+    printCapabilitiesCatalog(getCapabilitiesCatalog())
+    return undefined
+  }
+
+  const cwd = process.cwd()
+  const interactive = !args.yes
+  const resolved = interactive
+    ? await promptInteractiveOptions(args)
+    : {
+        ...args,
+        projectName: args.projectName?.trim(),
+        framework: args.framework ?? 'node',
+      }
+
+  if (!resolved.projectName) {
+    const message = 'Project name is required'
+    if (args.json) {
+      printJsonError(message)
+      process.exit(1)
+    }
+    throw new Error(message)
+  }
+
+  const nameError = validateProjectName(resolved.projectName, cwd)
+  if (nameError) {
+    if (args.json) {
+      printJsonError(nameError)
+      process.exit(1)
+    }
+    throw new Error(nameError)
+  }
+
+  const targetDir = path.resolve(cwd, resolved.projectName)
+  const scaffoldCtx = resolveScaffoldDefaults({
+    ...resolved,
+    projectName: resolved.projectName,
+  })
+  scaffoldCtx.targetDir = targetDir
+
+  if (!args.json) {
+    const spinner = p.spinner()
+    spinner.start('Scaffolding project')
+    try {
+      const result = await scaffoldProject({
+        ...scaffoldCtx,
+        targetDir,
+        skipInstall: args.noInstall,
+        agent: resolveUserAgent(),
+      })
+      spinner.stop('Project created')
+      const cdPath = path.relative(cwd, targetDir) || '.'
+      p.note(
+        [
+          `cd ${cdPath}`,
+          runScript(resolveUserAgent(), 'dev'),
+        ].join('\n'),
+        'Next steps',
+      )
+      p.outro(color.green('Done.'))
+      return result
+    }
+    catch (error) {
+      spinner.stop('Scaffold failed')
+      throw error
+    }
+  }
+
+  const result = await scaffoldProject({
+    ...scaffoldCtx,
+    targetDir,
+    skipInstall: args.noInstall,
+    agent: resolveUserAgent(),
+  })
+  printScaffoldResult(result)
+  return result
+}
+
+export function buildParsedArgsFromCli(values: {
+  framework?: string
+  db?: string
+  logger?: string
+  y?: boolean
+  noInstall?: boolean
+  json?: boolean
+}, positionals: string[]): ParsedCreateArgs {
+  const args: ParsedCreateArgs = {
+    yes: values.y ?? false,
+    noInstall: values.noInstall ?? false,
+    json: values.json ?? false,
+  }
+
+  if (positionals[0]) {
+    args.projectName = positionals[0]
+  }
+
+  if (values.framework) {
+    args.framework = parseFrameworkFlag(values.framework)
+  }
+
+  if (values.db) {
+    const parsed = parseDbFlag(values.db)
+    args.db = parsed.db
+    args.driver = parsed.driver
+  }
+
+  if (values.logger) {
+    args.logger = parseLoggerFlag(values.logger)
+  }
+
+  return args
+}

package/src/core/json-output.ts

@@ -0,0 +1,13 @@
+import type { CapabilitiesCatalog, ScaffoldResult } from './types.js'
+
+export function printCapabilitiesCatalog(catalog: CapabilitiesCatalog): void {
+  console.log(JSON.stringify(catalog, null, 2))
+}
+
+export function printScaffoldResult(result: ScaffoldResult): void {
+  console.log(JSON.stringify(result, null, 2))
+}
+
+export function printJsonError(message: string): void {
+  console.error(JSON.stringify({ error: message }))
+}

package/src/core/package-manager.ts

@@ -0,0 +1,68 @@
+import { spawn } from 'node:child_process'
+
+import type { Agent, ResolvedCommand } from 'package-manager-detector'
+import { resolveCommand } from 'package-manager-detector/commands'
+import { getUserAgent } from 'package-manager-detector/detect'
+
+export function resolveUserAgent(): Agent {
+  return getUserAgent() || 'npm'
+}
+
+function runCommand(command: string, args: string[], cwd: string): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: 'inherit',
+      shell: false,
+      env: process.env,
+    })
+    child.on('error', reject)
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve()
+        return
+      }
+      reject(new Error(`${command} ${args.join(' ')} exited with code ${code}`))
+    })
+  })
+}
+
+const fallback = {
+  agent: 'npm',
+  install: (packages: string[], dev: boolean) => {
+    return ['install', ...packages, dev ? '-D' : '']
+  },
+}
+
+function resolveInstallCommand(agent: Agent, packages: string[], dev: boolean): ResolvedCommand {
+  const command = resolveCommand(agent, 'install', packages)
+  if (command) return command
+
+  return { command: fallback.agent, args: fallback.install(packages, dev) }
+}
+
+export async function installPackages(
+  agent: Agent,
+  cwd: string,
+  { dependencies, devDependencies }: {
+    dependencies: string[]
+    devDependencies: string[]
+  },
+): Promise<void> {
+  if (dependencies.length > 0) {
+    const { command, args } = resolveInstallCommand(agent, dependencies, false)
+    await runCommand(command, args, cwd)
+  }
+  if (devDependencies.length > 0) {
+    const { command, args } = resolveInstallCommand(agent, devDependencies, true)
+    await runCommand(command, args, cwd)
+  }
+}
+
+export function runScript(agent: Agent, script: string): string {
+  const resolved = resolveCommand(agent, 'run', [script])
+  if (!resolved) {
+    throw new Error(`Unable to resolve run command for ${agent}`)
+  }
+  return `${resolved.command} ${resolved.args.join(' ')}`
+}

package/src/core/parse-options.ts

@@ -0,0 +1,97 @@
+import {
+  DB_DRIVERS,
+  DB_ODMS,
+  DEFAULT_DB_DRIVER,
+  FRAMEWORKS,
+  LOGGERS,
+  type DbDriver,
+  type DbOdm,
+  type Framework,
+  type LoggerId,
+  type ScaffoldContext,
+} from './types.js'
+
+export type ParsedCreateArgs = {
+  projectName?: string
+  framework?: Framework
+  db?: DbOdm
+  driver?: DbDriver
+  logger?: LoggerId
+  yes: boolean
+  noInstall: boolean
+  json: boolean
+}
+
+function isFramework(value: string): value is Framework {
+  return (FRAMEWORKS as readonly string[]).includes(value)
+}
+
+function isDbOdm(value: string): value is DbOdm {
+  return (DB_ODMS as readonly string[]).includes(value)
+}
+
+function isDbDriver(value: string): value is DbDriver {
+  return (DB_DRIVERS as readonly string[]).includes(value)
+}
+
+function isLoggerId(value: string): value is LoggerId {
+  return (LOGGERS as readonly string[]).includes(value)
+}
+
+export function parseDbFlag(value: string): { db: DbOdm, driver: DbDriver } {
+  const [odm, driver] = value.split(':')
+  if (!odm || !isDbOdm(odm)) {
+    throw new Error(`Invalid --db value "${value}". Use drizzle, prisma, or kysely (optionally with :postgres, :sqlite, or :mysql).`)
+  }
+
+  if (driver === undefined || driver === '') {
+    return { db: odm, driver: DEFAULT_DB_DRIVER }
+  }
+
+  if (!isDbDriver(driver)) {
+    throw new Error(`Invalid database driver "${driver}". Use postgres, sqlite, or mysql.`)
+  }
+
+  return { db: odm, driver }
+}
+
+export function resolveScaffoldDefaults(args: ParsedCreateArgs): ScaffoldContext {
+  const framework = args.framework ?? 'node'
+  const db = args.db
+  const logger = args.logger
+
+  if (!args.projectName) {
+    throw new Error('Project name is required')
+  }
+
+  const result: ScaffoldContext = {
+    projectName: args.projectName.trim(),
+    targetDir: '',
+    framework,
+  }
+
+  if (db) {
+    result.db = db
+    result.driver = args.driver ?? DEFAULT_DB_DRIVER
+  }
+
+  if (logger) {
+    result.logger = logger
+  }
+
+  return result
+}
+
+export function parseFrameworkFlag(value: string): Framework {
+  if (!isFramework(value)) {
+    throw new Error(`Invalid --framework "${value}". Use node, express, hono, or fastify.`)
+  }
+  return value
+}
+
+export function parseLoggerFlag(value: string): LoggerId {
+  if (!isLoggerId(value)) {
+    throw new Error(`Invalid --logger "${value}". Use pino or winston.`)
+  }
+  return value
+}

package/src/core/project-config.ts

@@ -0,0 +1,27 @@
+import { writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+import type { ScaffoldContext } from './types.js'
+
+export async function writeProjectConfig(root: string, ctx: ScaffoldContext): Promise<void> {
+  const config: Record<string, string> = {
+    framework: ctx.framework,
+  }
+
+  if (ctx.db) {
+    config.db = ctx.db
+    if (ctx.driver) {
+      config.driver = ctx.driver
+    }
+  }
+
+  if (ctx.logger) {
+    config.logger = ctx.logger
+  }
+
+  await writeFile(
+    path.join(root, '.taser.json'),
+    `${JSON.stringify(config, null, 2)}\n`,
+    'utf8',
+  )
+}

package/src/core/resolve-packages.ts

@@ -0,0 +1,62 @@
+import { resolveAddons } from '../addons/registry.js'
+import type { PackageGroups, ScaffoldContext, Framework } from '../core/types.js'
+
+function frameworkPackages(framework: Framework): PackageGroups {
+  const dependencies = ['@taserjs/router']
+  const devDependencies = [
+    '@taserjs/router-cli',
+    'npm-run-all2',
+    'tsdown',
+    'tsx',
+    'typescript',
+  ]
+  const scripts: Record<string, string> = {}
+
+  switch (framework) {
+    case 'express':
+      dependencies.push('@taserjs/adapter-express', 'express')
+      devDependencies.push('@types/express')
+      break
+    case 'hono':
+      dependencies.push('@hono/node-server', 'hono')
+      break
+    case 'fastify':
+      dependencies.push('@taserjs/adapter-fastify', 'fastify')
+      break
+    case 'node':
+    default:
+      dependencies.push('@taserjs/adapter-node')
+      break
+  }
+
+  return { dependencies, devDependencies, scripts }
+}
+
+export function resolvePackages(ctx: ScaffoldContext): PackageGroups {
+  const base = frameworkPackages(ctx.framework)
+  const addons = resolveAddons(ctx)
+
+  const dependencies = [...base.dependencies]
+  const devDependencies = [...base.devDependencies]
+  const scripts = { ...base.scripts }
+
+  for (const addon of addons) {
+    dependencies.push(...addon.dependencies(ctx))
+    devDependencies.push(...addon.devDependencies(ctx))
+    if (addon.scripts) {
+      Object.assign(scripts, addon.scripts(ctx))
+    }
+  }
+
+  return {
+    dependencies: [...new Set(dependencies)],
+    devDependencies: [...new Set(devDependencies)],
+    scripts,
+  }
+}
+
+// Backward-compatible export for tests during migration
+export function getPackageGroups(framework: Framework): Omit<PackageGroups, 'scripts'> & { scripts?: Record<string, string> } {
+  const groups = frameworkPackages(framework)
+  return groups
+}