@mantiq/cli 0.0.1

package/src/commands/MakeExceptionCommand.ts

@@ -0,0 +1,25 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeExceptionCommand extends GeneratorCommand {
+  override name = 'make:exception'
+  override description = 'Create a new exception class'
+  override usage = 'make:exception <name>'
+
+  override directory() { return 'app/Exceptions' }
+  override suffix() { return 'Exception' }
+
+  override stub(name: string, args: ParsedArgs): string {
+    const className = `${name}Exception`
+    const statusCode = (args.flags['status'] as string) || '500'
+    return `import { MantiqError } from '@mantiq/core'
+
+export class ${className} extends MantiqError {
+  constructor(message = '${name} error', public override statusCode = ${statusCode}) {
+    super(message)
+    this.name = '${className}'
+  }
+}
+`
+  }
+}

package/src/commands/MakeFactoryCommand.ts

@@ -0,0 +1,29 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeFactoryCommand extends GeneratorCommand {
+  override name = 'make:factory'
+  override description = 'Create a new model factory'
+  override usage = 'make:factory <name>'
+
+  override directory() { return 'database/factories' }
+  override suffix() { return 'Factory' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    const modelName = name.replace(/Factory$/, '')
+    return `import { Factory } from '@mantiq/database'
+import type { Faker } from '@mantiq/database'
+import { ${modelName} } from '../../app/Models/${modelName}.ts'
+
+export class ${name}Factory extends Factory<${modelName}> {
+  protected override model = ${modelName}
+
+  override definition(index: number, fake: Faker) {
+    return {
+      name: fake.name(),
+    }
+  }
+}
+`
+  }
+}

package/src/commands/MakeListenerCommand.ts

@@ -0,0 +1,29 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeListenerCommand extends GeneratorCommand {
+  override name = 'make:listener'
+  override description = 'Create a new event listener class'
+  override usage = 'make:listener <name> [--event=EventName]'
+
+  override directory() { return 'app/Listeners' }
+  override suffix() { return 'Listener' }
+
+  override stub(name: string, args: ParsedArgs): string {
+    const className = `${name}Listener`
+    const event = (args.flags['event'] as string) || 'Event'
+    const hasEvent = args.flags['event']
+
+    const importLine = hasEvent
+      ? `import type { ${event} } from '../Events/${event}.ts'\n\n`
+      : ''
+    const paramType = hasEvent ? event : 'unknown'
+
+    return `${importLine}export class ${className} {
+  async handle(event: ${paramType}): Promise<void> {
+    // TODO: handle event
+  }
+}
+`
+  }
+}

package/src/commands/MakeMiddlewareCommand.ts

@@ -0,0 +1,23 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeMiddlewareCommand extends GeneratorCommand {
+  override name = 'make:middleware'
+  override description = 'Create a new middleware class'
+  override usage = 'make:middleware <name>'
+
+  override directory() { return 'app/Http/Middleware' }
+  override suffix() { return 'Middleware' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    const className = `${name}Middleware`
+    return `import type { Middleware, MantiqRequest, NextFunction } from '@mantiq/core'
+
+export class ${className} implements Middleware {
+  async handle(request: MantiqRequest, next: NextFunction): Promise<Response> {
+    return next()
+  }
+}
+`
+  }
+}

package/src/commands/MakeMigrationCommand.ts

@@ -0,0 +1,125 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { existsSync, mkdirSync } from 'node:fs'
+
+export class MakeMigrationCommand extends Command {
+  override name = 'make:migration'
+  override description = 'Create a new migration file'
+  override usage = 'make:migration <name> [--create=table] [--table=table]'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    const rawName = args.args[0]
+    if (!rawName) {
+      this.io.error('Please provide a migration name. Usage: make:migration <name>')
+      return 1
+    }
+
+    const createTable = args.flags['create'] as string | undefined
+    const alterTable = args.flags['table'] as string | undefined
+
+    const timestamp = this.timestamp()
+    const snakeName = this.toSnakeCase(rawName)
+    const fileName = `${timestamp}_${snakeName}.ts`
+    const dir = `${process.cwd()}/database/migrations`
+    mkdirSync(dir, { recursive: true })
+    const filePath = `${dir}/${fileName}`
+
+    if (existsSync(filePath)) {
+      this.io.error(`${fileName} already exists.`)
+      return 1
+    }
+
+    const className = this.toClassName(snakeName)
+    const content = createTable
+      ? this.createStub(className, createTable)
+      : alterTable
+        ? this.alterStub(className, alterTable)
+        : this.blankStub(className)
+
+    await Bun.write(filePath, content)
+    this.io.success(`Created database/migrations/${fileName}`)
+    return 0
+  }
+
+  private createStub(className: string, table: string): string {
+    return `import { Migration } from '@mantiq/database'
+import type { SchemaBuilder } from '@mantiq/database'
+
+export default class ${className} extends Migration {
+  override async up(schema: SchemaBuilder) {
+    await schema.create('${table}', (t) => {
+      t.id()
+      t.timestamps()
+    })
+  }
+
+  override async down(schema: SchemaBuilder) {
+    await schema.dropIfExists('${table}')
+  }
+}
+`
+  }
+
+  private alterStub(className: string, table: string): string {
+    return `import { Migration } from '@mantiq/database'
+import type { SchemaBuilder } from '@mantiq/database'
+
+export default class ${className} extends Migration {
+  override async up(schema: SchemaBuilder) {
+    await schema.table('${table}', (t) => {
+      //
+    })
+  }
+
+  override async down(schema: SchemaBuilder) {
+    await schema.table('${table}', (t) => {
+      //
+    })
+  }
+}
+`
+  }
+
+  private blankStub(className: string): string {
+    return `import { Migration } from '@mantiq/database'
+import type { SchemaBuilder } from '@mantiq/database'
+
+export default class ${className} extends Migration {
+  override async up(schema: SchemaBuilder) {
+    //
+  }
+
+  override async down(schema: SchemaBuilder) {
+    //
+  }
+}
+`
+  }
+
+  private timestamp(): string {
+    const now = new Date()
+    return [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, '0'),
+      String(now.getDate()).padStart(2, '0'),
+      String(now.getHours()).padStart(2, '0'),
+      String(now.getMinutes()).padStart(2, '0'),
+      String(now.getSeconds()).padStart(2, '0'),
+    ].join('')
+  }
+
+  private toSnakeCase(name: string): string {
+    return name
+      .replace(/([A-Z])/g, '_$1')
+      .toLowerCase()
+      .replace(/^_/, '')
+      .replace(/[-\s]+/g, '_')
+  }
+
+  private toClassName(snakeName: string): string {
+    return snakeName
+      .split('_')
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join('')
+  }
+}

package/src/commands/MakeModelCommand.ts

@@ -0,0 +1,150 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { existsSync, mkdirSync } from 'node:fs'
+
+export class MakeModelCommand extends GeneratorCommand {
+  override name = 'make:model'
+  override description = 'Create a new model class'
+  override usage = 'make:model <name> [-m|--migration] [-f|--factory] [-s|--seed]'
+
+  override directory() { return 'app/Models' }
+  override suffix() { return '' }
+
+  override stub(name: string): string {
+    const tableName = this.toTableName(name)
+    return `import { Model } from '@mantiq/database'
+
+export class ${name} extends Model {
+  static override table = '${tableName}'
+
+  static override fillable = ['name']
+
+  static override hidden = []
+
+  static override casts = {}
+}
+`
+  }
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    const code = await super.handle(args)
+    if (code !== 0) return code
+
+    const name = this.toClassName(args.args[0]!)
+
+    // Also create migration if -m or --migration
+    if (args.flags['m'] || args.flags['migration']) {
+      await this.createMigration(name)
+    }
+
+    // Also create factory if -f or --factory
+    if (args.flags['f'] || args.flags['factory']) {
+      await this.createFactory(name)
+    }
+
+    // Also create seeder if -s or --seed
+    if (args.flags['s'] || args.flags['seed']) {
+      await this.createSeeder(name)
+    }
+
+    return 0
+  }
+
+  private async createMigration(name: string): Promise<void> {
+    const tableName = this.toTableName(name)
+    const timestamp = this.timestamp()
+    const fileName = `${timestamp}_create_${tableName}_table.ts`
+    const dir = `${process.cwd()}/database/migrations`
+    mkdirSync(dir, { recursive: true })
+    const filePath = `${dir}/${fileName}`
+
+    if (existsSync(filePath)) return
+
+    const content = `import { Migration } from '@mantiq/database'
+import type { SchemaBuilder } from '@mantiq/database'
+
+export default class Create${name}sTable extends Migration {
+  override async up(schema: SchemaBuilder) {
+    await schema.create('${tableName}', (t) => {
+      t.id()
+      t.string('name')
+      t.timestamps()
+    })
+  }
+
+  override async down(schema: SchemaBuilder) {
+    await schema.dropIfExists('${tableName}')
+  }
+}
+`
+    await Bun.write(filePath, content)
+    this.io.success(`Created database/migrations/${fileName}`)
+  }
+
+  private async createFactory(name: string): Promise<void> {
+    const dir = `${process.cwd()}/database/factories`
+    const fileName = `${name}Factory.ts`
+    const filePath = `${dir}/${fileName}`
+    mkdirSync(dir, { recursive: true })
+
+    if (existsSync(filePath)) return
+
+    const content = `import { Factory } from '@mantiq/database'
+import type { Faker } from '@mantiq/database'
+import { ${name} } from '../../app/Models/${name}.ts'
+
+export class ${name}Factory extends Factory<${name}> {
+  protected override model = ${name}
+
+  override definition(index: number, fake: Faker) {
+    return {
+      name: fake.name(),
+    }
+  }
+}
+`
+    await Bun.write(filePath, content)
+    this.io.success(`Created database/factories/${fileName}`)
+  }
+
+  private async createSeeder(name: string): Promise<void> {
+    const dir = `${process.cwd()}/database/seeders`
+    const fileName = `${name}Seeder.ts`
+    const filePath = `${dir}/${fileName}`
+    mkdirSync(dir, { recursive: true })
+
+    if (existsSync(filePath)) return
+
+    const content = `import { Seeder } from '@mantiq/database'
+
+export default class ${name}Seeder extends Seeder {
+  override async run() {
+    // TODO: seed ${name.toLowerCase()} data
+  }
+}
+`
+    await Bun.write(filePath, content)
+    this.io.success(`Created database/seeders/${fileName}`)
+  }
+
+  private toTableName(name: string): string {
+    // PascalCase to snake_case plural: User -> users, BlogPost -> blog_posts
+    return name
+      .replace(/([A-Z])/g, '_$1')
+      .toLowerCase()
+      .replace(/^_/, '')
+      .replace(/s?$/, 's')
+  }
+
+  private timestamp(): string {
+    const now = new Date()
+    return [
+      now.getFullYear(),
+      String(now.getMonth() + 1).padStart(2, '0'),
+      String(now.getDate()).padStart(2, '0'),
+      String(now.getHours()).padStart(2, '0'),
+      String(now.getMinutes()).padStart(2, '0'),
+      String(now.getSeconds()).padStart(2, '0'),
+    ].join('')
+  }
+}

package/src/commands/MakeObserverCommand.ts

@@ -0,0 +1,32 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeObserverCommand extends GeneratorCommand {
+  override name = 'make:observer'
+  override description = 'Create a new model observer class'
+  override usage = 'make:observer <name> [--model=ModelName]'
+
+  override directory() { return 'app/Observers' }
+  override suffix() { return 'Observer' }
+
+  override stub(name: string, args: ParsedArgs): string {
+    const className = `${name}Observer`
+    const model = (args.flags['model'] as string) || name
+    return `import type { ${model} } from '../Models/${model}.ts'
+
+export class ${className} {
+  async created(model: ${model}): Promise<void> {
+    //
+  }
+
+  async updated(model: ${model}): Promise<void> {
+    //
+  }
+
+  async deleted(model: ${model}): Promise<void> {
+    //
+  }
+}
+`
+  }
+}

package/src/commands/MakeProviderCommand.ts

@@ -0,0 +1,27 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeProviderCommand extends GeneratorCommand {
+  override name = 'make:provider'
+  override description = 'Create a new service provider class'
+  override usage = 'make:provider <name>'
+
+  override directory() { return 'app/Providers' }
+  override suffix() { return 'ServiceProvider' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    const className = `${name}ServiceProvider`
+    return `import { ServiceProvider } from '@mantiq/core'
+
+export class ${className} extends ServiceProvider {
+  override register(): void {
+    // Register bindings into the container
+  }
+
+  override async boot(): Promise<void> {
+    // Boot application services
+  }
+}
+`
+  }
+}

package/src/commands/MakeRequestCommand.ts

@@ -0,0 +1,29 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeRequestCommand extends GeneratorCommand {
+  override name = 'make:request'
+  override description = 'Create a new form request class'
+  override usage = 'make:request <name>'
+
+  override directory() { return 'app/Http/Requests' }
+  override suffix() { return 'Request' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    const className = `${name}Request`
+    return `import { FormRequest } from '@mantiq/validation'
+
+export class ${className} extends FormRequest {
+  override authorize(): boolean {
+    return true
+  }
+
+  override rules(): Record<string, string> {
+    return {
+      //
+    }
+  }
+}
+`
+  }
+}

package/src/commands/MakeRuleCommand.ts

@@ -0,0 +1,38 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeRuleCommand extends GeneratorCommand {
+  override name = 'make:rule'
+  override description = 'Create a new validation rule'
+  override usage = 'make:rule <name>'
+
+  override directory() { return 'app/Rules' }
+  override suffix() { return 'Rule' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    const className = `${name}Rule`
+    const ruleName = this.toRuleName(name)
+    return `import type { ValidationRule } from '@mantiq/validation'
+
+export const ${ruleName}: ValidationRule = {
+  name: '${ruleName}',
+
+  validate(value: unknown, args: string[], field: string): boolean | string {
+    // Return true if valid, or a string error message if invalid
+    return true
+  },
+}
+
+export class ${className} {
+  /** Register this rule with the validator */
+  static rule(): ValidationRule {
+    return ${ruleName}
+  }
+}
+`
+  }
+
+  private toRuleName(name: string): string {
+    return name.charAt(0).toLowerCase() + name.slice(1)
+  }
+}

package/src/commands/MakeSeederCommand.ts

@@ -0,0 +1,22 @@
+import { GeneratorCommand } from './GeneratorCommand.ts'
+import type { ParsedArgs } from '../Parser.ts'
+
+export class MakeSeederCommand extends GeneratorCommand {
+  override name = 'make:seeder'
+  override description = 'Create a new seeder class'
+  override usage = 'make:seeder <name>'
+
+  override directory() { return 'database/seeders' }
+  override suffix() { return 'Seeder' }
+
+  override stub(name: string, _args: ParsedArgs): string {
+    return `import { Seeder } from '@mantiq/database'
+
+export default class ${name}Seeder extends Seeder {
+  override async run() {
+    // TODO: seed data
+  }
+}
+`
+  }
+}

package/src/commands/MakeTestCommand.ts

@@ -0,0 +1,69 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { existsSync, mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+export class MakeTestCommand extends Command {
+  override name = 'make:test'
+  override description = 'Create a new test file'
+  override usage = 'make:test <name> [--unit]'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    const rawName = args.args[0]
+    if (!rawName) {
+      this.io.error('Please provide a test name. Usage: make:test <name>')
+      return 1
+    }
+
+    const isUnit = !!args.flags['unit']
+    const subDir = isUnit ? 'unit' : 'feature'
+    const className = this.toClassName(rawName)
+    const fileName = `${className}.test.ts`
+    const dir = `${process.cwd()}/tests/${subDir}`
+    const filePath = `${dir}/${fileName}`
+
+    if (existsSync(filePath)) {
+      this.io.error(`${fileName} already exists.`)
+      return 1
+    }
+
+    mkdirSync(dirname(filePath), { recursive: true })
+
+    const content = isUnit
+      ? this.unitStub(className)
+      : this.featureStub(className)
+
+    await Bun.write(filePath, content)
+    this.io.success(`Created tests/${subDir}/${fileName}`)
+    return 0
+  }
+
+  private unitStub(name: string): string {
+    return `import { describe, test, expect } from 'bun:test'
+
+describe('${name}', () => {
+  test('example', () => {
+    expect(true).toBe(true)
+  })
+})
+`
+  }
+
+  private featureStub(name: string): string {
+    return `import { describe, test, expect } from 'bun:test'
+
+describe('${name}', () => {
+  test('returns a successful response', async () => {
+    const response = await fetch('http://localhost:3000/api/ping')
+    expect(response.status).toBe(200)
+  })
+})
+`
+  }
+
+  private toClassName(name: string): string {
+    return name
+      .replace(/[-_]+(.)/g, (_, c: string) => c.toUpperCase())
+      .replace(/^(.)/, (_, c: string) => c.toUpperCase())
+  }
+}

package/src/commands/MigrateCommand.ts

@@ -0,0 +1,33 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { Migrator } from '@mantiq/database'
+import { getManager } from '@mantiq/database'
+
+export class MigrateCommand extends Command {
+  override name = 'migrate'
+  override description = 'Run pending database migrations'
+
+  override async handle(_args: ParsedArgs): Promise<number> {
+    const connection = getManager().connection()
+    const migrationsPath = this.resolveMigrationsPath()
+    const migrator = new Migrator(connection, { migrationsPath })
+
+    this.io.info('Running migrations...')
+    const ran = await migrator.run()
+
+    if (ran.length === 0) {
+      this.io.success('Nothing to migrate.')
+    } else {
+      for (const name of ran) {
+        this.io.twoColumn(`  ${this.io.green('DONE')}`, name, 8)
+      }
+      this.io.newLine()
+      this.io.success(`Ran ${ran.length} migration${ran.length > 1 ? 's' : ''}.`)
+    }
+    return 0
+  }
+
+  protected resolveMigrationsPath(): string {
+    return `${process.cwd()}/database/migrations`
+  }
+}

package/src/commands/MigrateFreshCommand.ts

@@ -0,0 +1,47 @@
+import { Command } from '../Command.ts'
+import type { ParsedArgs } from '../Parser.ts'
+import { Migrator } from '@mantiq/database'
+import { getManager } from '@mantiq/database'
+
+export class MigrateFreshCommand extends Command {
+  override name = 'migrate:fresh'
+  override description = 'Drop all tables and re-run all migrations'
+
+  override async handle(args: ParsedArgs): Promise<number> {
+    if (!args.flags['force'] && process.env['APP_ENV'] === 'production') {
+      this.io.error('Use --force to run in production.')
+      return 1
+    }
+
+    const connection = getManager().connection()
+    const migrator = new Migrator(connection, { migrationsPath: `${process.cwd()}/database/migrations` })
+
+    this.io.warn('Dropping all tables...')
+    const ran = await migrator.fresh()
+
+    for (const name of ran) {
+      this.io.twoColumn(`  ${this.io.green('DONE')}`, name, 8)
+    }
+    this.io.newLine()
+    this.io.success(`Fresh migration complete — ${ran.length} migration${ran.length > 1 ? 's' : ''} ran.`)
+
+    // Run seeder if --seed flag
+    if (args.flags['seed']) {
+      this.io.info('Seeding...')
+      try {
+        const seederPath = `${process.cwd()}/database/seeders/DatabaseSeeder.ts`
+        const mod = await import(seederPath)
+        const SeederClass = mod.default
+        const seeder = new SeederClass()
+        seeder.setConnection(connection)
+        await seeder.run()
+        this.io.success('Database seeded.')
+      } catch (e: any) {
+        this.io.error(`Seeding failed: ${e.message}`)
+        return 1
+      }
+    }
+
+    return 0
+  }
+}