mango-orm 1.0.2 → 1.1.1

package/README.md

@@ -900,7 +900,88 @@ Schema type builder for column definitions.
 
 ---
 
-## 🔐 Security
+## � Database Migrations
+
+Mango includes a powerful migration system to version and manage database schema changes with color-coded console feedback.
+
+### Creating Migration Files
+
+Generate a new migration file:
+
+```bash
+npm run migration:generate create_users_table
+```
+
+This creates a timestamped migration file like `migrations/1734912000000_create_users_table.ts`:
+
+```typescript
+import { IMangoMigrationType, Mango } from "mango-orm";
+
+export const create_users_table: IMangoMigrationType = {
+    name: "create_users_table",
+    timestamp: 1734912000000,
+    
+    up: async (mango: Mango) => {
+        await mango.createTable("users", {
+            id: mango.types().int().primaryKey().autoIncrement(),
+            username: mango.types().varchar(255).notNull().unique(),
+            email: mango.types().varchar(255).notNull(),
+            created_at: mango.types().timeStamp().default("CURRENT_TIMESTAMP")
+        });
+        console.log("✓ Users table created");
+    },
+    
+    down: async (mango: Mango) => {
+        await mango.dropTable("users");
+        console.log("✓ Users table dropped");
+    }
+};
+```
+
+### Running Migrations
+
+Create a migration runner script:
+
+```typescript
+import { Mango, MangoMigration } from "mango-orm";
+import { create_users_table } from "./migrations/1734912000000_create_users_table.js";
+
+const mango = new Mango();
+await mango.connect({ /* config */ });
+
+const migration = new MangoMigration(mango);
+migration.add(create_users_table);
+
+// Check migration status
+await migration.status();
+
+// Run next pending migration
+await migration.migrateUp();
+
+// Run all pending migrations
+await migration.migrateUpToLatest();
+
+// Rollback last migration
+await migration.migrateDown();
+
+// Rollback all migrations
+await migration.migrateDownToOldest();
+```
+
+### Migration Console Output
+
+```
+=== Migration Status ===
+
+  ✓ Executed: create_users_table
+  ⦿ Pending:  add_posts_table
+
+Total: 2 | Executed: 1 | Pending: 1
+```
+
+---
+
+## �🔐 Security
 
 Mango ORM is built with security in mind:
 
@@ -982,9 +1063,9 @@ await mango.connect({
 
 While Mango is functional, some features are still in development:
 
+- ✅ **Migration System**: Database schema migrations with version tracking
 - ⏳ **No Transaction Support**: BEGIN/COMMIT/ROLLBACK not fully implemented
 - ⏳ **Limited JOIN Support**: Basic joins work but complex joins need testing
-- ⏳ **No Migration System**: Schema versioning and migrations coming soon
 - ⏳ **No Relations**: ORM-style relations (hasMany, belongsTo) not yet available
 - ⏳ **No Query Caching**: Results are not cached (may add in future)
 - ⏳ **No Connection Retry**: Failed connections don't auto-retry
@@ -994,17 +1075,17 @@ While Mango is functional, some features are still in development:
 
 ## 🗺️ Roadmap
 
-### Short Term (v0.3.0)
+### Short Term (v1.1.0)
 - [x] WHERE clause support
 - [x] UPDATE operations
 - [x] DELETE operations
 - [x] Comprehensive documentation
+- [x] Migration system with CLI
 - [ ] Transaction support (BEGIN, COMMIT, ROLLBACK)
 - [ ] Better error messages with stack traces
 - [ ] Connection pool configuration options
 
-### Medium Term (v0.4.0)
-- [ ] Migration system
+### Medium Term (v1.2.0)
 - [ ] Seed data functionality
 - [ ] Query result caching
 - [ ] Batch operation optimization

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+import { generateMangoMigrationFile } from "./migration-cli.js";
+const command = process.argv[2];
+const migrationName = process.argv[3];
+const outputDir = process.argv[4] || './migrations';
+console.log(chalk.bold.cyan('\n🥭 Mango Migration CLI\n'));
+switch (command) {
+    case "generate":
+    case "g":
+        if (!migrationName) {
+            console.log(chalk.red("✗") + " Migration name is required\n");
+            showHelp();
+            process.exit(1);
+        }
+        generateMangoMigrationFile(migrationName, outputDir);
+        break;
+    case "help":
+    case "--help":
+    case "-h":
+        showHelp();
+        break;
+    default:
+        console.log(chalk.red("✗") + ` Unknown command: ${command}\n`);
+        showHelp();
+        process.exit(1);
+}
+function showHelp() {
+    console.log(chalk.bold("Usage:"));
+    console.log("  npm run migration:generate <name> [outputDir]\n");
+    console.log(chalk.bold("Commands:"));
+    console.log(chalk.cyan("  generate, g") + "    Generate a new migration file");
+    console.log(chalk.cyan("  help, -h") + "        Show this help message\n");
+    console.log(chalk.bold("Examples:"));
+    console.log("  npm run migration:generate create_users_table");
+    console.log("  npm run migration:generate add_email_column");
+    console.log("  npm run migration:generate create_posts_table ./db/migrations\n");
+}

package/dist/src/mango.d.ts

@@ -274,4 +274,29 @@ declare class Mango {
     haveTable(name: string): boolean;
     customQuery<Type>(query: string, supplies: any[]): Promise<Type>;
 }
+interface IMangoMigrationType {
+    name: string;
+    timestamp: number;
+    up: (mango: Mango) => Promise<void>;
+    down: (mango: Mango) => Promise<void>;
+}
+declare class MangoMigration {
+    private mango;
+    private mango_migration_table_name;
+    private migrations;
+    initialize(): Promise<void>;
+    constructor(mango: Mango);
+    addOneMigrationToDB(migration: IMangoMigrationType): Promise<void>;
+    addManyMigrationToDB(migration: IMangoMigrationType[]): Promise<void>;
+    deleteOneMigrationFromDB(migration: IMangoMigrationType): Promise<void>;
+    deleteManyMigrationFromDB(migrations: IMangoMigrationType[]): Promise<void>;
+    add(migration: IMangoMigrationType): MangoMigration;
+    getExecutedMigrations(): Promise<string[]>;
+    migrateUp(): Promise<void>;
+    migrateUpToLatest(): Promise<void>;
+    migrateDown(): Promise<void>;
+    migrateDownToOldest(): Promise<void>;
+    status(): Promise<void>;
+}
 export { Mango, MangoType, MangoTable };
+export { MangoMigration, IMangoMigrationType };

package/dist/src/mango.js

@@ -2,6 +2,7 @@
   Requires sql for connection
 */
 import * as sql from "mysql";
+import chalk from "chalk";
 /**
  * MangoType - Schema builder for defining table column types
  * Provides chainable methods to build SQL column definitions
@@ -676,7 +677,7 @@ class Mango {
         return [...this.tables];
     }
     async createTable(name, fields) {
-        this.query.query = "CREATE TABLE " + name + "( \n";
+        this.query.query = "CREATE TABLE " + name.toLowerCase() + "( \n";
         const fieldEnteries = Object.entries(fields);
         let table = new MangoTable(this.db, name.toLowerCase(), [
             ...fieldEnteries.map(([key, value], index) => {
@@ -690,6 +691,7 @@ class Mango {
             }
         });
         this.query.query += "\n)";
+        // console.log(this.query.query);
         await this.query.execute();
         this.query.query = "";
         this.tables.push(table);
@@ -719,4 +721,213 @@ class Mango {
         return this.query.customQuery(query, supplies);
     }
 }
+class MangoMigration {
+    async initialize() {
+        try {
+            if (!this.mango.haveTable(this.mango_migration_table_name)) {
+                await this.mango.createTable(this.mango_migration_table_name, {
+                    id: this.mango.types().int().primaryKey().notNull().autoIncrement(),
+                    name: this.mango.types().text().notNull().unique(),
+                    timestamp: this.mango.types().bigInt().notNull(),
+                    executed_at: this.mango.types().bigInt().notNull(),
+                });
+            }
+        }
+        catch (error) {
+            console.log("Error encountered while initializing mangoMigration");
+            throw error;
+        }
+    }
+    constructor(mango) {
+        this.mango_migration_table_name = "mango_migrations";
+        this.migrations = [];
+        this.mango = mango;
+        this.initialize();
+    }
+    async addOneMigrationToDB(migration) {
+        try {
+            await this.mango.selectTable(this.mango_migration_table_name).insertOne({
+                name: migration.name,
+                timestamp: migration.timestamp,
+                executed_at: Date.now()
+            }).execute();
+            console.log(chalk.dim(`   → Recorded in database`));
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Error:`) + ` Failed to record migration in DB:`, error.message);
+            throw error;
+        }
+    }
+    async addManyMigrationToDB(migration) {
+        try {
+            await this.mango.selectTable(this.mango_migration_table_name).insertMany(["name", "timestamp", "executed_at"], migration.map((m) => ([
+                m.name,
+                m.timestamp,
+                Date.now()
+            ]))).execute();
+            console.log(chalk.dim(`   → Recorded ${migration.length} migrations in database`));
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Error:`) + ` Failed to record migrations in DB:`, error.message);
+            throw error;
+        }
+    }
+    async deleteOneMigrationFromDB(migration) {
+        try {
+            await this.mango.selectTable(this.mango_migration_table_name).delete().where("name", "=", migration.name).execute();
+            console.log(chalk.dim(`   → Removed from database`));
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Error:`) + ` Failed to delete migration from DB:`, error);
+            throw error;
+        }
+    }
+    async deleteManyMigrationFromDB(migrations) {
+        const names = [...migrations].map((m) => m.name);
+        try {
+            await this.mango.selectTable(this.mango_migration_table_name).delete().whereIn("name", names).execute();
+            console.log(chalk.dim(`   → Removed ${migrations.length} migrations from database`));
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Error:`) + ` Failed to delete migrations from DB:`, error.message);
+            throw error;
+        }
+    }
+    add(migration) {
+        this.migrations.push(migration);
+        return this;
+    }
+    async getExecutedMigrations() {
+        const migration = await this.mango.selectTable(this.mango_migration_table_name).selectAll().orderBy("timestamp").sort(1).execute();
+        return migration.map((m) => m.name);
+    }
+    async migrateUp() {
+        await this.initialize();
+        const executed = await this.getExecutedMigrations();
+        const sorted = [...this.migrations].sort((a, b) => a.timestamp - b.timestamp);
+        const pending = sorted.find(m => !executed.includes(m.name));
+        if (!pending) {
+            console.log(chalk.yellow("⚠") + " No pending migrations to execute");
+            return;
+        }
+        console.log(chalk.cyan("→") + ` Running migration: ${chalk.bold(pending.name)}`);
+        try {
+            await pending.up(this.mango);
+            console.log(chalk.green("✓") + ` Migration completed: ${chalk.bold(pending.name)}`);
+            await this.addOneMigrationToDB(pending);
+        }
+        catch (error) {
+            console.error(chalk.red("✗") + ` Migration failed: ${chalk.bold(pending.name)}`);
+            console.error(chalk.dim(`   Error: ${error.message}`));
+            throw error;
+        }
+    }
+    async migrateUpToLatest() {
+        await this.initialize();
+        const executed = await this.getExecutedMigrations();
+        const sorted = [...this.migrations].sort((a, b) => a.timestamp - b.timestamp);
+        const pending = sorted.filter(m => !executed.includes(m.name));
+        if (pending.length === 0) {
+            console.log(chalk.yellow("⚠") + " No pending migrations to execute");
+            return;
+        }
+        console.log(chalk.cyan("→") + ` Running ${pending.length} pending migration(s)...\n`);
+        for (const migration of pending) {
+            console.log(chalk.cyan("  →") + ` ${chalk.bold(migration.name)}`);
+            try {
+                await migration.up(this.mango);
+                await this.addOneMigrationToDB(migration);
+                console.log(chalk.green("  ✓") + ` Completed\n`);
+            }
+            catch (error) {
+                console.error(chalk.red("  ✗") + ` Failed`);
+                console.error(chalk.dim(`     Error: ${error.message}`));
+                throw error;
+            }
+        }
+        console.log(chalk.green("✓") + ` All migrations completed successfully`);
+    }
+    async migrateDown() {
+        await this.initialize();
+        const executed = await this.getExecutedMigrations();
+        const sorted = [...this.migrations].sort((a, b) => a.timestamp - b.timestamp);
+        if (executed.length === 0) {
+            console.log(chalk.yellow("⚠") + " No migrations to rollback");
+            return;
+        }
+        const oldMigrationName = executed[executed.length - 1];
+        const migration = sorted.find(m => m.name === oldMigrationName);
+        if (!migration) {
+            throw new Error(`Migration not found: ${oldMigrationName}`);
+        }
+        console.log(chalk.magenta("←") + ` Rolling back: ${chalk.bold(migration.name)}`);
+        try {
+            await migration.down(this.mango);
+            await this.deleteOneMigrationFromDB(migration);
+            console.log(chalk.green("✓") + ` Rollback completed`);
+        }
+        catch (error) {
+            console.error(chalk.red("✗") + ` Rollback failed: ${chalk.bold(migration.name)}`);
+            console.error(chalk.dim(`   Error: ${error.message}`));
+            throw error;
+        }
+        return;
+    }
+    async migrateDownToOldest() {
+        await this.initialize();
+        const executed = await this.getExecutedMigrations();
+        const sorted = [...this.migrations].sort((a, b) => a.timestamp - b.timestamp);
+        if (executed.length === 0) {
+            console.log(chalk.yellow("⚠") + " No migrations to rollback");
+            return;
+        }
+        console.log(chalk.magenta("←") + ` Rolling back ${executed.length} migration(s)...\n`);
+        for (const migrationName of executed.reverse()) {
+            const migration = sorted.find(migration => migration.name === migrationName);
+            if (!migration) {
+                throw new Error(`Migration not found: ${migrationName}`);
+            }
+            console.log(chalk.magenta("  ←") + ` ${chalk.bold(migration.name)}`);
+            try {
+                await migration.down(this.mango);
+                await this.deleteOneMigrationFromDB(migration);
+                console.log(chalk.green("  ✓") + ` Completed\n`);
+            }
+            catch (error) {
+                console.error(chalk.red("  ✗") + ` Failed`);
+                console.error(chalk.dim(`     Error: ${error.message}`));
+                throw error;
+            }
+        }
+        console.log(chalk.green("✓") + ` All migrations rolled back successfully`);
+        return;
+    }
+    async status() {
+        await this.initialize();
+        const executedMigrations = await this.getExecutedMigrations();
+        const sortedMigrations = [...this.migrations].sort((a, b) => a.timestamp - b.timestamp);
+        console.log(chalk.bold.cyan("\n=== Migration Status ==="));
+        console.log();
+        if (sortedMigrations.length === 0) {
+            console.log(chalk.dim("  No migrations registered"));
+        }
+        else {
+            for (const migration of sortedMigrations) {
+                if (executedMigrations.includes(migration.name)) {
+                    console.log(chalk.green("  ✓ Executed:") + ` ${chalk.cyan(migration.name)}`);
+                }
+                else {
+                    console.log(chalk.yellow("  ⧗ Pending: ") + ` ${chalk.cyan(migration.name)}`);
+                }
+            }
+        }
+        console.log();
+        console.log(chalk.bold("Total:") + ` ${this.migrations.length} | ` +
+            chalk.green("Executed:") + ` ${executedMigrations.length} | ` +
+            chalk.yellow("Pending:") + ` ${this.migrations.length - executedMigrations.length}`);
+        console.log();
+    }
+}
+;
 export { Mango, MangoType, MangoTable };
+export { MangoMigration };

package/dist/src/migration-cli.d.ts

@@ -0,0 +1,2 @@
+declare const generateMangoMigrationFile: (migrationFilename: string, outputDir?: string) => void;
+export { generateMangoMigrationFile };

package/dist/src/migration-cli.js

@@ -0,0 +1,40 @@
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+const generateMangoMigrationFile = (migrationFilename, outputDir = './migrations') => {
+    const timestamp = Date.now();
+    const filepath = path.join(outputDir, `${timestamp}_${migrationFilename}.ts`);
+    const template = `import { IMangoMigrationType, Mango } from "../src/mango.js";
+
+export const ${migrationFilename}: IMangoMigrationType = {
+    name: "${migrationFilename}",
+    timestamp: ${timestamp},
+    
+    up: async (mango: Mango) => {
+        // TODO: Write your migration code here
+        // Example:
+        // await mango.createTable("users", {
+        //     id: mango.types().int().primaryKey().autoIncrement(),
+        //     username: mango.types().varchar(255).notNull().unique(),
+        //     password: mango.types().varchar(255).notNull()
+        // });
+        
+        console.log("✓ Migration ${migrationFilename} completed");
+    },
+    
+    down: async (mango: Mango) => {
+        // TODO: Write your rollback code here
+        // Example:
+        // await mango.dropTable("users");
+        
+        console.log("✓ Rollback ${migrationFilename} completed");
+    }
+};
+`;
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(filepath, template);
+    console.log(chalk.green("✓") + ` Created migration: ${chalk.cyan(filepath)}`);
+};
+export { generateMangoMigrationFile };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "mango-orm",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "type": "module",
-  "description": "A lightweight, type-safe MySQL ORM for Node.js and TypeScript",
+  "description": "A lightweight, type-safe MySQL ORM for Node.js and TypeScript with database migrations",
   "main": "dist/src/mango.js",
   "types": "dist/src/mango.d.ts",
   "scripts": {
@@ -10,11 +10,14 @@
     "dev": "tsc --watch",
     "test": "tsc && node dist/test/test.js",
     "test:ops": "tsc && node dist/test/test-operations.js",
-    "prepublishOnly": "pnpm build"
+    "prepublishOnly": "pnpm build",
+    "migration:generate": "tsc && node dist/src/cli.js generate",
+    "migration:help": "tsc && node dist/src/cli.js help"
   },
   "files": [
     "dist/src",
-    "README.md"
+    "README.md",
+    "LICENSE"
   ],
   "keywords": [
     "mysql",
@@ -23,7 +26,12 @@
     "database",
     "sql",
     "type-safe",
-    "query-builder"
+    "query-builder",
+    "migrations",
+    "schema-management",
+    "mysql-orm",
+    "nodejs",
+    "fluent-api"
   ],
   "author": "Siddharth Karn siddharth2062.karn@gmail.com (https://github.com/devSiddharthKarn)",
   "license": "ISC",
@@ -38,6 +46,7 @@
   "packageManager": "pnpm@10.25.0",
   "dependencies": {
     "@types/mysql": "^2.15.27",
+    "chalk": "^5.6.2",
     "mysql": "^2.18.1"
   },
   "devDependencies": {