@strav/cli 0.4.31 → 1.0.0-alpha.4

package/src/key_generate.ts

@@ -0,0 +1,66 @@
+/**
+ * `bun strav key:generate` — generate APP_KEY and write it to `.env`.
+ *
+ * Generates 32 cryptographically-random bytes and hex-encodes them (64
+ * chars). This format matches `parseEncryptionKey()` in `@strav/kernel/encryption`
+ * so the value can be used directly as `config.encryption.key`.
+ *
+ * Behaviour:
+ *   - If `.env` doesn't exist, creates it with `APP_KEY=<key>`.
+ *   - If `.env` exists and already has `APP_KEY=`, updates the line.
+ *   - If `.env` exists without `APP_KEY=`, appends the line.
+ *   - `--show` prints the key to stdout instead of writing to disk
+ *     (useful when your secret manager reads from stdout).
+ *   - `--force` regenerates and overwrites even when APP_KEY is already set.
+ */
+
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { Command, type ExecuteArgs } from './command.ts'
+import { ExitCode } from './exit_codes.ts'
+
+export class KeyGenerate extends Command {
+  static signature = 'key:generate {--show} {--force}'
+  static description = 'Generate APP_KEY and write it to .env.'
+  static providers: string[] = []
+
+  override async execute({ flags }: ExecuteArgs): Promise<number> {
+    const envPath = join(process.cwd(), '.env')
+    const show = flags.show === true
+    const force = flags.force === true
+
+    // Read existing .env content (may not exist)
+    let existing = existsSync(envPath) ? await readFile(envPath, 'utf8') : ''
+
+    // Guard: don't overwrite unless --force
+    if (!force && existing.match(/^APP_KEY=.+/m)) {
+      this.warn('APP_KEY already set in .env. Use --force to overwrite.')
+      return ExitCode.Success
+    }
+
+    // Generate 32 random bytes → 64-char hex string
+    const bytes = new Uint8Array(32)
+    crypto.getRandomValues(bytes)
+    const key = [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')
+
+    if (show) {
+      this.line(`APP_KEY=${key}`)
+      return ExitCode.Success
+    }
+
+    if (existing.match(/^APP_KEY=/m)) {
+      // Replace the existing APP_KEY line
+      existing = existing.replace(/^APP_KEY=.*$/m, `APP_KEY=${key}`)
+    } else {
+      // Append (with a trailing newline)
+      existing = existing.trimEnd()
+      existing = existing ? `${existing}\nAPP_KEY=${key}\n` : `APP_KEY=${key}\n`
+    }
+
+    await writeFile(envPath, existing, 'utf8')
+    this.success(`APP_KEY written to ${envPath}`)
+    this.info('Add it to your shell with: source .env  (or use dotenv)')
+    return ExitCode.Success
+  }
+}

package/src/make/index.ts

@@ -0,0 +1,17 @@
+// make:* scaffold commands — one class per target file type.
+
+export { MakeCommandFile } from './make_command_file.ts'
+export { MakeController } from './make_controller.ts'
+export { MakeFactory } from './make_factory.ts'
+export { MakeJob } from './make_job.ts'
+export { MakeMail } from './make_mail.ts'
+export { MakeMiddleware } from './make_middleware.ts'
+export { MakeMigration } from './make_migration.ts'
+export { MakeModel } from './make_model.ts'
+export { MakeNotification } from './make_notification.ts'
+export { MakePolicy } from './make_policy.ts'
+export { MakeProvider } from './make_provider.ts'
+export { MakeRepository } from './make_repository.ts'
+export { MakeRequest } from './make_request.ts'
+export { MakeSeeder } from './make_seeder.ts'
+export { MakeTest } from './make_test.ts'

package/src/make/make_command_file.ts

@@ -0,0 +1,27 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeCommandFile extends MakeCommand {
+  static signature = 'make:command {name}'
+  static description = 'Create a console Command stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `app/console/commands/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name)
+    return `import { Command, type ExecuteArgs, ExitCode } from '@strav/cli'
+
+export class ${cls} extends Command {
+  static signature = '${snake(name).replace(/_/g, ':')}'
+  static description = 'Describe what this command does.'
+
+  override async execute({ args, flags }: ExecuteArgs): Promise<number> {
+    // implement the command here
+    return ExitCode.Success
+  }
+}
+`
+  }
+}

package/src/make/make_controller.ts

@@ -0,0 +1,24 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeController extends MakeCommand {
+  static signature = 'make:controller {name}'
+  static description = 'Create a new HTTP controller stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    const fileName = name.toLowerCase().endsWith('controller') ? snake(name) : `${snake(name)}_controller`
+    return `app/http/controllers/${fileName}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name).endsWith('Controller') ? pascal(name) : `${pascal(name)}Controller`
+    return `import type { HttpContext } from '@strav/http'
+
+export class ${cls} {
+  async handle(ctx: HttpContext): Promise<Response> {
+    return ctx.response.ok('Hello from ${cls}')
+  }
+}
+`
+  }
+}

package/src/make/make_factory.ts

@@ -0,0 +1,25 @@
+import { camel, MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeFactory extends MakeCommand {
+  static signature = 'make:factory {name}'
+  static description = 'Create a factory stub for a model.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    const base = snake(name).replace(/_factory$/, '')
+    return `database/factories/${base}_factory.ts`
+  }
+
+  protected stub(name: string): string {
+    const base = pascal(name).replace(/Factory$/, '')
+    return `import type { ${base} } from '../../app/models/${snake(base)}.ts'
+
+export function ${camel(base)}Factory(overrides: Partial<${base}> = {}): ${base} {
+  return {
+    // define default attribute values here
+    ...overrides,
+  } as ${base}
+}
+`
+  }
+}

package/src/make/make_job.ts

@@ -0,0 +1,25 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeJob extends MakeCommand {
+  static signature = 'make:job {name}'
+  static description = 'Create a queue job stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `app/jobs/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name)
+    return `import { Job, type JobContext } from '@strav/queue'
+
+export class ${cls} extends Job<unknown> {
+  static override readonly jobName = '${snake(name)}'
+
+  async handle(ctx: JobContext<unknown>): Promise<void> {
+    // handle the job
+  }
+}
+`
+  }
+}

package/src/make/make_mail.ts

@@ -0,0 +1,27 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeMail extends MakeCommand {
+  static signature = 'make:mail {name}'
+  static description = 'Create a Mailable stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `app/mail/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name)
+    return `import { Mailable, type Message } from '@strav/signal'
+
+export class ${cls} extends Mailable<unknown> {
+  build(payload: unknown): Message {
+    return {
+      to: [{ address: 'recipient@example.com' }],
+      subject: '${pascal(name)}',
+      html: '<p>Hello</p>',
+    }
+  }
+}
+`
+  }
+}

package/src/make/make_middleware.ts

@@ -0,0 +1,23 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeMiddleware extends MakeCommand {
+  static signature = 'make:middleware {name}'
+  static description = 'Create a new HTTP middleware stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `app/http/middleware/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name)
+    return `import type { HttpContext, MiddlewareNext } from '@strav/http'
+
+export class ${cls} {
+  async handle(ctx: HttpContext, next: MiddlewareNext): Promise<Response> {
+    return next(ctx)
+  }
+}
+`
+  }
+}

package/src/make/make_migration.ts

@@ -0,0 +1,48 @@
+import { UsageError } from '../binder.ts'
+import type { ExecuteArgs } from '../command.ts'
+import { MakeCommand } from '../make_command.ts'
+
+export class MakeMigration extends MakeCommand {
+  static signature = 'make:migration {--message=}'
+  static description = 'Create a migration file stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `database/migrations/${name}.ts`
+  }
+
+  protected stub(name: string): string {
+    return `import type { Migration } from '@strav/database'
+
+export const migration: Migration = {
+  name: '${name}',
+  async up(db) {
+    // write your migration here
+  },
+  async down(db) {
+    // write your rollback here
+  },
+}
+`
+  }
+
+  override async execute({ flags }: ExecuteArgs): Promise<number> {
+    const msg = (flags.message as string | undefined)?.trim()
+    if (!msg) {
+      throw new UsageError(
+        '--message (or -m) is required: bun strav make:migration -m "create users"',
+      )
+    }
+    const slug = msg
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '_')
+      .replace(/^_+|_+$/g, '')
+    if (!slug)
+      throw new UsageError(`--message "${msg}" produced an empty slug — use letters / digits`)
+    const now = new Date()
+    const pad = (n: number) => String(n).padStart(2, '0')
+    const ts = `${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`
+    const name = `${ts}_${slug}`
+    return super.execute({ args: { name }, flags })
+  }
+}

package/src/make/make_model.ts

@@ -0,0 +1,91 @@
+/**
+ * `make:model <Name>` — the model_generator.
+ *
+ * Writes three files (each skipped if it already exists):
+ *   - `app/models/<name>.ts`            — Model class
+ *   - `app/repositories/<name>_repository.ts` — Repository<Model>
+ *   - `database/factories/<name>_factory.ts`  — Factory stub
+ */
+
+import { existsSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { Command, type ExecuteArgs } from '../command.ts'
+import { ExitCode } from '../exit_codes.ts'
+import { camel, pascal, snake } from '../make_command.ts'
+
+export class MakeModel extends Command {
+  static signature = 'make:model {name}'
+  static description = 'Create Model + Repository + Factory stubs (model_generator).'
+  static providers: string[] = []
+
+  override async execute({ args }: ExecuteArgs): Promise<number> {
+    const raw = (args.name ?? '').trim()
+    if (!raw) {
+      this.error('A model name is required.')
+      return ExitCode.UsageError
+    }
+
+    const name = pascal(raw)
+    const files: Array<{ path: string; content: string }> = [
+      { path: `app/models/${snake(raw)}.ts`, content: modelStub(name) },
+      {
+        path: `app/repositories/${snake(raw)}_repository.ts`,
+        content: repositoryStub(name),
+      },
+      {
+        path: `database/factories/${snake(raw)}_factory.ts`,
+        content: factoryStub(name),
+      },
+    ]
+
+    for (const { path, content } of files) {
+      const dest = join(process.cwd(), path)
+      if (existsSync(dest)) {
+        this.warn(`${dest} already exists — skipping.`)
+        continue
+      }
+      await mkdir(dirname(dest), { recursive: true })
+      await writeFile(dest, content, 'utf8')
+      this.success(`Created ${dest}`)
+    }
+    return ExitCode.Success
+  }
+}
+
+function modelStub(name: string): string {
+  return `import { Model } from '@strav/database'
+
+export class ${name} extends Model {
+  declare id: string
+  // add your properties here
+}
+`
+}
+
+function repositoryStub(name: string): string {
+  return `import { inject } from '@strav/kernel'
+import { PostgresDatabase, Repository } from '@strav/database'
+import { ${name} } from '../models/${snake(name)}.ts'
+import { ${camel(name)}Schema } from '../../database/schemas/${snake(name)}_schema.ts'
+
+@inject()
+export class ${name}Repository extends Repository<${name}> {
+  constructor(db: PostgresDatabase) {
+    super(db, ${camel(name)}Schema)
+  }
+}
+`
+}
+
+function factoryStub(name: string): string {
+  return `import type { ${name} } from '../../app/models/${snake(name)}.ts'
+
+export function ${camel(name)}Factory(overrides: Partial<${name}> = {}): ${name} {
+  return {
+    // define default attribute values here
+    ...overrides,
+  } as ${name}
+}
+`
+}

package/src/make/make_notification.ts

@@ -0,0 +1,23 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeNotification extends MakeCommand {
+  static signature = 'make:notification {name}'
+  static description = 'Create a Notification stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `app/notifications/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name)
+    return `// ${cls} notification
+// Implement channels (mail, database, broadcast) once @strav/signal notifications land.
+export class ${cls} {
+  via(): string[] {
+    return ['mail']
+  }
+}
+`
+  }
+}

package/src/make/make_policy.ts

@@ -0,0 +1,24 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakePolicy extends MakeCommand {
+  static signature = 'make:policy {name}'
+  static description = 'Create an authorization policy stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    const base = snake(name).replace(/_policy$/, '')
+    return `app/policies/${base}_policy.ts`
+  }
+
+  protected stub(name: string): string {
+    const base = pascal(name).replace(/Policy$/, '')
+    const cls = `${base}Policy`
+    return `export class ${cls} {
+  // async view(user: User, model: ${base}): Promise<boolean> { return true }
+  // async create(user: User): Promise<boolean> { return true }
+  // async update(user: User, model: ${base}): Promise<boolean> { return true }
+  // async delete(user: User, model: ${base}): Promise<boolean> { return true }
+}
+`
+  }
+}

package/src/make/make_provider.ts

@@ -0,0 +1,29 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeProvider extends MakeCommand {
+  static signature = 'make:provider {name}'
+  static description = 'Create a ServiceProvider stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `app/providers/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name).endsWith('Provider') ? pascal(name) : `${pascal(name)}Provider`
+    return `import { type Application, ServiceProvider } from '@strav/kernel'
+
+export class ${cls} extends ServiceProvider {
+  override readonly name = '${snake(cls).replace(/_provider$/, '')}'
+
+  override register(app: Application): void {
+    // bind services into the container
+  }
+
+  override async boot(app: Application): Promise<void> {
+    // run initialization after all providers are registered
+  }
+}
+`
+  }
+}

package/src/make/make_repository.ts

@@ -0,0 +1,30 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeRepository extends MakeCommand {
+  static signature = 'make:repository {name}'
+  static description = 'Create a Repository stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    const base = snake(name).replace(/_repository$/, '')
+    return `app/repositories/${base}_repository.ts`
+  }
+
+  protected stub(name: string): string {
+    const base = pascal(name).replace(/Repository$/, '')
+    const cls = `${base}Repository`
+    const model = base
+    return `import { inject } from '@strav/kernel'
+import { type Database, PostgresDatabase, Repository } from '@strav/database'
+import { ${model} } from '../models/${snake(model)}.ts'
+import { ${snake(model)}Schema } from '../../database/schemas/${snake(model)}_schema.ts'
+
+@inject()
+export class ${cls} extends Repository<${model}> {
+  constructor(db: PostgresDatabase) {
+    super(db, ${snake(model)}Schema)
+  }
+}
+`
+  }
+}

package/src/make/make_request.ts

@@ -0,0 +1,24 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeRequest extends MakeCommand {
+  static signature = 'make:request {name}'
+  static description = 'Create a new FormRequest stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `app/http/requests/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name).endsWith('Request') ? pascal(name) : `${pascal(name)}Request`
+    return `import { FormRequest } from '@strav/http'
+import { z } from 'zod'
+
+export class ${cls} extends FormRequest {
+  schema = z.object({
+    // define your fields here
+  })
+}
+`
+  }
+}

package/src/make/make_seeder.ts

@@ -0,0 +1,23 @@
+import { MakeCommand, pascal, snake } from '../make_command.ts'
+
+export class MakeSeeder extends MakeCommand {
+  static signature = 'make:seeder {name}'
+  static description = 'Create a database seeder stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `database/seeders/${snake(name)}.ts`
+  }
+
+  protected stub(name: string): string {
+    const cls = pascal(name).endsWith('Seeder') ? pascal(name) : `${pascal(name)}Seeder`
+    return `import type { Database } from '@strav/database'
+
+export class ${cls} {
+  async run(db: Database): Promise<void> {
+    // seed your data here
+  }
+}
+`
+  }
+}

package/src/make/make_test.ts

@@ -0,0 +1,22 @@
+import { MakeCommand, snake } from '../make_command.ts'
+
+export class MakeTest extends MakeCommand {
+  static signature = 'make:test {name}'
+  static description = 'Create a feature test stub.'
+  static providers: string[] = []
+
+  protected filePath(name: string): string {
+    return `tests/feature/${snake(name)}.test.ts`
+  }
+
+  protected stub(name: string): string {
+    return `import { describe, expect, test } from 'bun:test'
+
+describe('${snake(name).replace(/_/g, ' ')}', () => {
+  test('placeholder', () => {
+    expect(true).toBe(true)
+  })
+})
+`
+  }
+}

package/src/make_command.ts

@@ -0,0 +1,69 @@
+/**
+ * `MakeCommand` — base for every `make:*` scaffold command.
+ *
+ * Subclasses implement `filePath(name)` and `stub(name)` and get the
+ * filesystem write, exists-check, and directory creation for free.
+ *
+ * Naming helpers (`pascal`, `snake`, `camel`) convert the user's input
+ * into the conventional forms each stub needs.
+ *
+ * Re-running against an existing file is a no-op with a warning —
+ * there's no overwrite mode. Stubs can't safely re-derive what the user
+ * has already edited.
+ */
+
+import { existsSync } from 'node:fs'
+import { mkdir, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { Command, type ExecuteArgs } from './command.ts'
+import { ExitCode } from './exit_codes.ts'
+
+export abstract class MakeCommand extends Command {
+  /** Destination path relative to `process.cwd()`. */
+  protected abstract filePath(name: string): string
+  /** File content to write. */
+  protected abstract stub(name: string): string
+
+  override async execute({ args }: ExecuteArgs): Promise<number> {
+    const raw = (args.name ?? '').trim()
+    if (!raw) {
+      this.error('A name is required.')
+      return ExitCode.UsageError
+    }
+
+    const dest = join(process.cwd(), this.filePath(raw))
+    if (existsSync(dest)) {
+      this.warn(`${dest} already exists — skipping. Delete it first to regenerate.`)
+      return ExitCode.Success
+    }
+
+    await mkdir(dirname(dest), { recursive: true })
+    await writeFile(dest, this.stub(raw), 'utf8')
+    this.success(`Created ${dest}`)
+    return ExitCode.Success
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Naming helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** MyFoo / my_foo / my-foo → MyFoo */
+export function pascal(name: string): string {
+  return name
+    .replace(/[-_](.)/g, (_, c: string) => c.toUpperCase())
+    .replace(/^(.)/, (_, c: string) => c.toUpperCase())
+}
+
+/** MyFoo / myFoo → my_foo */
+export function snake(name: string): string {
+  return pascal(name)
+    .replace(/([A-Z])/g, (c) => `_${c.toLowerCase()}`)
+    .replace(/^_/, '')
+}
+
+/** MyFoo → myFoo */
+export function camel(name: string): string {
+  const p = pascal(name)
+  return p.charAt(0).toLowerCase() + p.slice(1)
+}