@forgebase/cli 0.0.1

package/mock-server.js

@@ -0,0 +1,39 @@
+import http from 'http';
+
+const mockSchema = {
+  users: {
+    columns: [
+      { name: 'id', dataType: 'serial', isNullable: false },
+      { name: 'email', dataType: 'varchar', isNullable: false },
+      { name: 'age', dataType: 'integer', isNullable: true },
+      { name: 'is_active', dataType: 'boolean', isNullable: false },
+      { name: 'metadata', dataType: 'jsonb', isNullable: true },
+      { name: 'created_at', dataType: 'timestamptz', isNullable: false },
+    ],
+  },
+  posts: {
+    columns: [
+      { name: 'id', dataType: 'bigserial', isNullable: false },
+      { name: 'title', dataType: 'text', isNullable: false },
+      { name: 'content', dataType: 'text', isNullable: true },
+      { name: 'author_id', dataType: 'integer', isNullable: false },
+    ],
+  },
+};
+
+const server = http.createServer((req, res) => {
+  if (req.url === '/schema') {
+    // Simulate network latency (3 seconds)
+    setTimeout(() => {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(mockSchema));
+    }, 3000);
+  } else {
+    res.writeHead(404);
+    res.end();
+  }
+});
+
+server.listen(3001, () => {
+  console.log('Mock schema server running at http://localhost:3001/schema');
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@forgebase/cli",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "description": "CLI tool for ForgeBase",
+  "main": "dist/index.js",
+  "bin": {
+    "forgebase-cli": "dist/index.js",
+    "dbcli": "dist/index.js"
+  },
+  "keywords": [
+    "forgebase",
+    "cli",
+    "database",
+    "schema"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "SOG-web",
+  "license": "MIT",
+  "dependencies": {
+    "@types/figlet": "^1.7.0",
+    "axios": "^1.11.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "figlet": "^1.10.0",
+    "inquirer": "^13.2.4",
+    "ora": "^9.3.0",
+    "prettier": "^3.6.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tslib": "^2.3.0",
+    "typescript": "5.8.2",
+    "@forgebase/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build": "pnpm clean && pnpm build:esm && pnpm build:cjs",
+    "dev": "tsc -p tsconfig.esm.json --watch",
+    "start": "node dist/index.js",
+    "test:mock-server": "node mock-server.js",
+    "test:generate": "node dist/esm/index.js database --url http://localhost:3001/schema --output test-schema.ts"
+  }
+}

package/src/commands/database.ts

@@ -0,0 +1,204 @@
+import { Command } from 'commander';
+import axios from 'axios';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as prettier from 'prettier';
+import chalk from 'chalk';
+import ora from 'ora';
+
+const KyselyTypeMapping: Record<string, string> = {
+  // Number types
+  integer: 'number',
+  int2: 'number',
+  int4: 'number',
+  int8: 'number',
+  smallint: 'number',
+  bigint: 'number',
+  real: 'number',
+  'double precision': 'number',
+  float4: 'number',
+  float8: 'number',
+  decimal: 'number',
+  numeric: 'number',
+  serial: 'number',
+  bigserial: 'number',
+
+  // String types
+  varchar: 'string',
+  char: 'string',
+  text: 'string',
+  uuid: 'string',
+  date: 'string',
+  time: 'string',
+  timetz: 'string',
+  timestamp: 'string',
+  timestamptz: 'string',
+  datetime: 'string',
+  blob: 'string',
+  varbinary: 'string',
+
+  // Boolean
+  boolean: 'boolean',
+
+  // JSON/Any
+  json: 'any',
+  jsonb: 'any',
+  binary: 'any',
+  bytea: 'any',
+};
+
+// Default mapping for unknown types
+const DEFAULT_TYPE = 'any';
+
+interface ColumnInfo {
+  name: string;
+  dataType: string;
+  isNullable: boolean;
+  hasAutoIncrement: boolean;
+}
+
+interface TableInfo {
+  columns: ColumnInfo[];
+}
+
+interface DatabaseSchema {
+  [tableName: string]: TableInfo;
+}
+
+import { showBanner, confirmAction } from '../utils/ui.js';
+
+export const databaseCommand = new Command('database')
+  .description('Database management commands')
+  .requiredOption('--url <url>', 'URL to the ForgeBase schema endpoint')
+  .requiredOption('--output <path>', 'Path to save the generated schema file')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(async (options) => {
+    showBanner(
+      'Database Schema Generator',
+      'Generates TypeScript definitions from your running database.',
+    );
+
+    const confirmed = await confirmAction(
+      `Do you want to generate the schema from ${chalk.bold(options.url)} to ${chalk.bold(options.output)}?`,
+      options.yes,
+    );
+
+    if (!confirmed) {
+      console.log(chalk.yellow('Operation cancelled.'));
+      return;
+    }
+
+    const spinner = ora('Fetching database schema...').start();
+    try {
+      // 1. Fetch Schema
+      const response = await axios.get<DatabaseSchema>(options.url);
+      const schema = response.data;
+
+      if (!schema || typeof schema !== 'object') {
+        throw new Error('Invalid schema response from server');
+      }
+
+      spinner.text = 'Generating TypeScript definitions...';
+
+      // 2. Generate TypeScript Interfaces
+      const lines: string[] = [];
+      const tableNames: string[] = [];
+
+      // Add file header
+      lines.push('/**');
+      lines.push(' * This file was auto-generated by @forgebase/cli.');
+      lines.push(' * Do not modify this file manually.');
+      lines.push(' */');
+      lines.push('');
+
+      for (const [tableName, tableInfo] of Object.entries(schema)) {
+        const interfaceName = toPascalCase(tableName);
+        tableNames.push(tableName); // Keep original table name for Schema interface keys
+
+        lines.push(`export interface ${interfaceName} {`);
+
+        for (const col of tableInfo.columns) {
+          // Map type
+          let tsType =
+            KyselyTypeMapping[col.dataType.toLowerCase()] || DEFAULT_TYPE;
+
+          // Handle nullability
+          if (col.isNullable) {
+            tsType += ' | null';
+          }
+
+          lines.push(`  ${col.name}: ${tsType};`);
+        }
+
+        lines.push('}');
+        lines.push('');
+      }
+
+      // 3. Generate Schema Interface
+      lines.push('export interface Schema {');
+      for (const tableName of tableNames) {
+        // Map table name to interface name
+        // e.g. "users" -> "users: User" (assuming User interface is generated)
+        // But commonly tables are plural, interfaces are singular/pascal.
+        // Let's use the generated interface name.
+        const interfaceName = toPascalCase(tableName);
+        lines.push(`  ${tableName}: ${interfaceName};`);
+      }
+      lines.push('}');
+      lines.push('');
+
+      // 4. Format with Prettier
+      const rawContent = lines.join('\n');
+      const formattedContent = await prettier.format(rawContent, {
+        parser: 'typescript',
+        singleQuote: true,
+      });
+
+      // 5. Write to file
+      const outputPath = path.resolve(process.cwd(), options.output);
+      const outputDir = path.dirname(outputPath);
+
+      if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+
+      fs.writeFileSync(outputPath, formattedContent);
+
+      spinner.succeed(chalk.green(`Schema generated successfully!`));
+
+      console.log('');
+      console.log(chalk.cyan('  → ') + chalk.bold('Source:   ') + options.url);
+      console.log(chalk.cyan('  → ') + chalk.bold('Output:   ') + outputPath);
+      console.log(
+        chalk.cyan('  → ') + chalk.bold('Tables:   ') + tableNames.length,
+      );
+      console.log('');
+      console.log(chalk.gray('  You can now use this schema with the SDK:'));
+      console.log(chalk.blue('  const db = new DatabaseSDK<Schema>(...);'));
+      console.log('');
+    } catch (error: any) {
+      spinner.fail(chalk.red('Failed to generate schema'));
+      console.error(chalk.red(error.message));
+      if (axios.isAxiosError(error)) {
+        console.error(
+          chalk.red(
+            `Status: ${error.response?.status} ${error.response?.statusText}`,
+          ),
+        );
+      }
+      process.exit(1);
+    }
+  });
+
+function toPascalCase(str: string): string {
+  // Handle snake_case, kebab-case, etc.
+  // e.g. user_profiles -> UserProfiles
+  return (
+    str
+      .match(/[a-z0-9]+/gi)
+      ?.map(
+        (word) => word.charAt(0).toUpperCase() + word.substr(1).toLowerCase(),
+      )
+      .join('') || str
+  );
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { databaseCommand } from './commands/database.js';
+
+const program = new Command();
+
+program
+  .name('forgebase-cli')
+  .description('CLI tool for ForgeBase')
+  .version('0.0.1');
+
+program.addCommand(databaseCommand);
+
+program.parse();

package/src/utils/ui.ts

@@ -0,0 +1,37 @@
+import figlet from 'figlet';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+export function showBanner(commandName: string, description: string) {
+  console.log('');
+  console.log(
+    chalk.hex('#FF5733')(
+      figlet.textSync('ForgeBase CLI', { horizontalLayout: 'full' }),
+    ),
+  );
+  console.log('');
+  console.log(chalk.bold.cyan(`Command: ${commandName}`));
+  console.log(chalk.gray(description));
+  console.log(chalk.gray('--------------------------------------------------'));
+  console.log('');
+}
+
+export async function confirmAction(
+  message: string,
+  skip: boolean,
+): Promise<boolean> {
+  if (skip) {
+    return true;
+  }
+
+  const { proceed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'proceed',
+      message: message,
+      default: true,
+    },
+  ]);
+
+  return proceed;
+}

package/test-schema.ts

@@ -0,0 +1,25 @@
+/**
+ * This file was auto-generated by @forgebase/cli.
+ * Do not modify this file manually.
+ */
+
+export interface Users {
+  id: number;
+  email: string;
+  age: number | null;
+  is_active: boolean;
+  metadata: any | null;
+  created_at: string;
+}
+
+export interface Posts {
+  id: number;
+  title: string;
+  content: string | null;
+  author_id: number;
+}
+
+export interface Schema {
+  users: Users;
+  posts: Posts;
+}

package/tsconfig.cjs.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "module": "CommonJS",
+    "target": "ES2020",
+    "moduleResolution": "Node"
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "module": "ESNext",
+    "target": "ES2020",
+    "moduleResolution": "Bundler"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "extends": "@forgebase/typescript-config/base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "composite": true,
+    "noImplicitAny": false,
+    "target": "ES2020",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"]
+  },
+  "include": ["src"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "jest.config.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.ts"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}