@neupgroup/mapper 1.6.0 → 1.6.2

package/dist/cli/create-connection.js

@@ -20,44 +20,53 @@ Example:
     process.exit(0);
 }
 const connectionName = args[0];
-const type = args[1] || 'api';
+const type = (args[1] || 'api').toLowerCase();
 if (!connectionName) {
     console.error('Error: Connection name is required.');
     console.log('Usage: npm run create-connection <connectionName> [type]');
     process.exit(1);
 }
-const connectionDir = path.resolve(process.cwd(), 'src/connection');
-if (!fs.existsSync(connectionDir))
-    fs.mkdirSync(connectionDir, { recursive: true });
-const filePath = path.join(connectionDir, `${connectionName}.ts`);
-let configTemplate = '';
-if (type === 'mysql') {
-    configTemplate = `
-    type: 'mysql',
-    host: 'localhost',
-    port: 3306,
-    user: 'root',
-    password: '',
-    database: '${connectionName}'
-`;
+const configDir = path.resolve(process.cwd(), 'src/config');
+if (!fs.existsSync(configDir))
+    fs.mkdirSync(configDir, { recursive: true });
+const filePath = path.join(configDir, `${connectionName}.ts`);
+let template = {
+    name: connectionName,
+    type: type
+};
+if (type === 'mysql' || type === 'postgres') {
+    template = {
+        ...template,
+        host: '',
+        port: type === 'mysql' ? 3306 : 5432,
+        user: '',
+        password: '',
+        database: ''
+    };
 }
 else if (type === 'sqlite') {
-    configTemplate = `
-    type: 'sqlite',
-    filename: './${connectionName}.db'
-`;
+    template = {
+        ...template,
+        filename: ''
+    };
 }
-else {
-    configTemplate = `
-    type: '${type}',
-    // Add configuration here
-`;
+else if (type === 'mongodb') {
+    template = {
+        ...template,
+        url: ''
+    };
 }
-const fileContent = `import { ConnectionConfig } from '@neupgroup/mapper';
-
-export const config: ConnectionConfig = {
-${configTemplate}
-};
+else if (type === 'api') {
+    template = {
+        ...template,
+        baseUrl: '',
+        headers: {}
+    };
+}
+const fileContent = `
+export const connections = [
+    ${JSON.stringify(template, null, 4)}
+];
 `;
-fs.writeFileSync(filePath, fileContent.trim());
-console.log(`Created connection file: ${filePath} `);
+fs.writeFileSync(filePath, fileContent.trim() + '\n');
+console.log(`Created connection configuration: ${filePath}`);

package/dist/cli/create-migration.js

@@ -43,18 +43,37 @@ const filePath = path.join(migrationDir, fileName);
 const fileContent = `
 import { Mapper, TableMigrator } from '@neupgroup/mapper';
 
+export const usesConnection = 'default';
+
 export async function up() {
-    // const table = Mapper.schemas().table('${tableName}');
-    // table.useConnection('default');
-    // table.addColumn('id').type('int').isPrimary().autoIncrement();
-    // ... add more columns
-    // await table.exec();
-    console.log('Migrating up: ${tableName}');
+    const schema = Mapper.schema().table('${tableName}');
+    schema.useConnection(usesConnection);
+
+    /**
+     * CASE 1: CREATE SCHEMA (Requires .exec())
+     * Use this when defining a new schema. addColumn calls are batched.
+     */
+    // schema.addColumn('id').type('int').isPrimary().autoIncrement();
+    // schema.addColumn('name').type('string').notNull();
+    // await schema.exec(); 
+
+    /**
+     * CASE 2: ALTER SCHEMA (Queued actions)
+     * These methods are queued and only execute when you call .exec()
+     */
+    // schema.dropColumn('old_field');
+    // schema.dropUnique('field_name');
+    // await schema.exec();
 }
 
 export async function down() {
-    // Drop table or revert changes
-    console.log('Migrating down: ${tableName}');
+    /**
+     * DROP SCHEMA (Immediate action)
+     * This will drop the schema from the DB and delete the local schema file.
+     */
+    const schema = Mapper.schema().table('${tableName}');
+    schema.useConnection(usesConnection);
+    await schema.dropTable().exec();
 }
 `;
 fs.writeFileSync(filePath, fileContent.trim());

package/dist/cli/migrate.js

@@ -7,20 +7,23 @@ if (args.includes('--help') || args.includes('-h')) {
 Usage: npm run migrate [command]
 
 Commands:
-  up       Run all pending migrations (default)
-  down     Roll back the last completed migration
+  (none)     Run all pending migrations to reach top level
+  up         Migrate one level up
+  down       Migrate one level down (rollback)
+  refresh    Roll back all migrations and run them all again
 
 Options:
   --help, -h   Show this help message
 
 Description:
   This command will look for migration files in src/migration,
-  load database connections from src/connection, and execute
-  pending changes on your database while updating local schema files.
+  load database connections from src/config and src/connection,
+  and execute pending changes on your database while updating local schema files.
 `);
     process.exit(0);
 }
-const command = args[0] || 'up'; // 'up' or 'down'
+// Commands: '' (all up), 'up' (1 up), 'down' (1 down), 'refresh' (all down then all up)
+const command = args[0] || 'all';
 const migrationDir = path.resolve(process.cwd(), 'src/migration');
 const indexFilePath = path.join(migrationDir, 'index.ts');
 if (!fs.existsSync(indexFilePath)) {
@@ -29,23 +32,31 @@ if (!fs.existsSync(indexFilePath)) {
 }
 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);
+    const dirs = [
+        path.resolve(process.cwd(), 'src/connection'),
+        path.resolve(process.cwd(), 'src/config')
+    ];
+    for (const dir of dirs) {
+        if (fs.existsSync(dir)) {
+            const { StaticMapper } = await import('../fluent-mapper.js');
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.ts'));
+            for (const file of files) {
+                const name = file.replace('.ts', '');
+                const filePath = path.resolve(dir, file);
+                try {
+                    const mod = await import('file://' + filePath);
+                    if (mod.connections && Array.isArray(mod.connections)) {
+                        for (const conn of mod.connections) {
+                            StaticMapper.makeConnection(conn.name, conn.type, conn);
+                        }
+                    }
+                    else if (mod.config) {
+                        StaticMapper.makeConnection(name, mod.config.type, mod.config);
+                    }
+                }
+                catch (e) {
+                    console.warn(`Failed to load connection from ${file}: ${e.message}`);
                 }
-            }
-            catch (e) {
-                console.warn(`Failed to load connection ${name}: ${e.message}`);
             }
         }
     }
@@ -60,51 +71,75 @@ async function run() {
     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') {
+    // Helper functions
+    const runUp = async (migrationName) => {
+        console.log(`Running migration UP: ${migrationName}...`);
+        const filePath = path.join(migrationDir, `${migrationName}.ts`);
+        const mod = await import('file://' + path.resolve(filePath));
+        if (mod.up) {
+            await mod.up();
+            completed.push(migrationName);
+            currentVersion = migrations.indexOf(migrationName);
+            console.log(`Completed UP: ${migrationName}`);
+            return true;
+        }
+        else {
+            console.error(`Migration ${migrationName} does not have an up() function.`);
+            return false;
+        }
+    };
+    const runDown = async (migrationName) => {
+        console.log(`Rolling back migration DOWN: ${migrationName}...`);
+        const filePath = path.join(migrationDir, `${migrationName}.ts`);
+        const mod = await import('file://' + path.resolve(filePath));
+        if (mod.down) {
+            await mod.down();
+            completed.pop();
+            currentVersion = completed.length > 0 ? migrations.indexOf(completed[completed.length - 1]) : -1;
+            console.log(`Completed DOWN: ${migrationName}`);
+            return true;
+        }
+        else {
+            console.error(`Migration ${migrationName} does not have a down() function.`);
+            return false;
+        }
+    };
+    if (command === 'all' || 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 {
+            const toRun = command === 'up' ? [pending[0]] : pending;
+            for (const m of toRun) {
+                if (!(await runUp(m)))
+                    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.`);
+            const lastMigrationName = completed[completed.length - 1];
+            await runDown(lastMigrationName);
+        }
+    }
+    else if (command === 'refresh') {
+        console.log('Refreshing migrations (Rollback all then run all)...');
+        // 1. Rollback all
+        const toRollback = [...completed].reverse();
+        for (const m of toRollback) {
+            await runDown(m);
+        }
+        // 2. Run all
+        for (const m of migrations) {
+            if (!(await runUp(m)))
+                break;
         }
     }
-    // Update index.ts
+    // Save state back to index.ts
     const indexContent = `
 export const migrations = [
 ${migrations.map(m => `    '${m}'`).join(',\n')}
@@ -117,7 +152,7 @@ ${completed.map(m => `    '${m}'`).join(',\n')}
 export const currentVersion = ${currentVersion};
 `;
     fs.writeFileSync(indexFilePath, indexContent.trim() + '\n');
-    console.log(`Migration runner finished. Current version: ${currentVersion}`);
+    console.log(`Migration runner finished. Current version index: ${currentVersion}`);
 }
 run().catch(err => {
     console.error('Migration failed:', err);

package/dist/discovery.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Automatically discovers and registers connections and schemas
+ * from the standard directory structure.
+ */
+export declare function discover(): Promise<void>;

package/dist/discovery.js

@@ -0,0 +1,79 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { StaticMapper } from './fluent-mapper.js';
+/**
+ * Automatically discovers and registers connections and schemas
+ * from the standard directory structure.
+ */
+export async function discover() {
+    // 1. Discover Connections
+    const configDirs = [
+        path.resolve(process.cwd(), 'src/config'),
+        path.resolve(process.cwd(), 'src/connection')
+    ];
+    for (const dir of configDirs) {
+        if (fs.existsSync(dir)) {
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+            for (const file of files) {
+                const filePath = path.resolve(dir, file);
+                try {
+                    const mod = await import('file://' + filePath);
+                    // Support connections array
+                    if (mod.connections && Array.isArray(mod.connections)) {
+                        for (const conn of mod.connections) {
+                            StaticMapper.makeConnection(conn.name, conn.type, conn);
+                        }
+                    }
+                    // Support legacy config object
+                    else if (mod.config) {
+                        const name = file.split('.')[0];
+                        StaticMapper.makeConnection(name, mod.config.type, mod.config);
+                    }
+                }
+                catch (e) {
+                    // console.warn(`Discovery: Failed to load connection from ${file}`);
+                }
+            }
+        }
+    }
+    // 2. Discover Schemas
+    const schemasDir = path.resolve(process.cwd(), 'src/schemas');
+    if (fs.existsSync(schemasDir)) {
+        const files = fs.readdirSync(schemasDir).filter(f => f.endsWith('.ts') || f.endsWith('.js'));
+        for (const file of files) {
+            const schemaName = file.split('.')[0];
+            const filePath = path.resolve(schemasDir, file);
+            try {
+                const mod = await import('file://' + filePath);
+                // Look for the exported schema object (usually named after the file/table)
+                const schemaDef = mod[schemaName] || mod.schema || mod.default;
+                if (schemaDef && schemaDef.fields) {
+                    const connectionName = schemaDef.usesConnection || 'default';
+                    StaticMapper.connection(connectionName)
+                        .schema(schemaName)
+                        .collection(schemaDef.collectionName || schemaName)
+                        .structure(schemaDef.fields);
+                    // Apply options if present
+                    if (schemaDef.insertableFields || schemaDef.updatableFields) {
+                        const manager = StaticMapper.getFluentMapper().mapper.getSchemaManager();
+                        const schema = manager.create(schemaName); // This might throw if exists, should use update
+                        // ... existing StaticMapper already handles this in discovery pattern? 
+                        // Actually StaticMapper.schemas(schemaName) works.
+                        const wrapper = StaticMapper.schemas(schemaName);
+                        if (schemaDef.insertableFields)
+                            wrapper.insertableFields = schemaDef.insertableFields;
+                        if (schemaDef.updatableFields)
+                            wrapper.updatableFields = schemaDef.updatableFields;
+                        if (schemaDef.massUpdateable !== undefined)
+                            wrapper.massEditAllowed = schemaDef.massUpdateable;
+                        if (schemaDef.massDeletable !== undefined)
+                            wrapper.massDeleteAllowed = schemaDef.massDeletable;
+                    }
+                }
+            }
+            catch (e) {
+                // console.warn(`Discovery: Failed to load schema from ${file}`);
+            }
+        }
+    }
+}

package/dist/errors.js

@@ -40,7 +40,7 @@ export class SchemaExistingError extends MapperError {
 }
 export class SchemaMissingError extends MapperError {
     constructor(name) {
-        super(`Unknown schema '${name}'.`, 'SCHEMA_UNKNOWN', `Ensure you have defined the schema '${name}' using 'Mapper.schema().create("${name}")...'`);
+        super(`Unknown schema '${name}'.`, 'SCHEMA_UNKNOWN', `The schema '${name}' is not registered. Ensure you have run migrations, called 'Mapper.discover()', or defined it manually using 'Mapper.schema().create("${name}")'.`);
     }
 }
 export class SchemaConfigurationError extends MapperError {

package/dist/fluent-mapper.d.ts

@@ -1,10 +1,28 @@
-import { SchemaManager, ConnectionType } from './index.js';
+import { Connections, SchemaManager, type SchemaDef, ConnectionType } from './index.js';
 import { TableMigrator } from './migrator.js';
 export declare class FluentQueryBuilder {
     private mapper;
     private schemaName;
     private query;
-    constructor(mapper: any, schemaName: string);
+    private _migrator?;
+    constructor(mapper: any, schemaName: string, connectionName?: string);
+    getDef(): SchemaDef;
+    set fields(config: any);
+    set insertableFields(val: string[]);
+    set updatableFields(val: string[]);
+    set deleteType(val: 'softDelete' | 'hardDelete');
+    set massDeleteAllowed(val: boolean);
+    set massEditAllowed(val: boolean);
+    structure(config: any): this;
+    collection(collectionName: string): this;
+    get migrator(): TableMigrator;
+    useConnection(name: string): this;
+    addColumn(name: string): import("./migrator.js").ColumnBuilder;
+    selectColumn(name: string): import("./migrator.js").ColumnBuilder;
+    dropColumn(name: string): this;
+    drop(): this;
+    exec(): Promise<void>;
+    dropTable(): Promise<void>;
     where(field: string, value: any, operator?: string): this;
     whereComplex(raw: string): this;
     limit(n: number): this;
@@ -69,11 +87,11 @@ export declare class FluentConnectionSelector {
     private mapper;
     private connectionName;
     constructor(mapper: any, connectionName: string);
-    schema(schemaName: string): FluentSchemaBuilder;
+    schema(schemaName: string): FluentQueryBuilder;
+    schemas(schemaName: string): FluentQueryBuilder;
     query(schemaName: string): FluentQueryBuilder;
     table(tableName: string): FluentQueryBuilder;
     collection(collectionName: string): FluentQueryBuilder;
-    schemas(schemaName: string): FluentSchemaWrapper;
     path(path: string): FluentApiRequestBuilder;
     header(key: string | Record<string, string | string[]>, value?: string | string[]): FluentApiRequestBuilder;
     headers(headers: Record<string, string> | any[]): FluentApiRequestBuilder;
@@ -87,6 +105,8 @@ export declare class FluentMapper {
     private mapper;
     constructor(mapper: any);
     query(schemaName: string): FluentQueryBuilder;
+    schema(name: string): FluentQueryBuilder;
+    table(name: string): FluentQueryBuilder;
     makeConnection(name: string, type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     useConnection(connectionName: string): FluentConnectionSelector;
     connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
@@ -96,6 +116,7 @@ export declare class FluentMapper {
     add(schemaName: string, data: Record<string, any>): Promise<any>;
     update(schemaName: string, filters: Record<string, any>, data: Record<string, any>): Promise<void>;
     delete(schemaName: string, filters: Record<string, any>): Promise<void>;
+    dropTable(name: string): Promise<void>;
 }
 export declare class StaticMapper {
     private static instance;
@@ -103,36 +124,27 @@ export declare class StaticMapper {
     static makeConnection(name: string, type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     static makeTempConnection(type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     static query(schemaName: string): FluentQueryBuilder;
+    static schema(name: string): FluentQueryBuilder;
+    static schema(): SchemaManagerWrapper;
+    static table(name: string): FluentQueryBuilder;
     static connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
     static useConnection(connectionName: string): FluentConnectionSelector;
-    static schemas(name?: string): FluentSchemaWrapper | SchemaManagerWrapper;
+    static schemas(name?: string): any;
     static get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
     static getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
     static add(schemaName: string, data: Record<string, any>): Promise<any>;
     static update(schemaName: string, filters: Record<string, any>, data: Record<string, any>): Promise<void>;
     static delete(schemaName: string, filters: Record<string, any>): Promise<void>;
+    static dropTable(name: string): Promise<void>;
+    static getConnections(): Connections;
+    static discover(): Promise<void>;
 }
 export declare const Mapper: typeof StaticMapper;
 export default Mapper;
-export declare class FluentSchemaWrapper {
-    private manager;
-    private name;
-    private connectionName?;
-    constructor(manager: SchemaManager, name: string, connectionName?: string | undefined);
-    private getDef;
-    set fields(config: any);
-    set insertableFields(val: string[]);
-    set updatableFields(val: string[]);
-    set deleteType(val: 'softDelete' | 'hardDelete');
-    set massDeleteAllowed(val: boolean);
-    set massEditAllowed(val: boolean);
-    get(...fields: string[]): any;
-    limit(n: number): FluentQueryBuilder;
-    offset(n: number): FluentQueryBuilder;
-    insert(data: Record<string, any>): Promise<any>;
-}
 export declare class SchemaManagerWrapper {
     private manager;
     constructor(manager: SchemaManager);
     table(name: string): TableMigrator;
+    schema(name: string): TableMigrator;
+    dropTable(name: string): Promise<void>;
 }