@neupgroup/mapper 1.4.3 → 1.5.0

package/dist/adapters/api-adapter.d.ts

@@ -35,6 +35,7 @@ export declare class APIAdapter implements DbAdapter {
     updateDocument(collectionName: string, docId: string, data: DocumentData): Promise<void>;
     deleteDocument(collectionName: string, docId: string): Promise<void>;
     request(method: string, endpoint: string, data?: any, customHeaders?: Record<string, string | string[]>): Promise<any>;
+    raw(query: string, params?: any[]): Promise<any>;
 }
 /**
  * Factory function to create API adapter

package/dist/adapters/api-adapter.js

@@ -168,6 +168,10 @@ export class APIAdapter {
             headers: customHeaders,
         });
     }
+    async raw(query, params) {
+        // API adapter raw could be a generic request or just return null
+        return null;
+    }
 }
 /**
  * Factory function to create API adapter

package/dist/adapters/mongodb-adapter.d.ts

@@ -49,6 +49,7 @@ export declare class MongoDBAdapter implements DbAdapter {
      * Get collection statistics
      */
     getStats(collectionName: string): Promise<any>;
+    raw(query: string, params?: any[]): Promise<any>;
 }
 /**
  * Factory function to create MongoDB adapter

package/dist/adapters/mongodb-adapter.js

@@ -218,6 +218,19 @@ export class MongoDBAdapter {
         const collection = this.db.collection(collectionName);
         return await collection.stats();
     }
+    async raw(query, params) {
+        await this.ensureConnected();
+        try {
+            // Try to parse query as a command object if it's a string
+            const command = typeof query === 'string' ? JSON.parse(query) : query;
+            return await this.db.command(command);
+        }
+        catch (e) {
+            // For migrations, if it's not JSON, we might not be able to do much
+            // but we can at least return the database object for custom logic if params are provided
+            return this.db;
+        }
+    }
 }
 /**
  * Factory function to create MongoDB adapter

package/dist/cli/migrate.js

@@ -10,6 +10,27 @@ if (!fs.existsSync(indexFilePath)) {
     process.exit(0);
 }
 async function run() {
+    // Load connections
+    const connectionDir = path.resolve(process.cwd(), 'src/connection');
+    if (fs.existsSync(connectionDir)) {
+        const { StaticMapper } = await import('../fluent-mapper.js');
+        const connFiles = fs.readdirSync(connectionDir).filter(f => f.endsWith('.ts'));
+        for (const file of connFiles) {
+            const name = file.replace('.ts', '');
+            const filePath = path.resolve(connectionDir, file);
+            try {
+                const mod = await import('file://' + filePath);
+                const config = mod.config;
+                if (config) {
+                    console.log(`Loading connection: ${name}`);
+                    StaticMapper.makeConnection(name, config.type, config);
+                }
+            }
+            catch (e) {
+                console.warn(`Failed to load connection ${name}: ${e.message}`);
+            }
+        }
+    }
     const content = fs.readFileSync(indexFilePath, 'utf-8');
     const matchMigrations = content.match(/migrations = \[(.*?)\]/s);
     const matchCompleted = content.match(/completed = \[(.*?)\]/s);

package/dist/migrator.d.ts

@@ -17,9 +17,13 @@ export declare class ColumnBuilder {
 export declare class TableMigrator {
     private name;
     private columns;
+    private connectionName;
     constructor(name: string);
+    useConnection(name: string): this;
     addColumn(name: string): ColumnBuilder;
     getColumns(): any[];
+    private getAdapter;
+    private generateCreateSql;
     exec(): Promise<void>;
     drop(): Promise<void>;
     dropColumn(columnName: string): Promise<void>;

package/dist/migrator.js

@@ -56,6 +56,11 @@ export class TableMigrator {
     constructor(name) {
         this.name = name;
         this.columns = [];
+        this.connectionName = 'default';
+    }
+    useConnection(name) {
+        this.connectionName = name;
+        return this;
     }
     addColumn(name) {
         const col = new ColumnBuilder(name);
@@ -65,28 +70,78 @@ export class TableMigrator {
     getColumns() {
         return this.columns.map(c => c.getDefinition());
     }
+    async getAdapter() {
+        const { StaticMapper } = await import('./fluent-mapper.js');
+        try {
+            const conn = StaticMapper.connection(this.connectionName);
+            // Accessing internal mapper instance safely
+            const adapter = conn.mapper.getConnections().getAdapter(this.connectionName);
+            const config = conn.mapper.getConnections().get(this.connectionName);
+            return { adapter, config };
+        }
+        catch (e) {
+            console.error(`Failed to get adapter for connection: ${this.connectionName}`);
+            return { adapter: null, config: null };
+        }
+    }
+    generateCreateSql(type) {
+        const columns = this.getColumns();
+        let sql = `CREATE TABLE IF NOT EXISTS \`${this.name}\` (\n`;
+        const columnDefs = columns.map(col => {
+            let def = `  \`${col.name}\` `;
+            // Map types
+            let dbType = 'VARCHAR(255)';
+            if (col.type === 'int')
+                dbType = 'INT';
+            else if (col.type === 'number')
+                dbType = 'DECIMAL(10,2)';
+            else if (col.type === 'boolean')
+                dbType = 'TINYINT(1)';
+            else if (col.type === 'date')
+                dbType = 'DATETIME';
+            def += dbType;
+            if (col.notNull)
+                def += ' NOT NULL';
+            if (col.isPrimary)
+                def += ' PRIMARY KEY';
+            if (col.autoIncrement) {
+                if (type === 'mysql')
+                    def += ' AUTO_INCREMENT';
+                else if (type === 'sqlite')
+                    def += ' AUTOINCREMENT';
+                else if (type === 'sql')
+                    def += ' SERIAL'; // Postgres handled differently usually but okay for simple
+            }
+            if (col.defaultValue !== undefined) {
+                def += ` DEFAULT ${typeof col.defaultValue === 'string' ? `'${col.defaultValue}'` : col.defaultValue}`;
+            }
+            if (col.isUnique && !col.isPrimary)
+                def += ' UNIQUE';
+            return def;
+        });
+        sql += columnDefs.join(',\n');
+        // Foreign keys
+        columns.filter(c => c.foreignKey).forEach(c => {
+            sql += `,\n  FOREIGN KEY (\`${c.name}\`) REFERENCES \`${c.foreignKey.table}\`(\`${c.foreignKey.column}\`)`;
+        });
+        sql += '\n)';
+        if (type === 'postgres' || type === 'sql') {
+            // Replace backticks with double quotes for Postgres
+            sql = sql.replace(/`/g, '"');
+        }
+        return sql;
+    }
     async exec() {
-        // This is where we trigger schema file update
+        // 1. Update schema file
         const fs = await import('fs');
         const path = await import('path');
         const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+        if (!fs.existsSync(schemasDir))
+            fs.mkdirSync(schemasDir, { recursive: true });
         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' : ''} }`;
+            return `        { name: '${col.name}', type: '${col.type}'${col.isPrimary ? ', isPrimary: true' : ''}${col.autoIncrement ? ', autoIncrement: true' : ''}${col.notNull ? ', notNull: true' : ''}${col.isUnique ? ', isUnique: true' : ''}${col.defaultValue !== undefined ? `, defaultValue: ${JSON.stringify(col.defaultValue)}` : ''} }`;
         }).join(',\n');
         const schemaContent = `
 export const ${this.name} = {
@@ -97,51 +152,107 @@ ${fieldsContent}
     updatableFields: [${columns.filter(c => !c.autoIncrement && !c.isPrimary).map(c => `'${c.name}'`).join(', ')}],
     massUpdateable: false,
     massDeletable: false,
-    usesConnection: 'default'
+    usesConnection: '${this.connectionName}'
 };
 `;
         fs.writeFileSync(schemaFilePath, schemaContent.trim() + '\n');
-        console.log(`Updated schema: ${schemaFilePath}`);
+        console.log(`Updated schema file: ${schemaFilePath}`);
+        // 2. Execute on Database
+        const { adapter, config } = await this.getAdapter();
+        if (adapter && config) {
+            console.log(`Executing migration on database (${config.type})...`);
+            const sql = this.generateCreateSql(config.type);
+            try {
+                await adapter.raw(sql);
+                console.log(`Successfully executed SQL on database.`);
+            }
+            catch (err) {
+                console.error(`Database execution failed: ${err.message}`);
+                throw err;
+            }
+        }
+        else {
+            console.log(`Skipping database execution: Connection "${this.connectionName}" not found or adapter not attached.`);
+        }
     }
     async drop() {
+        // 1. Remove schema file
         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}`);
+            console.log(`Deleted schema file: ${schemaFilePath}`);
+        }
+        // 2. Execute on Database
+        const { adapter, config } = await this.getAdapter();
+        if (adapter && config) {
+            const quote = (config.type === 'postgres' || config.type === 'sql') ? '"' : '`';
+            const sql = `DROP TABLE IF EXISTS ${quote}${this.name}${quote}`;
+            try {
+                await adapter.raw(sql);
+                console.log(`Dropped table ${this.name} from database.`);
+            }
+            catch (err) {
+                console.error(`Failed to drop table from database: ${err.message}`);
+            }
         }
     }
     async dropColumn(columnName) {
+        // 1. Update schema file
         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}`);
+            console.log(`Dropped column ${columnName} from schema file.`);
+        }
+        // 2. Execute on Database
+        const { adapter, config } = await this.getAdapter();
+        if (adapter && config) {
+            const quote = (config.type === 'postgres' || config.type === 'sql') ? '"' : '`';
+            const sql = `ALTER TABLE ${quote}${this.name}${quote} DROP COLUMN ${quote}${columnName}${quote}`;
+            try {
+                await adapter.raw(sql);
+                console.log(`Dropped column ${columnName} from database.`);
+            }
+            catch (err) {
+                console.error(`Failed to drop column from database: ${err.message}`);
+            }
         }
     }
     async dropUnique(columnName) {
+        // 1. Update schema file
         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}`);
+            console.log(`Dropped unique constraint from ${columnName} in schema file.`);
+        }
+        // 2. Execute on Database (Database specific, simplified for MySQL)
+        const { adapter, config } = await this.getAdapter();
+        if (adapter && config && config.type === 'mysql') {
+            try {
+                await adapter.raw(`ALTER TABLE \`${this.name}\` DROP INDEX \`${columnName}\``);
+                console.log(`Dropped unique index ${columnName} from database.`);
+            }
+            catch (err) {
+                console.error(`Failed to drop unique index from database: ${err.message}`);
+            }
         }
     }
     async dropPrimaryKey(columnName) {
+        // 1. Update schema file
         const fs = await import('fs');
         const path = await import('path');
         const schemasDir = path.resolve(process.cwd(), 'src/schemas');
@@ -151,7 +262,19 @@ ${fieldsContent}
             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}`);
+            console.log(`Dropped primary key constraint from ${columnName} in schema file.`);
+        }
+        // 2. Execute on Database
+        const { adapter, config } = await this.getAdapter();
+        if (adapter && config) {
+            const quote = (config.type === 'postgres' || config.type === 'sql') ? '"' : '`';
+            try {
+                await adapter.raw(`ALTER TABLE ${quote}${this.name}${quote} DROP PRIMARY KEY`);
+                console.log(`Dropped primary key from database.`);
+            }
+            catch (err) {
+                console.warn(`Failed to drop primary key: ${err.message}. (Some databases require more complex PK drops)`);
+            }
         }
     }
 }

package/dist/orm/types.d.ts

@@ -22,4 +22,5 @@ export interface DbAdapter {
     addDocument(collectionName: string, data: DocumentData): Promise<string>;
     updateDocument(collectionName: string, docId: string, data: DocumentData): Promise<void>;
     deleteDocument(collectionName: string, docId: string): Promise<void>;
+    raw(query: string, params?: any[]): Promise<any>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neupgroup/mapper",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "Neup.Mapper core library for schema and mapping utilities",
   "type": "module",
   "main": "dist/index.js",