@strav/create 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 0.5.3
+
+### Added
+
+- **Web template**: `resources/islands/setup.ts` stub for shared Vue app configuration (plugin installation, global provides)
+
+## 0.1.1
+
+### Changed
+
+- Applied consistent code formatting across all source files

package/README.md

@@ -0,0 +1,46 @@
+# @stravigor/create
+
+Scaffold a new [Strav](https://www.npmjs.com/package/@stravigor/core) application.
+
+## Usage
+
+```bash
+bunx @stravigor/create@latest my-app --api   # headless REST API
+bunx @stravigor/create@latest my-app --web   # full-stack with views
+bunx @stravigor/create@latest my-app         # interactive prompt
+```
+
+## 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]
+
+--api                     Headless REST API template
+--web                     Full-stack template with views and static files
+--template, -t api|web    Alias for --api / --web
+--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,24 @@
+{
+  "name": "@strav/create",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Scaffold a new Strav application",
+  "license": "MIT",
+  "keywords": [
+    "strav",
+    "stravigor",
+    "bun",
+    "framework",
+    "scaffold",
+    "create"
+  ],
+  "bin": {
+    "@strav/create": "./src/index.ts"
+  },
+  "files": [
+    "src/",
+    "package.json",
+    "README.md",
+    "CHANGELOG.md"
+  ]
+}

package/src/index.ts

@@ -0,0 +1,164 @@
+#!/usr/bin/env bun
+import { existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { select, input } from './prompts.ts'
+import { scaffold, type ScaffoldOptions } from './scaffold.ts'
+import pkg from '../package.json'
+
+const VERSION = pkg.version
+
+// ── 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 === '--api') {
+      result.template = 'api'
+    } else if (arg === '--web') {
+      result.template = 'web'
+    } 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 && !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:')}
+    --api                     Headless REST API template
+    --web                     Full-stack template with views and static files
+    --template, -t ${dim('api|web')}    Alias for --api / --web
+    --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,135 @@
+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 choice = choices[i]!
+      const label = i === selected ? `\x1b[1m${choice.label}\x1b[0m` : choice.label
+      const desc = `\x1b[2m${choice.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,54 @@
+import { readdirSync, mkdirSync, statSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import pkg from '../package.json'
+
+export interface ScaffoldOptions {
+  projectName: string
+  template: 'api' | 'web'
+  dbName: string
+}
+
+export async function scaffold(root: string, opts: ScaffoldOptions): Promise<void> {
+  const templatesDir = join(import.meta.dir, 'templates')
+  const appKey = crypto.randomUUID()
+
+  const replacements: Record<string, string> = {
+    __PROJECT_NAME__: opts.projectName,
+    __DB_NAME__: opts.dbName,
+    __APP_KEY__: appKey,
+    __CORE_VERSION__: `^${pkg.version}`,
+  }
+
+  // Copy shared files first, then template-specific (may override shared)
+  await copyDir(join(templatesDir, 'shared'), root, replacements)
+  await copyDir(join(templatesDir, opts.template), root, replacements)
+}
+
+async function copyDir(
+  srcDir: string,
+  destDir: string,
+  replacements: Record<string, string>
+): Promise<void> {
+  const entries = readdirSync(srcDir)
+
+  for (const entry of entries) {
+    const srcPath = join(srcDir, entry)
+    const destPath = join(destDir, entry.replace(/\.tpl$/, ''))
+
+    if (statSync(srcPath).isDirectory()) {
+      await copyDir(srcPath, destPath, replacements)
+    } else {
+      mkdirSync(dirname(destPath), { recursive: true })
+      const content = await Bun.file(srcPath).text()
+      await Bun.write(destPath, applyReplacements(content, replacements))
+    }
+  }
+}
+
+function applyReplacements(content: string, replacements: Record<string, string>): string {
+  let result = content
+  for (const [placeholder, value] of Object.entries(replacements)) {
+    result = result.replaceAll(placeholder, value)
+  }
+  return result
+}

package/src/templates/api/config/http.ts

@@ -0,0 +1,7 @@
+import { env } from '@stravigor/kernel/helpers/env'
+
+export default {
+  host: env('HOST', '0.0.0.0'),
+  port: env.int('PORT', 3000),
+  domain: env('DOMAIN', 'localhost'),
+}

package/src/templates/api/index.ts

@@ -0,0 +1,30 @@
+import 'reflect-metadata'
+import { app } from '@stravigor/kernel/core'
+import { router } from '@stravigor/http/http'
+import { ConfigProvider, EncryptionProvider } from '@stravigor/kernel/providers'
+import { DatabaseProvider } from '@stravigor/database/providers'
+import BaseModel from '@stravigor/database/orm/base_model'
+import Database from '@stravigor/database/database/database'
+import Server from '@stravigor/http/http/server'
+import { ExceptionHandler } from '@stravigor/kernel/exceptions'
+
+// Register service providers
+app.use(new ConfigProvider()).use(new DatabaseProvider()).use(new EncryptionProvider())
+
+// Boot services (loads config, connects database, derives encryption keys)
+await app.start()
+
+// Initialize ORM
+new BaseModel(app.resolve(Database))
+
+// Configure router
+router.useExceptionHandler(new ExceptionHandler(true))
+router.cors()
+
+// Load routes
+await import('./start/routes')
+
+// Start HTTP server
+app.singleton(Server)
+const server = app.resolve(Server)
+server.start(router)

package/src/templates/api/start/routes.ts

@@ -0,0 +1,12 @@
+import { router } from '@stravigor/http/http'
+
+router.get('/', () => {
+  return Response.json({
+    name: '__PROJECT_NAME__',
+    status: 'running',
+  })
+})
+
+router.get('/health', () => {
+  return Response.json({ status: 'ok' })
+})

package/src/templates/api/tests/health.test.ts.tpl

@@ -0,0 +1,12 @@
+import { test, expect } from 'bun:test'
+import { TestCase } from '@stravigor/testing'
+
+const t = await TestCase.boot({
+  routes: () => import('../start/routes'),
+})
+
+test('health check returns ok', async () => {
+  const res = await t.get('/health')
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual({ status: 'ok' })
+})

package/src/templates/shared/.env.tpl

@@ -0,0 +1,13 @@
+APP_ENV=local
+APP_DEBUG=true
+APP_KEY=__APP_KEY__
+
+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=__DB_NAME__

package/src/templates/shared/.gitignore.tpl

@@ -0,0 +1,5 @@
+node_modules/
+.env
+app/
+database/migrations/
+*.log

package/src/templates/shared/config/app.ts

@@ -0,0 +1,7 @@
+import { env } from '@stravigor/kernel/helpers/env'
+
+export default {
+  env: env('APP_ENV', 'local'),
+  debug: env.bool('APP_DEBUG', true),
+  key: env('APP_KEY'),
+}

package/src/templates/shared/config/database.ts

@@ -0,0 +1,11 @@
+import { env } from '@stravigor/kernel/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', '__DB_NAME__'),
+  pool: env.int('DB_POOL_MAX', 10),
+  idleTimeout: env.int('DB_IDLE_TIMEOUT', 20),
+}

package/src/templates/shared/config/encryption.ts

@@ -0,0 +1,6 @@
+import { env } from '@stravigor/kernel/helpers/env'
+
+export default {
+  key: env('APP_KEY'),
+  previousKeys: [],
+}

package/src/templates/shared/database/schemas/user.ts

@@ -0,0 +1,10 @@
+import { defineSchema, t, Archetype } from '@stravigor/database/schema'
+
+export default defineSchema('user', {
+  archetype: Archetype.Entity,
+  fields: {
+    email: t.varchar(255).required().unique().index(),
+    name: t.varchar(255).required(),
+    password: t.varchar(255).required().sensitive(),
+  },
+})

package/src/templates/shared/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "__PROJECT_NAME__",
+  "version": "0.0.1",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "dev": "bun --hot index.ts",
+    "start": "bun index.ts",
+    "test": "bun test tests/"
+  },
+  "dependencies": {
+    "@stravigor/kernel": "__CORE_VERSION__",
+    "@stravigor/http": "__CORE_VERSION__",
+    "@stravigor/view": "__CORE_VERSION__",
+    "@stravigor/database": "__CORE_VERSION__",
+    "@stravigor/cli": "__CORE_VERSION__",
+    "luxon": "^3.7.2",
+    "reflect-metadata": "^0.2.2"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/luxon": "^3.7.1",
+    "@stravigor/testing": "__CORE_VERSION__"
+  }
+}

package/src/templates/shared/strav.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import '@stravigor/cli/cli/strav'

package/src/templates/shared/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "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"
+  ]
+}

package/src/templates/web/config/http.ts

@@ -0,0 +1,8 @@
+import { env } from '@stravigor/kernel/helpers/env'
+
+export default {
+  host: env('HOST', '0.0.0.0'),
+  port: env.int('PORT', 3000),
+  domain: env('DOMAIN', 'localhost'),
+  public: './public',
+}

package/src/templates/web/config/session.ts

@@ -0,0 +1,7 @@
+export default {
+  cookie: 'strav_session',
+  lifetime: 120,
+  httpOnly: true,
+  secure: false,
+  sameSite: 'lax' as const,
+}

package/src/templates/web/config/view.ts

@@ -0,0 +1,4 @@
+export default {
+  directory: 'resources/views',
+  cache: false,
+}

package/src/templates/web/index.ts

@@ -0,0 +1,36 @@
+import 'reflect-metadata'
+import { app } from '@stravigor/kernel/core'
+import { router } from '@stravigor/http/http'
+import { ConfigProvider, EncryptionProvider } from '@stravigor/kernel/providers'
+import { DatabaseProvider } from '@stravigor/database/providers'
+import { SessionProvider } from '@stravigor/http/providers'
+import { ViewProvider } from '@stravigor/view'
+import BaseModel from '@stravigor/database/orm/base_model'
+import Database from '@stravigor/database/database/database'
+import Server from '@stravigor/http/http/server'
+import { ExceptionHandler } from '@stravigor/kernel/exceptions'
+
+// Register service providers
+app
+  .use(new ConfigProvider())
+  .use(new DatabaseProvider())
+  .use(new EncryptionProvider())
+  .use(new SessionProvider())
+  .use(new ViewProvider())
+
+// Boot services (loads config, connects database, derives encryption keys, starts sessions)
+await app.start()
+
+// Initialize ORM
+new BaseModel(app.resolve(Database))
+
+// Configure router
+router.useExceptionHandler(new ExceptionHandler(true))
+
+// Load routes
+await import('./start/routes')
+
+// Start HTTP server
+app.singleton(Server)
+const server = app.resolve(Server)
+server.start(router)

package/src/templates/web/public/styles.css

@@ -0,0 +1,53 @@
+* {
+  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;
+}

package/src/templates/web/resources/islands/setup.ts

@@ -0,0 +1,11 @@
+import type { App } from 'vue'
+
+export default function setup(app: App) {
+  // Install plugins, provide globals, or register components here.
+  // This runs once before any island is mounted.
+  //
+  // Examples:
+  //   app.use(pinia)
+  //   app.provide('api', apiClient)
+  //   app.component('Icon', Icon)
+}

package/src/templates/web/resources/views/welcome.strav

@@ -0,0 +1,21 @@
+<!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>

package/src/templates/web/start/routes.ts

@@ -0,0 +1,10 @@
+import { router } from '@stravigor/http/http'
+import { view } from '@stravigor/view'
+
+router.get('/', async () => {
+  return view('welcome', { name: '__PROJECT_NAME__' })
+})
+
+router.get('/api/health', () => {
+  return Response.json({ status: 'ok' })
+})

package/src/templates/web/tests/health.test.ts.tpl

@@ -0,0 +1,12 @@
+import { test, expect } from 'bun:test'
+import { TestCase } from '@stravigor/testing'
+
+const t = await TestCase.boot({
+  routes: () => import('../start/routes'),
+})
+
+test('health check returns ok', async () => {
+  const res = await t.get('/api/health')
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual({ status: 'ok' })
+})