@quatrain/cli 1.1.8

package/src/commands/generate/config.ts

@@ -0,0 +1,130 @@
+import inquirer from 'inquirer'
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Triggers an interactive CLI prompt to generate a root `quatrain.json` configuration file.
+ * Automatically configures backend, authentication, queueing, and storage parameters.
+ */
+export async function generateConfig() {
+   console.log('--- Initializing Quatrain Configuration ---\n')
+
+   const answers = await inquirer.prompt([
+      {
+         type: 'list',
+         name: 'backend',
+         message: 'Which Backend system to use?',
+         choices: [
+            { name: 'SQLite', value: 'sqlite' },
+            { name: 'PostgreSQL', value: 'postgres' },
+            { name: 'Firestore', value: 'firestore' },
+            { name: 'None (Mock)', value: 'mock' },
+         ],
+      },
+      {
+         type: 'list',
+         name: 'auth',
+         message: 'Which Authentication provider to use?',
+         choices: [
+            { name: 'Supabase', value: 'supabase' },
+            { name: 'Firebase', value: 'firebase' },
+            { name: 'None', value: 'none' },
+         ],
+      },
+      {
+         type: 'list',
+         name: 'queue',
+         message: 'Which Queue system to use?',
+         choices: [
+            { name: 'AMQP (RabbitMQ)', value: 'amqp' },
+            { name: 'AWS SQS', value: 'sqs' },
+            { name: 'GCP Pub/Sub', value: 'gcp' },
+            { name: 'None', value: 'none' },
+         ],
+      },
+      {
+         type: 'list',
+         name: 'storage',
+         message: 'Which Storage provider to use?',
+         choices: [
+            { name: 'AWS S3', value: 's3' },
+            { name: 'Supabase Storage', value: 'supabase' },
+            { name: 'Firebase Storage', value: 'firebase' },
+            { name: 'None', value: 'none' },
+         ],
+      }
+   ])
+
+   const config: any = {}
+
+   // --- Backend Config ---
+   if (answers.backend !== 'mock') {
+      config.backend = {
+         adapter: answers.backend === 'sqlite' ? 'SQLiteAdapter' : 
+                  answers.backend === 'postgres' ? 'PostgresAdapter' : 'FirestoreAdapter',
+         package: `@quatrain/backend-${answers.backend}`,
+         config: {}
+      }
+      if (answers.backend === 'sqlite') {
+         config.backend.config.database = 'env(DB_PATH)'
+      } else if (answers.backend === 'postgres') {
+         config.backend.config.host = 'env(PG_HOST)'
+         config.backend.config.port = 'env(PG_PORT)'
+         config.backend.config.user = 'env(PG_USER)'
+         config.backend.config.password = 'env(PG_PWD)'
+         config.backend.config.database = 'env(PG_DB)'
+      }
+   }
+
+   // --- Auth Config ---
+   if (answers.auth !== 'none') {
+      config.auth = {
+         adapter: answers.auth === 'supabase' ? 'SupabaseAuthAdapter' : 'FirebaseAuthAdapter',
+         package: `@quatrain/auth-${answers.auth}`,
+         config: {}
+      }
+      if (answers.auth === 'supabase') {
+         config.auth.config.supabaseUrl = 'env(SUPABASE_URL)'
+         config.auth.config.supabaseKey = 'env(SUPABASE_KEY)'
+      }
+   }
+
+   // --- Queue Config ---
+   if (answers.queue !== 'none') {
+      const adapterMap: Record<string, string> = { amqp: 'AmqpQueueAdapter', sqs: 'SqsAdapter', gcp: 'GcpPubSubAdapter' }
+      const pkgMap: Record<string, string> = { amqp: 'amqp', sqs: 'aws', gcp: 'gcp' }
+      config.queue = {
+         adapter: adapterMap[answers.queue as string],
+         package: `@quatrain/queue-${pkgMap[answers.queue as string]}`,
+         config: {}
+      }
+      if (answers.queue === 'amqp') {
+         config.queue.config.host = 'env(MQ_HOST)'
+         config.queue.config.port = 'env(MQ_PORT)'
+         config.queue.config.user = 'env(MQ_USER)'
+         config.queue.config.password = 'env(MQ_PWD)'
+      }
+   }
+
+   // --- Storage Config ---
+   if (answers.storage !== 'none') {
+      const adapterMap: Record<string, string> = { s3: 'S3StorageAdapter', supabase: 'SupabaseStorageAdapter', firebase: 'FirebaseStorageAdapter' }
+      config.storage = {
+         adapter: adapterMap[answers.storage as string],
+         package: `@quatrain/storage-${answers.storage}`,
+         config: {}
+      }
+      if (answers.storage === 's3') {
+         config.storage.config.accesskey = 'env(S3_ACCESS_KEY)'
+         config.storage.config.secret = 'env(S3_SECRET_KEY)'
+         config.storage.config.region = 'env(S3_REGION)'
+         config.storage.config.bucket = 'env(S3_BUCKET)'
+      }
+   }
+
+   const outputPath = path.resolve(process.cwd(), 'quatrain.json')
+   fs.writeFileSync(outputPath, JSON.stringify(config, null, 3), 'utf8')
+
+   console.log(`\n✅ Configuration file successfully generated at: ${outputPath}`)
+   console.log('Tokens formatted as "env(...)" will automatically be replaced by the Bootloader with runtime environment variables.\n')
+}

package/src/commands/generate/migration.ts

@@ -0,0 +1,49 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Creates a new timestamp-prefixed migration script scaffold within the local `migrations/` folder.
+ * 
+ * @param name - The semantic suffix name of the migration.
+ */
+export async function generateMigration(name: string) {
+   if (!name) {
+      console.error('Error: Migration name is required.')
+      process.exit(1)
+   }
+
+   // Format YYYYMMDDHHmmss
+   const now = new Date()
+   const timestamp = now.getFullYear().toString() +
+      (now.getMonth() + 1).toString().padStart(2, '0') +
+      now.getDate().toString().padStart(2, '0') +
+      now.getHours().toString().padStart(2, '0') +
+      now.getMinutes().toString().padStart(2, '0') +
+      now.getSeconds().toString().padStart(2, '0')
+
+   const filename = `${timestamp}_${name}.ts`
+   const migrationsDir = path.resolve(process.cwd(), 'migrations')
+
+   if (!fs.existsSync(migrationsDir)) {
+      fs.mkdirSync(migrationsDir, { recursive: true })
+   }
+
+   const filePath = path.join(migrationsDir, filename)
+
+   const template = `import { Backend } from '@quatrain/backend'
+
+export const up = async () => {
+   // const db = await Backend.getBackend('default')._connect()
+   // await db.exec(\`CREATE TABLE IF NOT EXISTS example (id TEXT PRIMARY KEY);\`)
+}
+
+export const down = async () => {
+   // const db = await Backend.getBackend('default')._connect()
+   // await db.exec(\`DROP TABLE IF EXISTS example;\`)
+}
+`
+
+   fs.writeFileSync(filePath, template, 'utf8')
+
+   console.log(`\n✅ Migration file successfully generated at: ${filePath}\n`)
+}

package/src/commands/generate/scaffold.ts

@@ -0,0 +1,86 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Bootstraps a completely new, production-ready Quatrain project structure.
+ * Creates monorepo configuration files (package.json, tsconfig.json) and standard directories.
+ * 
+ * @param projectName - The name and path of the target project directory.
+ */
+export async function generateScaffold(projectName: string) {
+   const projectDir = path.resolve(process.cwd(), projectName)
+
+   if (fs.existsSync(projectDir)) {
+      console.error(`Error: The directory "${projectName}" already exists.`)
+      process.exit(1)
+   }
+
+   console.log(`\n🚀 Initializing Quatrain project: ${projectName}...\n`)
+
+   // 1. Create base directories
+   const dirs = ['apps', 'data', 'config', 'packages', 'migrations']
+   dirs.forEach(dir => {
+      const dirPath = path.join(projectDir, dir)
+      fs.mkdirSync(dirPath, { recursive: true })
+      // Add a .gitkeep file for git
+      fs.writeFileSync(path.join(dirPath, '.gitkeep'), '', 'utf8')
+      console.log(`📁 Directory created: ${dir}/`)
+   })
+
+   // 2. Create base package.json (Monorepo)
+   const packageJson = {
+      name: projectName.toLowerCase(),
+      version: "1.0.0",
+      private: true,
+      workspaces: [
+         "apps/*",
+         "packages/*"
+      ],
+      scripts: {
+         "dev": "yarn workspaces foreach -p run dev",
+         "build": "yarn workspaces foreach -ptA run build"
+      },
+      dependencies: {
+         "@quatrain/core": "^1.0.0",
+         "@quatrain/app": "^1.0.0"
+      }
+   }
+   
+   fs.writeFileSync(
+      path.join(projectDir, 'package.json'),
+      JSON.stringify(packageJson, null, 3),
+      'utf8'
+   )
+   console.log(`📄 File created: package.json`)
+
+   // 3. Create root tsconfig.json
+   const tsconfigJson = {
+      compilerOptions: {
+         target: "ES2022",
+         module: "NodeNext",
+         moduleResolution: "NodeNext",
+         lib: ["ES2022"],
+         strict: true,
+         esModuleInterop: true,
+         skipLibCheck: true,
+         forceConsistentCasingInFileNames: true,
+         baseUrl: ".",
+         paths: {
+            "@app/*": ["apps/*/src/index.ts"],
+            "@packages/*": ["packages/*/src/index.ts"]
+         }
+      },
+      exclude: ["node_modules", "**/dist", "**/lib"]
+   }
+
+   fs.writeFileSync(
+      path.join(projectDir, 'tsconfig.json'),
+      JSON.stringify(tsconfigJson, null, 3),
+      'utf8'
+   )
+   console.log(`📄 File created: tsconfig.json`)
+
+   // 4. Final instructions
+   console.log(`\n✅ Project "${projectName}" successfully scaffolded!`)
+   console.log(`\nTo get started:\n  cd ${projectName}\n  yarn install\n`)
+}

package/src/index.ts

@@ -0,0 +1,59 @@
+import inquirer from 'inquirer';
+
+export { inquirer };
+
+/**
+ * Ask a yes/no question to the user.
+ */
+export async function askConfirm(message: string, defaultVal = true): Promise<boolean> {
+  const result = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'value',
+      message,
+      default: defaultVal,
+    },
+  ]);
+  return result.value;
+}
+
+/**
+ * Prompt the user for textual input.
+ */
+export async function askInput(message: string, defaultVal?: string): Promise<string> {
+  const result = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'value',
+      message,
+      default: defaultVal,
+    },
+  ]);
+  return result.value;
+}
+
+/**
+ * Prompt the user to select from a list of choices.
+ */
+export async function askChoice<T = string>(
+  message: string,
+  choices: (string | { name: string; value: T })[]
+): Promise<T> {
+  const result = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'value',
+      message,
+      choices,
+    },
+  ]);
+  return result.value;
+}
+
+import { Command } from 'commander';
+
+/**
+ * Custom Commander subclass to wrap Command functionality inside @quatrain/cli.
+ */
+export class CliCommand extends Command {}
+