@neupgroup/mapper 1.4.0 → 1.4.2

package/dist/cli/create-migration.js

@@ -61,3 +61,40 @@ export const ${tableName} = {
 else {
     console.log(`Schema file already exists: ${schemaFilePath}`);
 }
+// Update migrations index
+const indexFilePath = path.join(migrationDir, 'index.ts');
+let migrations = [];
+let completed = [];
+let currentVersion = -1;
+if (fs.existsSync(indexFilePath)) {
+    const content = fs.readFileSync(indexFilePath, 'utf-8');
+    const matchMigrations = content.match(/migrations = \[(.*?)\]/s);
+    if (matchMigrations) {
+        migrations = matchMigrations[1].split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+    }
+    const matchCompleted = content.match(/completed = \[(.*?)\]/s);
+    if (matchCompleted) {
+        completed = matchCompleted[1].split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+    }
+    const matchVersion = content.match(/currentVersion = (.*?);/);
+    if (matchVersion) {
+        currentVersion = parseInt(matchVersion[1]);
+    }
+}
+const migrationName = fileName.replace('.ts', '');
+if (!migrations.includes(migrationName)) {
+    migrations.push(migrationName);
+}
+const indexContent = `
+export const migrations = [
+${migrations.map(m => `    '${m}'`).join(',\n')}
+];
+
+export const completed = [
+${completed.map(m => `    '${m}'`).join(',\n')}
+];
+
+export const currentVersion = ${currentVersion};
+`;
+fs.writeFileSync(indexFilePath, indexContent.trim() + '\n');
+console.log(`Updated migration index: ${indexFilePath}`);

package/dist/cli/migrate.d.ts

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

package/dist/cli/migrate.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+const args = process.argv.slice(2);
+const command = args[0] || 'up'; // 'up' or 'down'
+const migrationDir = path.resolve(process.cwd(), 'src/migration');
+const indexFilePath = path.join(migrationDir, 'index.ts');
+if (!fs.existsSync(indexFilePath)) {
+    console.log('No migrations found.');
+    process.exit(0);
+}
+async function run() {
+    const content = fs.readFileSync(indexFilePath, 'utf-8');
+    const matchMigrations = content.match(/migrations = \[(.*?)\]/s);
+    const matchCompleted = content.match(/completed = \[(.*?)\]/s);
+    const matchVersion = content.match(/currentVersion = (.*?);/);
+    if (!matchMigrations) {
+        console.log('No migrations list found in index.ts');
+        return;
+    }
+    const migrations = matchMigrations[1].split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+    let completed = matchCompleted ? matchCompleted[1].split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean) : [];
+    let currentVersion = matchVersion ? parseInt(matchVersion[1]) : -1;
+    if (command === 'up') {
+        const pending = migrations.filter(m => !completed.includes(m));
+        if (pending.length === 0) {
+            console.log('No pending migrations.');
+            return;
+        }
+        console.log(`Found ${pending.length} pending migrations.`);
+        for (const m of pending) {
+            console.log(`Running migration UP: ${m}...`);
+            const filePath = path.join(migrationDir, `${m}.ts`);
+            const absolutePath = path.resolve(filePath);
+            const mod = await import('file://' + absolutePath);
+            if (mod.up) {
+                await mod.up();
+                completed.push(m);
+                currentVersion = migrations.indexOf(m);
+                console.log(`Completed UP: ${m}`);
+            }
+            else {
+                console.error(`Migration ${m} does not have an up() function.`);
+                break;
+            }
+        }
+    }
+    else if (command === 'down') {
+        if (completed.length === 0) {
+            console.log('No migrations to roll back.');
+            return;
+        }
+        const lastMigrationName = completed[completed.length - 1];
+        console.log(`Rolling back migration: ${lastMigrationName}...`);
+        const filePath = path.join(migrationDir, `${lastMigrationName}.ts`);
+        const absolutePath = path.resolve(filePath);
+        const mod = await import('file://' + absolutePath);
+        if (mod.down) {
+            await mod.down();
+            completed.pop();
+            currentVersion = completed.length > 0 ? migrations.indexOf(completed[completed.length - 1]) : -1;
+            console.log(`Completed DOWN: ${lastMigrationName}`);
+        }
+        else {
+            console.error(`Migration ${lastMigrationName} does not have a down() function.`);
+        }
+    }
+    // Update index.ts
+    const indexContent = `
+export const migrations = [
+${migrations.map(m => `    '${m}'`).join(',\n')}
+];
+
+export const completed = [
+${completed.map(m => `    '${m}'`).join(',\n')}
+];
+
+export const currentVersion = ${currentVersion};
+`;
+    fs.writeFileSync(indexFilePath, indexContent.trim() + '\n');
+    console.log(`Migration runner finished. Current version: ${currentVersion}`);
+}
+run().catch(err => {
+    console.error('Migration failed:', err);
+    process.exit(1);
+});

package/dist/migrator.d.ts

@@ -19,4 +19,10 @@ export declare class TableMigrator {
     private columns;
     constructor(name: string);
     addColumn(name: string): ColumnBuilder;
+    getColumns(): any[];
+    exec(): Promise<void>;
+    drop(): Promise<void>;
+    dropColumn(columnName: string): Promise<void>;
+    dropUnique(columnName: string): Promise<void>;
+    dropPrimaryKey(columnName: string): Promise<void>;
 }

package/dist/migrator.js

@@ -62,4 +62,96 @@ export class TableMigrator {
         this.columns.push(col);
         return col;
     }
+    getColumns() {
+        return this.columns.map(c => c.getDefinition());
+    }
+    async exec() {
+        // This is where we trigger schema file update
+        const fs = await import('fs');
+        const path = await import('path');
+        const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+        const schemaFilePath = path.join(schemasDir, `${this.name}.ts`);
+        const columns = this.getColumns();
+        let existingSchema = {
+            fields: [],
+            insertableFields: [],
+            updatableFields: [],
+            massUpdateable: false,
+            massDeletable: false,
+            usesConnection: 'default'
+        };
+        if (fs.existsSync(schemaFilePath)) {
+            // Very basic parser/updater. 
+            // Real implementation would use AST, but for now we'll do simple string replacement or overwrite if it's the first time.
+            // For the sake of this demo, we will generate the fields array.
+        }
+        const fieldsContent = columns.map(col => {
+            return `        { name: '${col.name}', type: '${col.type}'${col.isPrimary ? ', isPrimary: true' : ''}${col.autoIncrement ? ', autoIncrement: true' : ''}${col.notNull ? ', notNull: true' : ''}${col.isUnique ? ', isUnique: true' : ''} }`;
+        }).join(',\n');
+        const schemaContent = `
+export const ${this.name} = {
+    fields: [
+${fieldsContent}
+    ],
+    insertableFields: [${columns.filter(c => !c.autoIncrement).map(c => `'${c.name}'`).join(', ')}],
+    updatableFields: [${columns.filter(c => !c.autoIncrement && !c.isPrimary).map(c => `'${c.name}'`).join(', ')}],
+    massUpdateable: false,
+    massDeletable: false,
+    usesConnection: 'default'
+};
+`;
+        fs.writeFileSync(schemaFilePath, schemaContent.trim() + '\n');
+        console.log(`Updated schema: ${schemaFilePath}`);
+    }
+    async drop() {
+        const fs = await import('fs');
+        const path = await import('path');
+        const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+        const schemaFilePath = path.join(schemasDir, `${this.name}.ts`);
+        if (fs.existsSync(schemaFilePath)) {
+            fs.unlinkSync(schemaFilePath);
+            console.log(`Deleted schema: ${schemaFilePath}`);
+        }
+    }
+    async dropColumn(columnName) {
+        const fs = await import('fs');
+        const path = await import('path');
+        const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+        const schemaFilePath = path.join(schemasDir, `${this.name}.ts`);
+        if (fs.existsSync(schemaFilePath)) {
+            // Very simple implementation: filter out the line with the column
+            const content = fs.readFileSync(schemaFilePath, 'utf-8');
+            const lines = content.split('\n');
+            const filteredLines = lines.filter(line => !line.includes(`name: '${columnName}'`));
+            fs.writeFileSync(schemaFilePath, filteredLines.join('\n'));
+            console.log(`Dropped column ${columnName} from schema ${this.name}`);
+        }
+    }
+    async dropUnique(columnName) {
+        const fs = await import('fs');
+        const path = await import('path');
+        const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+        const schemaFilePath = path.join(schemasDir, `${this.name}.ts`);
+        if (fs.existsSync(schemaFilePath)) {
+            let content = fs.readFileSync(schemaFilePath, 'utf-8');
+            // Remove ", isUnique: true" from the line containing the column
+            const regex = new RegExp(`({ name: '${columnName}', .*?), isUnique: true(.*})`);
+            content = content.replace(regex, '$1$2');
+            fs.writeFileSync(schemaFilePath, content);
+            console.log(`Dropped unique constraint from ${columnName} in schema ${this.name}`);
+        }
+    }
+    async dropPrimaryKey(columnName) {
+        const fs = await import('fs');
+        const path = await import('path');
+        const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+        const schemaFilePath = path.join(schemasDir, `${this.name}.ts`);
+        if (fs.existsSync(schemaFilePath)) {
+            let content = fs.readFileSync(schemaFilePath, 'utf-8');
+            const regex = new RegExp(`({ name: '${columnName}', .*?), isPrimary: true(.*})`);
+            content = content.replace(regex, '$1$2');
+            fs.writeFileSync(schemaFilePath, content);
+            console.log(`Dropped primary key constraint from ${columnName} in schema ${this.name}`);
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neupgroup/mapper",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "Neup.Mapper core library for schema and mapping utilities",
   "type": "module",
   "main": "dist/index.js",
@@ -8,7 +8,10 @@
   "types": "dist/index.d.ts",
   "bin": {
     "create-migration": "dist/cli/create-migration.js",
-    "create-connection": "dist/cli/create-connection.js"
+    "create-connection": "dist/cli/create-connection.js",
+    "migrate": "dist/cli/migrate.js",
+    "migrate-up": "dist/cli/migrate.js",
+    "migrate-down": "dist/cli/migrate.js"
   },
   "files": [
     "dist"
@@ -17,7 +20,10 @@
   "scripts": {
     "build": "tsc -p ./tsconfig.json",
     "create-migration": "npx tsx src/cli/create-migration.ts",
-    "create-connection": "npx tsx src/cli/create-connection.ts"
+    "create-connection": "npx tsx src/cli/create-connection.ts",
+    "migrate": "npx tsx src/cli/migrate.ts",
+    "migrate-up": "npx tsx src/cli/migrate.ts up",
+    "migrate-down": "npx tsx src/cli/migrate.ts down"
   },
   "publishConfig": {
     "access": "public"