@stravigor/create 0.1.0

package/README.md

@@ -0,0 +1,42 @@
+# @stravigor/create
+
+Scaffold a new [Strav](https://www.npmjs.com/package/@stravigor/core) application.
+
+## Usage
+
+```bash
+bunx @stravigor/create my-app
+```
+
+## Templates
+
+- **api** — Headless REST API with CORS enabled
+- **web** — Full-stack with `.strav` views, sessions, and static files
+
+## Options
+
+```
+bunx @stravigor/create <project-name> [options]
+
+--template, -t api|web    Template to use (default: prompt)
+--db <name>               Database name (default: project name)
+-h, --help                Show help
+```
+
+## What's scaffolded
+
+```
+my-app/
+├── index.ts              Server entry point
+├── strav.ts              CLI (migrations, generators)
+├── config/               Configuration files
+├── database/schemas/     Schema definitions
+├── start/routes.ts       Route registration
+├── tests/                Test files
+├── .env                  Environment variables
+└── package.json
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@stravigor/create",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Scaffold a new Strav application",
+  "license": "MIT",
+  "keywords": ["strav", "stravigor", "bun", "framework", "scaffold", "create"],
+  "bin": {
+    "@stravigor/create": "./src/index.ts"
+  },
+  "files": ["src/", "package.json", "README.md"]
+}

package/src/index.ts

@@ -0,0 +1,156 @@
+#!/usr/bin/env bun
+import { existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { select, input } from './prompts.ts'
+import { scaffold } from './scaffold.ts'
+import type { ScaffoldOptions } from './templates/shared.ts'
+
+const VERSION = '0.1.0'
+
+// ── Colors ──────────────────────────────────────────────────────────
+
+const bold = (s: string) => `\x1b[1m${s}\x1b[0m`
+const dim = (s: string) => `\x1b[2m${s}\x1b[0m`
+const green = (s: string) => `\x1b[32m${s}\x1b[0m`
+const cyan = (s: string) => `\x1b[36m${s}\x1b[0m`
+const red = (s: string) => `\x1b[31m${s}\x1b[0m`
+
+// ── Arg parsing ─────────────────────────────────────────────────────
+
+interface ParsedArgs {
+  projectName?: string
+  template?: 'api' | 'web'
+  db?: string
+  help?: boolean
+}
+
+function parseArgs(): ParsedArgs {
+  const args = process.argv.slice(2)
+  const result: ParsedArgs = {}
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+
+    if (arg === '--help' || arg === '-h') {
+      result.help = true
+    } else if (arg === '--template' || arg === '-t') {
+      const val = args[++i]
+      if (val === 'api' || val === 'web') {
+        result.template = val
+      } else {
+        console.error(red(`  Invalid template: ${val}. Use "api" or "web".`))
+        process.exit(1)
+      }
+    } else if (arg === '--db') {
+      result.db = args[++i]
+    } else if (!arg.startsWith('-') && !result.projectName) {
+      result.projectName = arg
+    }
+  }
+
+  return result
+}
+
+function printUsage(): void {
+  console.log(`
+  ${bold('@stravigor/create')} ${dim(`v${VERSION}`)}
+
+  ${bold('Usage:')}
+    bunx @stravigor/create ${cyan('<project-name>')} [options]
+
+  ${bold('Options:')}
+    --template, -t ${dim('api|web')}    Template to use (default: prompt)
+    --db ${dim('<name>')}               Database name (default: project name)
+    -h, --help                Show this help message
+  `)
+}
+
+function toSnakeCase(name: string): string {
+  return name.replace(/-/g, '_')
+}
+
+// ── Main ────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  const args = parseArgs()
+
+  if (args.help) {
+    printUsage()
+    process.exit(0)
+  }
+
+  console.log()
+  console.log(`  ${bold('@stravigor/create')} ${dim(`v${VERSION}`)}`)
+  console.log()
+
+  // Project name
+  if (!args.projectName) {
+    printUsage()
+    process.exit(1)
+  }
+
+  const projectName = args.projectName
+  const root = resolve(projectName)
+
+  // Validate
+  if (existsSync(root)) {
+    console.error(red(`  Directory "${projectName}" already exists.`))
+    process.exit(1)
+  }
+
+  if (!/^[a-zA-Z0-9_-]+$/.test(projectName)) {
+    console.error(red(`  Invalid project name. Use only letters, numbers, hyphens, and underscores.`))
+    process.exit(1)
+  }
+
+  // Template
+  let template = args.template
+  if (!template) {
+    template = await select('Which template?', [
+      { label: 'api', value: 'api', description: 'Headless REST API' },
+      { label: 'web', value: 'web', description: 'Full-stack with views and static files' },
+    ]) as 'api' | 'web'
+  }
+
+  // Database name
+  const defaultDb = toSnakeCase(projectName)
+  const dbName = args.db ?? await input('Database name:', defaultDb)
+
+  console.log()
+
+  // Scaffold
+  const opts: ScaffoldOptions = { projectName, template, dbName }
+  await scaffold(root, opts)
+  console.log(`  ${green('+')} Scaffolded project files`)
+
+  // Install dependencies
+  console.log(`  ${dim('...')} Installing dependencies`)
+  const install = Bun.spawn(['bun', 'install'], { cwd: root, stdout: 'ignore', stderr: 'pipe' })
+  const exitCode = await install.exited
+
+  if (exitCode !== 0) {
+    const stderr = await new Response(install.stderr).text()
+    console.error(red(`  Failed to install dependencies:`))
+    console.error(dim(`  ${stderr}`))
+    process.exit(1)
+  }
+
+  console.log(`  ${green('+')} Installed dependencies`)
+
+  // Done
+  console.log()
+  console.log(`  ${green('Project created successfully!')}`)
+  console.log()
+  console.log(`  Next steps:`)
+  console.log()
+  console.log(`    ${dim('$')} cd ${projectName}`)
+  console.log(`    ${dim('$')} bun --hot index.ts`)
+  console.log()
+  console.log(`  ${dim('Then open http://localhost:3000')}`)
+  console.log()
+}
+
+main().catch((err) => {
+  console.error(red(`  Error: ${err instanceof Error ? err.message : err}`))
+  process.exit(1)
+})

package/src/prompts.ts

@@ -0,0 +1,134 @@
+const ESC = '\x1b'
+const ARROW_UP = `${ESC}[A`
+const ARROW_DOWN = `${ESC}[B`
+const ENTER = '\r'
+
+interface Choice {
+  label: string
+  value: string
+  description: string
+}
+
+export async function select(message: string, choices: Choice[]): Promise<string> {
+  let selected = 0
+
+  const render = () => {
+    // Move cursor up to overwrite previous render (except first time)
+    process.stdout.write(`\x1b[${choices.length}A`)
+    for (let i = 0; i < choices.length; i++) {
+      const prefix = i === selected ? '\x1b[36m>\x1b[0m' : ' '
+      const label = i === selected ? `\x1b[1m${choices[i].label}\x1b[0m` : choices[i].label
+      const desc = `\x1b[2m${choices[i].description}\x1b[0m`
+      process.stdout.write(`\x1b[2K  ${prefix} ${label}  ${desc}\n`)
+    }
+  }
+
+  process.stdout.write(`  \x1b[1m${message}\x1b[0m\n`)
+  // Print initial lines so render() can overwrite them
+  for (const choice of choices) {
+    process.stdout.write('\n')
+  }
+  render()
+
+  return new Promise((resolve) => {
+    const stdin = process.stdin
+    stdin.setRawMode(true)
+    stdin.resume()
+    stdin.setEncoding('utf8')
+
+    let buffer = ''
+
+    const onData = (data: string) => {
+      buffer += data
+
+      // Check for Ctrl+C
+      if (buffer.includes('\x03')) {
+        stdin.setRawMode(false)
+        stdin.pause()
+        stdin.removeListener('data', onData)
+        process.stdout.write('\n')
+        process.exit(0)
+      }
+
+      // Process escape sequences
+      while (buffer.length > 0) {
+        if (buffer.startsWith(ARROW_UP)) {
+          selected = (selected - 1 + choices.length) % choices.length
+          render()
+          buffer = buffer.slice(ARROW_UP.length)
+        } else if (buffer.startsWith(ARROW_DOWN)) {
+          selected = (selected + 1) % choices.length
+          render()
+          buffer = buffer.slice(ARROW_DOWN.length)
+        } else if (buffer.startsWith(ENTER)) {
+          stdin.setRawMode(false)
+          stdin.pause()
+          stdin.removeListener('data', onData)
+          resolve(choices[selected].value)
+          buffer = ''
+          return
+        } else if (buffer.startsWith(ESC)) {
+          // Incomplete escape sequence, wait for more data
+          break
+        } else {
+          // Discard unrecognized input
+          buffer = buffer.slice(1)
+        }
+      }
+    }
+
+    stdin.on('data', onData)
+  })
+}
+
+export async function input(message: string, defaultValue: string): Promise<string> {
+  process.stdout.write(`  \x1b[1m${message}\x1b[0m \x1b[2m(${defaultValue})\x1b[0m `)
+
+  return new Promise((resolve) => {
+    const stdin = process.stdin
+    stdin.setRawMode(true)
+    stdin.resume()
+    stdin.setEncoding('utf8')
+
+    let value = ''
+
+    const onData = (data: string) => {
+      for (const char of data) {
+        if (char === '\x03') {
+          // Ctrl+C
+          stdin.setRawMode(false)
+          stdin.pause()
+          stdin.removeListener('data', onData)
+          process.stdout.write('\n')
+          process.exit(0)
+        }
+
+        if (char === '\r' || char === '\n') {
+          stdin.setRawMode(false)
+          stdin.pause()
+          stdin.removeListener('data', onData)
+          process.stdout.write('\n')
+          resolve(value || defaultValue)
+          return
+        }
+
+        if (char === '\x7f' || char === '\b') {
+          // Backspace
+          if (value.length > 0) {
+            value = value.slice(0, -1)
+            process.stdout.write('\b \b')
+          }
+          continue
+        }
+
+        // Printable characters
+        if (char >= ' ') {
+          value += char
+          process.stdout.write(char)
+        }
+      }
+    }
+
+    stdin.on('data', onData)
+  })
+}

package/src/scaffold.ts

@@ -0,0 +1,20 @@
+import { mkdirSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { getSharedFiles, type ScaffoldOptions } from './templates/shared.ts'
+import { getApiFiles } from './templates/api.ts'
+import { getWebFiles } from './templates/web.ts'
+
+export async function scaffold(root: string, opts: ScaffoldOptions): Promise<void> {
+  // Collect all files
+  const files = [
+    ...getSharedFiles(opts),
+    ...(opts.template === 'web' ? getWebFiles(opts) : getApiFiles(opts)),
+  ]
+
+  // Create directories and write files
+  for (const file of files) {
+    const fullPath = join(root, file.path)
+    mkdirSync(dirname(fullPath), { recursive: true })
+    await Bun.write(fullPath, file.content)
+  }
+}

package/src/templates/api.ts

@@ -0,0 +1,80 @@
+import type { TemplateFile, ScaffoldOptions } from './shared.ts'
+
+export function getApiFiles(opts: ScaffoldOptions): TemplateFile[] {
+  return [
+    { path: 'index.ts', content: indexTs(opts) },
+    { path: 'config/http.ts', content: configHttp() },
+    { path: 'start/routes.ts', content: routes(opts) },
+  ]
+}
+
+function indexTs(opts: ScaffoldOptions): string {
+  return `import 'reflect-metadata'
+import { app } from '@stravigor/core/core'
+import Configuration from '@stravigor/core/config/configuration'
+import Database from '@stravigor/core/database/database'
+import BaseModel from '@stravigor/core/orm/base_model'
+import Router from '@stravigor/core/http/router'
+import Server from '@stravigor/core/http/server'
+import { ExceptionHandler } from '@stravigor/core/exceptions'
+import EncryptionManager from '@stravigor/core/encryption/encryption_manager'
+
+async function boot() {
+  const config = new Configuration('./config')
+  await config.load()
+  app.singleton(Configuration, () => config)
+
+  app.singleton(Database)
+  const db = app.resolve(Database)
+  new BaseModel(db)
+
+  app.singleton(EncryptionManager)
+  app.resolve(EncryptionManager)
+
+  app.singleton(Router)
+  const router = app.resolve(Router)
+
+  const handler = new ExceptionHandler(config.get('app.env') === 'local')
+  router.useExceptionHandler(handler)
+  router.cors()
+
+  await import('./start/routes')
+
+  app.singleton(Server)
+  const server = app.resolve(Server)
+  server.start(router)
+}
+
+boot().catch((err) => {
+  console.error('Failed to boot:', err)
+  process.exit(1)
+})
+`
+}
+
+function configHttp(): string {
+  return `import { env } from '@stravigor/core/helpers/env'
+
+export default {
+  host: env('HOST', '0.0.0.0'),
+  port: env.int('PORT', 3000),
+  domain: env('DOMAIN', 'localhost'),
+}
+`
+}
+
+function routes(opts: ScaffoldOptions): string {
+  return `import { router } from '@stravigor/core/http'
+
+router.get('/', () => {
+  return Response.json({
+    name: '${opts.projectName}',
+    status: 'running',
+  })
+})
+
+router.get('/health', () => {
+  return Response.json({ status: 'ok' })
+})
+`
+}

package/src/templates/shared.ts

@@ -0,0 +1,152 @@
+export interface TemplateFile {
+  path: string
+  content: string
+}
+
+export interface ScaffoldOptions {
+  projectName: string
+  template: 'api' | 'web'
+  dbName: string
+}
+
+export function getSharedFiles(opts: ScaffoldOptions): TemplateFile[] {
+  const appKey = crypto.randomUUID()
+
+  return [
+    { path: 'package.json', content: packageJson(opts) },
+    { path: 'tsconfig.json', content: tsconfig() },
+    { path: '.env', content: dotEnv(opts, appKey) },
+    { path: '.gitignore', content: gitignore() },
+    { path: 'strav.ts', content: stravTs() },
+    { path: 'config/app.ts', content: configApp() },
+    { path: 'config/database.ts', content: configDatabase(opts) },
+    { path: 'config/encryption.ts', content: configEncryption() },
+    { path: 'database/schemas/.gitkeep', content: '' },
+    { path: 'tests/health.test.ts', content: healthTest(opts) },
+  ]
+}
+
+function packageJson(opts: ScaffoldOptions): string {
+  return JSON.stringify({
+    name: opts.projectName,
+    version: '0.0.1',
+    type: 'module',
+    private: true,
+    scripts: {
+      dev: 'bun --hot index.ts',
+      start: 'bun index.ts',
+      test: 'bun test tests/',
+    },
+    dependencies: {
+      '@stravigor/core': '^0.1.0',
+      'luxon': '^3.7.2',
+      'reflect-metadata': '^0.2.2',
+    },
+    devDependencies: {
+      '@types/bun': 'latest',
+      '@types/luxon': '^3.7.1',
+      '@stravigor/testing': '^0.1.0',
+    },
+  }, null, 2) + '\n'
+}
+
+function tsconfig(): string {
+  return JSON.stringify({
+    compilerOptions: {
+      lib: ['ESNext'],
+      target: 'ESNext',
+      module: 'ESNext',
+      moduleDetection: 'force',
+      allowJs: true,
+      moduleResolution: 'bundler',
+      allowImportingTsExtensions: true,
+      noEmit: true,
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true,
+      strict: true,
+      skipLibCheck: true,
+      noFallthroughCasesInSwitch: true,
+      noUnusedLocals: false,
+      noUnusedParameters: false,
+    },
+    include: ['**/*.ts'],
+  }, null, 2) + '\n'
+}
+
+function dotEnv(opts: ScaffoldOptions, appKey: string): string {
+  return `APP_ENV=local
+APP_DEBUG=true
+APP_KEY=${appKey}
+
+HOST=0.0.0.0
+PORT=3000
+DOMAIN=localhost
+
+DB_HOST=127.0.0.1
+DB_PORT=5432
+DB_USERNAME=postgres
+DB_PASSWORD=
+DB_DATABASE=${opts.dbName}
+`
+}
+
+function gitignore(): string {
+  return `node_modules/
+.env
+app/
+database/migrations/
+*.log
+`
+}
+
+function stravTs(): string {
+  return `#!/usr/bin/env bun
+import '@stravigor/core/cli/strav'
+`
+}
+
+function configApp(): string {
+  return `import { env } from '@stravigor/core/helpers/env'
+
+export default {
+  env: env('APP_ENV', 'local'),
+  debug: env.bool('APP_DEBUG', true),
+  key: env('APP_KEY'),
+}
+`
+}
+
+function configDatabase(opts: ScaffoldOptions): string {
+  return `import { env } from '@stravigor/core/helpers/env'
+
+export default {
+  host: env('DB_HOST', '127.0.0.1'),
+  port: env.int('DB_PORT', 5432),
+  username: env('DB_USERNAME', 'postgres'),
+  password: env('DB_PASSWORD', ''),
+  database: env('DB_DATABASE', '${opts.dbName}'),
+}
+`
+}
+
+function configEncryption(): string {
+  return `import { env } from '@stravigor/core/helpers/env'
+
+export default {
+  key: env('APP_KEY'),
+  previousKeys: [],
+}
+`
+}
+
+function healthTest(opts: ScaffoldOptions): string {
+  const path = opts.template === 'web' ? '/api/health' : '/health'
+  return `import { test, expect } from 'bun:test'
+
+test('health check returns ok', async () => {
+  const res = await fetch('http://localhost:3000${path}')
+  const json = await res.json()
+  expect(json.status).toBe('ok')
+})
+`
+}

package/src/templates/web.ts

@@ -0,0 +1,191 @@
+import type { TemplateFile, ScaffoldOptions } from './shared.ts'
+
+export function getWebFiles(opts: ScaffoldOptions): TemplateFile[] {
+  return [
+    { path: 'index.ts', content: indexTs(opts) },
+    { path: 'config/http.ts', content: configHttp() },
+    { path: 'config/session.ts', content: configSession() },
+    { path: 'config/view.ts', content: configView() },
+    { path: 'start/routes.ts', content: routes(opts) },
+    { path: 'views/welcome.strav', content: welcomeView() },
+    { path: 'public/styles.css', content: stylesCss() },
+  ]
+}
+
+function indexTs(opts: ScaffoldOptions): string {
+  return `import 'reflect-metadata'
+import { app } from '@stravigor/core/core'
+import Configuration from '@stravigor/core/config/configuration'
+import Database from '@stravigor/core/database/database'
+import BaseModel from '@stravigor/core/orm/base_model'
+import Router from '@stravigor/core/http/router'
+import Server from '@stravigor/core/http/server'
+import { ExceptionHandler } from '@stravigor/core/exceptions'
+import EncryptionManager from '@stravigor/core/encryption/encryption_manager'
+import SessionManager from '@stravigor/core/session/session_manager'
+import { ViewEngine } from '@stravigor/core/view'
+
+async function boot() {
+  const config = new Configuration('./config')
+  await config.load()
+  app.singleton(Configuration, () => config)
+
+  app.singleton(Database)
+  const db = app.resolve(Database)
+  new BaseModel(db)
+
+  app.singleton(EncryptionManager)
+  app.resolve(EncryptionManager)
+
+  app.singleton(SessionManager)
+  app.resolve(SessionManager)
+
+  app.singleton(ViewEngine)
+  app.resolve(ViewEngine)
+
+  app.singleton(Router)
+  const router = app.resolve(Router)
+
+  const handler = new ExceptionHandler(config.get('app.env') === 'local')
+  router.useExceptionHandler(handler)
+
+  await import('./start/routes')
+
+  app.singleton(Server)
+  const server = app.resolve(Server)
+  server.start(router)
+}
+
+boot().catch((err) => {
+  console.error('Failed to boot:', err)
+  process.exit(1)
+})
+`
+}
+
+function configHttp(): string {
+  return `import { env } from '@stravigor/core/helpers/env'
+
+export default {
+  host: env('HOST', '0.0.0.0'),
+  port: env.int('PORT', 3000),
+  domain: env('DOMAIN', 'localhost'),
+  public: './public',
+}
+`
+}
+
+function configSession(): string {
+  return `export default {
+  cookie: 'strav_session',
+  lifetime: 120,
+  httpOnly: true,
+  secure: false,
+  sameSite: 'lax' as const,
+}
+`
+}
+
+function configView(): string {
+  return `export default {
+  directory: 'views',
+  cache: false,
+}
+`
+}
+
+function routes(opts: ScaffoldOptions): string {
+  return `import { router } from '@stravigor/core/http'
+import { view } from '@stravigor/core/view'
+
+router.get('/', async () => {
+  return view('welcome', { name: '${opts.projectName}' })
+})
+
+router.get('/api/health', () => {
+  return Response.json({ status: 'ok' })
+})
+`
+}
+
+function welcomeView(): string {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>{{ name }} — Strav</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com">
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+  <link href="https://fonts.googleapis.com/css2?family=Barlow+Semi+Condensed:wght@400;600;700&display=swap" rel="stylesheet">
+  <link rel="stylesheet" href="/styles.css">
+</head>
+<body>
+  <div class="container">
+    <h1>Welcome to Strav</h1>
+    <p>Your application <strong>{{ name }}</strong> is up and running.</p>
+    <div class="links">
+      <a href="https://github.com/nicoyambura/stravigor" target="_blank">Documentation</a>
+    </div>
+  </div>
+</body>
+</html>
+`
+}
+
+function stylesCss(): string {
+  return `* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: 'Barlow Semi Condensed', sans-serif;
+  background: #f8fafc;
+  color: #1e293b;
+  min-height: 100vh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.container {
+  text-align: center;
+  padding: 2rem;
+}
+
+h1 {
+  font-size: 2.5rem;
+  font-weight: 700;
+  margin-bottom: 1rem;
+  color: oklch(57.7% 0.245 27.325);
+}
+
+p {
+  font-size: 1.125rem;
+  color: #64748b;
+  margin-bottom: 2rem;
+}
+
+p strong {
+  color: #1e293b;
+}
+
+.links a {
+  color: #2563eb;
+  text-decoration: none;
+  font-size: 0.875rem;
+  font-weight: 600;
+  border: 1px solid #e2e8f0;
+  padding: 0.5rem 1rem;
+  border-radius: 0.375rem;
+  transition: all 0.2s;
+}
+
+.links a:hover {
+  background: #eff6ff;
+  border-color: #2563eb;
+}
+`
+}