@neupgroup/mapper 1.6.2 → 1.7.1

package/dist/builders/base-dispatcher.d.ts

@@ -0,0 +1,10 @@
+import { SelectBuilder, InsertBuilder, UpdateBuilder, DeleteBuilder } from './dml-builders.js';
+export declare class BaseDispatcher {
+    private mapper;
+    private target;
+    constructor(mapper: any, target: string);
+    select(fields?: string[]): SelectBuilder;
+    insert(data: any): InsertBuilder;
+    update(data: any): UpdateBuilder;
+    delete(): DeleteBuilder;
+}

package/dist/builders/base-dispatcher.js

@@ -0,0 +1,19 @@
+import { SelectBuilder, InsertBuilder, UpdateBuilder, DeleteBuilder } from './dml-builders.js';
+export class BaseDispatcher {
+    constructor(mapper, target) {
+        this.mapper = mapper;
+        this.target = target;
+    }
+    select(fields = []) {
+        return new SelectBuilder(this.mapper, this.target, fields);
+    }
+    insert(data) {
+        return new InsertBuilder(this.mapper, this.target, data);
+    }
+    update(data) {
+        return new UpdateBuilder(this.mapper, this.target, data);
+    }
+    delete() {
+        return new DeleteBuilder(this.mapper, this.target);
+    }
+}

package/dist/builders/clause-builder.d.ts

@@ -0,0 +1,11 @@
+export declare class ClauseBuilder {
+    protected mapper: any;
+    protected target: string;
+    protected query: any;
+    constructor(mapper: any, target: string);
+    where(field: string, value: any, operator?: string): this;
+    whereComplex(raw: string): this;
+    whereRaw(raw: string): this;
+    limit(n: number): this;
+    offset(n: number): this;
+}

package/dist/builders/clause-builder.js

@@ -0,0 +1,27 @@
+export class ClauseBuilder {
+    constructor(mapper, target) {
+        this.mapper = mapper;
+        this.target = target;
+        // Initialize the underlying query object from the mapper core
+        this.query = mapper.use(target);
+    }
+    where(field, value, operator) {
+        this.query.where(field, value, operator);
+        return this;
+    }
+    whereComplex(raw) {
+        this.query.whereComplex(raw);
+        return this;
+    }
+    whereRaw(raw) {
+        return this.whereComplex(raw);
+    }
+    limit(n) {
+        this.query.limit(n);
+        return this;
+    }
+    offset(n) {
+        this.query.offset(n);
+        return this;
+    }
+}

package/dist/builders/dml-builders.d.ts

@@ -0,0 +1,25 @@
+import { ClauseBuilder } from './clause-builder.js';
+export declare class SelectBuilder extends ClauseBuilder {
+    fields: string[];
+    constructor(mapper: any, target: string, fields?: string[]);
+    get(): Promise<any[]>;
+    getOne(): Promise<any | null>;
+}
+export declare class InsertBuilder {
+    private mapper;
+    private target;
+    private data;
+    private query;
+    constructor(mapper: any, target: string, data: any);
+    private ensureSchema;
+    run(): Promise<any>;
+}
+export declare class UpdateBuilder extends ClauseBuilder {
+    private data;
+    constructor(mapper: any, target: string, data: any);
+    run(): Promise<void>;
+}
+export declare class DeleteBuilder extends ClauseBuilder {
+    constructor(mapper: any, target: string);
+    run(): Promise<void>;
+}

package/dist/builders/dml-builders.js

@@ -0,0 +1,55 @@
+import { ClauseBuilder } from './clause-builder.js';
+export class SelectBuilder extends ClauseBuilder {
+    constructor(mapper, target, fields = []) {
+        super(mapper, target);
+        this.fields = fields;
+        if (fields.length > 0) {
+            this.query.selectFields(fields);
+        }
+    }
+    async get() {
+        return this.query.get();
+    }
+    async getOne() {
+        return this.query.getOne();
+    }
+}
+export class InsertBuilder {
+    constructor(mapper, target, data) {
+        this.mapper = mapper;
+        this.target = target;
+        this.data = data;
+        this.query = mapper.use(target);
+        // Ensure we handle auto-registration if needed (legacy behavior support)
+        this.ensureSchema(mapper, target);
+    }
+    ensureSchema(mapper, target) {
+        try {
+            mapper.use(target);
+        }
+        catch (e) {
+            mapper.getSchemaManager().create(target).use({ connection: 'default', collection: target }).setStructure({});
+        }
+    }
+    async run() {
+        return this.mapper.add(this.target, this.data);
+    }
+}
+export class UpdateBuilder extends ClauseBuilder {
+    constructor(mapper, target, data) {
+        super(mapper, target);
+        this.data = data;
+        this.query.to(data);
+    }
+    async run() {
+        return this.query.update();
+    }
+}
+export class DeleteBuilder extends ClauseBuilder {
+    constructor(mapper, target) {
+        super(mapper, target);
+    }
+    async run() {
+        return this.query.delete();
+    }
+}

package/dist/builders/raw-builder.d.ts

@@ -0,0 +1,8 @@
+export declare class RawBuilder {
+    private mapper;
+    private sql;
+    private _bindings;
+    constructor(mapper: any, sql: string);
+    bind(bindings: any[] | any): this;
+    run(): Promise<any>;
+}

package/dist/builders/raw-builder.js

@@ -0,0 +1,22 @@
+export class RawBuilder {
+    constructor(mapper, sql) {
+        this.mapper = mapper;
+        this.sql = sql;
+        this._bindings = [];
+    }
+    bind(bindings) {
+        this._bindings = Array.isArray(bindings) ? bindings : [bindings];
+        return this;
+    }
+    async run() {
+        const connections = this.mapper.getConnections();
+        const conn = connections.get('default');
+        if (!conn)
+            throw new Error("No default connection found for raw query.");
+        const adapter = connections.getAdapter(conn.name);
+        if (adapter && typeof adapter.query === 'function') {
+            return adapter.query(this.sql, this._bindings);
+        }
+        throw new Error(`Connection '${conn.name}' does not support raw queries.`);
+    }
+}

package/dist/builders/schema-builders.d.ts

@@ -0,0 +1,44 @@
+export declare class SchemaCreator {
+    private mapper;
+    private name;
+    private type;
+    private migrator;
+    constructor(mapper: any, name: string, type: string);
+    private ensureRegistration;
+    addColumn(name: string): import("../migrator.js").ColumnBuilder;
+    structure(config: any): this;
+    exec(): Promise<void>;
+}
+export declare class SchemaUpdater {
+    private mapper;
+    private name;
+    private migrator;
+    constructor(mapper: any, name: string);
+    addColumn(name: string): import("../migrator.js").ColumnBuilder;
+    selectColumn(name: string): import("../migrator.js").ColumnBuilder;
+    dropColumn(name: string): this;
+    exec(): Promise<void>;
+}
+export declare class SchemaDropper {
+    private name;
+    constructor(name: string);
+    exec(): Promise<void>;
+}
+export declare class SchemaHandler {
+    protected mapper: any;
+    protected name: string;
+    protected schemaType: string;
+    constructor(mapper: any, name: string, schemaType: string);
+    create(): SchemaCreator;
+    update(): SchemaUpdater;
+    drop(): SchemaDropper;
+}
+export declare class SchemaDispatcher {
+    private mapper;
+    private name;
+    constructor(mapper: any, name: string);
+    type(type: 'table' | 'api' | 'collection'): SchemaHandler;
+    create(): SchemaCreator;
+    update(): SchemaUpdater;
+    drop(): SchemaDropper;
+}

package/dist/builders/schema-builders.js

@@ -0,0 +1,84 @@
+import { TableMigrator } from '../migrator.js';
+import { parseDescriptorStructure } from '../index.js';
+export class SchemaCreator {
+    constructor(mapper, name, type) {
+        this.mapper = mapper;
+        this.name = name;
+        this.type = type;
+        this.migrator = new TableMigrator(name);
+        this.ensureRegistration();
+    }
+    ensureRegistration() {
+        // Register if technically missing from memory so migrator has something to work with
+        const manager = this.mapper.getSchemaManager();
+        if (!manager.schemas.has(this.name)) {
+            manager.create(this.name).use({ connection: 'default', collection: this.name }).setStructure({});
+        }
+    }
+    // DDL Methods
+    addColumn(name) { return this.migrator.addColumn(name); }
+    structure(config) {
+        // Apply structure config to the in-memory definition immediately for usage
+        const def = this.mapper.getSchemaManager().schemas.get(this.name);
+        if (def) {
+            const parsed = parseDescriptorStructure(config);
+            def.fields = parsed.fields;
+            def.fieldsMap = new Map();
+            def.fields.forEach((f) => def.fieldsMap.set(f.name, f));
+        }
+        return this;
+    }
+    async exec() {
+        return this.migrator.exec();
+    }
+}
+export class SchemaUpdater {
+    constructor(mapper, name) {
+        this.mapper = mapper;
+        this.name = name;
+        this.migrator = new TableMigrator(name);
+    }
+    addColumn(name) { return this.migrator.addColumn(name); }
+    selectColumn(name) { return this.migrator.selectColumn(name); }
+    dropColumn(name) { this.migrator.dropColumn(name); return this; }
+    async exec() {
+        return this.migrator.exec();
+    }
+}
+export class SchemaDropper {
+    constructor(name) {
+        this.name = name;
+    }
+    async exec() {
+        return new TableMigrator(this.name).drop().exec();
+    }
+}
+export class SchemaHandler {
+    constructor(mapper, name, schemaType) {
+        this.mapper = mapper;
+        this.name = name;
+        this.schemaType = schemaType;
+    }
+    create() {
+        return new SchemaCreator(this.mapper, this.name, this.schemaType);
+    }
+    update() {
+        return new SchemaUpdater(this.mapper, this.name);
+    }
+    drop() {
+        return new SchemaDropper(this.name);
+    }
+}
+export class SchemaDispatcher {
+    constructor(mapper, name) {
+        this.mapper = mapper;
+        this.name = name;
+    }
+    type(type) {
+        return new SchemaHandler(this.mapper, this.name, type);
+    }
+    // Shortcuts if type is omitted (defaults to 'table' behavior essentially)
+    create() { return new SchemaHandler(this.mapper, this.name, 'table').create(); }
+    update() { return new SchemaHandler(this.mapper, this.name, 'table').update(); }
+    drop() { return new SchemaHandler(this.mapper, this.name, 'table').drop(); }
+}

package/dist/cli/create-migration.js

@@ -46,7 +46,7 @@ import { Mapper, TableMigrator } from '@neupgroup/mapper';
 export const usesConnection = 'default';
 
 export async function up() {
-    const schema = Mapper.schema().table('${tableName}');
+    const schema = Mapper.schema('${tableName}');
     schema.useConnection(usesConnection);
 
     /**
@@ -71,9 +71,9 @@ export async function down() {
      * DROP SCHEMA (Immediate action)
      * This will drop the schema from the DB and delete the local schema file.
      */
-    const schema = Mapper.schema().table('${tableName}');
+    const schema = Mapper.schema('${tableName}');
     schema.useConnection(usesConnection);
-    await schema.dropTable().exec();
+    await schema.drop().exec();
 }
 `;
 fs.writeFileSync(filePath, fileContent.trim());

package/dist/connector.d.ts

@@ -40,11 +40,11 @@ export declare class Connector {
      * Define the table or collection to operate on.
      * This registers the connection (if not already) and prepares a query.
      */
-    table(tableName: string): import("./fluent-mapper.js").FluentQueryBuilder;
+    table(tableName: string): import("./fluent-mapper.js").BaseDispatcher;
     /**
      * Alias for table() for API endpoints (subpath).
      */
-    subpath(path: string): import("./fluent-mapper.js").FluentQueryBuilder;
+    subpath(path: string): import("./fluent-mapper.js").BaseDispatcher;
     /**
      * Finalizes the connection registration and returns a query object.
      */

package/dist/discovery.js

@@ -49,17 +49,13 @@ export async function discover() {
                 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)
+                    StaticMapper.schema(schemaName)
+                        .create()
                         .structure(schemaDef.fields);
                     // Apply options if present
+                    // 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);
+                        const wrapper = StaticMapper.getFluentMapper().mapper.getSchemaManager().create(schemaName);
                         if (schemaDef.insertableFields)
                             wrapper.insertableFields = schemaDef.insertableFields;
                         if (schemaDef.updatableFields)

package/dist/fluent-mapper.d.ts

@@ -1,150 +1,53 @@
-import { Connections, SchemaManager, type SchemaDef, ConnectionType } from './index.js';
-import { TableMigrator } from './migrator.js';
-export declare class FluentQueryBuilder {
-    private mapper;
-    private schemaName;
-    private query;
-    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;
-    offset(n: number): this;
-    to(update: Record<string, any>): this;
-    get(...fields: string[]): any;
-    then(onfulfilled?: ((value: any) => any) | null, onrejected?: ((reason: any) => any) | null): Promise<any>;
-    getOne(): Promise<Record<string, any> | null>;
-    add(data: Record<string, any>): Promise<any>;
-    insert(data: Record<string, any>): Promise<any>;
-    update(): Promise<void>;
-    delete(): Promise<void>;
-    deleteOne(): Promise<void>;
-    updateOne(): Promise<void>;
-}
+import { ConnectionType } from './index.js';
+import { BaseDispatcher } from './builders/base-dispatcher.js';
+import { RawBuilder } from './builders/raw-builder.js';
+import { SchemaDispatcher } from './builders/schema-builders.js';
+export { BaseDispatcher, RawBuilder, SchemaDispatcher };
+export * from './builders/dml-builders.js';
+export * from './builders/schema-builders.js';
+export * from './builders/raw-builder.js';
+export * from './builders/clause-builder.js';
 export declare class FluentConnectionBuilder {
+    private name;
+    private type;
     private mapper;
-    private connectionName;
-    private connectionType;
-    private connectionConfig;
-    constructor(mapper: any, connectionName: string, connectionType: string, config: Record<string, any>);
-    schema(schemaName: string): FluentSchemaBuilder;
-    query(schemaName: string): FluentQueryBuilder;
-    useConnection(connectionName: string): FluentConnectionSelector;
-}
-export declare class FluentSchemaBuilder {
-    private mapper;
-    private schemaName;
-    private connectionName;
-    constructor(mapper: any, schemaName: string, connectionName: string);
-    collection(collectionName: string): FluentSchemaCollectionBuilder;
-}
-export declare class FluentSchemaCollectionBuilder {
-    private mapper;
-    private schemaName;
-    private connectionName;
-    private collectionName;
-    constructor(mapper: any, schemaName: string, connectionName: string, collectionName: string);
-    structure(structure: Record<string, string> | Array<{
-        name: string;
-        type: string;
-        [key: string]: any;
-    }>): FluentMapper;
-}
-export declare class FluentApiRequestBuilder {
-    private mapper;
-    private connectionName;
-    private _path;
-    private _headers;
-    constructor(mapper: any, connectionName: string, path?: string);
-    path(p: string): this;
-    header(key: string | Record<string, string | string[]>, value?: string | string[]): this;
-    headers(h: Record<string, string | string[]> | any[]): this;
-    get(): Promise<any>;
-    post(data?: any): Promise<any>;
-    put(data?: any): Promise<any>;
-    patch(data?: any): Promise<any>;
-    delete(): Promise<any>;
-    private execute;
+    constructor(mapper: any, name: string, type: ConnectionType, config: Record<string, any>);
+    base(target: string): BaseDispatcher;
+    query(target: string): BaseDispatcher;
 }
 export declare class FluentConnectionSelector {
     private mapper;
-    private connectionName;
-    constructor(mapper: any, connectionName: string);
-    schema(schemaName: string): FluentQueryBuilder;
-    schemas(schemaName: string): FluentQueryBuilder;
-    query(schemaName: string): FluentQueryBuilder;
-    table(tableName: string): FluentQueryBuilder;
-    collection(collectionName: string): FluentQueryBuilder;
-    path(path: string): FluentApiRequestBuilder;
-    header(key: string | Record<string, string | string[]>, value?: string | string[]): FluentApiRequestBuilder;
-    headers(headers: Record<string, string> | any[]): FluentApiRequestBuilder;
-    get(): Promise<any>;
-    post(data?: any): Promise<any>;
-    put(data?: any): Promise<any>;
-    patch(data?: any): Promise<any>;
-    delete(): Promise<any>;
+    private name;
+    constructor(mapper: any, name: string);
+    base(target: string): BaseDispatcher;
+    query(target: string): BaseDispatcher;
 }
 export declare class FluentMapper {
     private mapper;
     constructor(mapper: any);
-    query(schemaName: string): FluentQueryBuilder;
-    schema(name: string): FluentQueryBuilder;
-    table(name: string): FluentQueryBuilder;
+    base(target: string): BaseDispatcher;
+    query(target: string): BaseDispatcher;
+    schema(name: string): SchemaDispatcher;
+    raw(sql: string): RawBuilder;
     makeConnection(name: string, type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
-    useConnection(connectionName: string): FluentConnectionSelector;
-    connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
-    makeTempConnection(type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
-    get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
-    getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
-    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>;
+    connection(configOrName: string | any): FluentConnectionSelector;
+    get(target: string): Promise<any>;
+    add(target: string, data: any): Promise<any>;
+    update(target: string, filter: any, data: any): Promise<any>;
+    delete(target: string, filter: any): Promise<any>;
 }
 export declare class StaticMapper {
     private static instance;
     private static getFluentMapper;
-    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): 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 base(target: string): BaseDispatcher;
+    static query(target: string): BaseDispatcher;
+    static schema(name: string): SchemaDispatcher;
+    static raw(sql: string): RawBuilder;
+    static connection(arg: any): FluentConnectionSelector;
+    static makeConnection(n: string, t: ConnectionType, c: any): FluentConnectionBuilder;
     static discover(): Promise<void>;
+    static get(t: string): Promise<any>;
+    static add(t: string, d: any): Promise<any>;
 }
 export declare const Mapper: typeof StaticMapper;
 export default Mapper;
-export declare class SchemaManagerWrapper {
-    private manager;
-    constructor(manager: SchemaManager);
-    table(name: string): TableMigrator;
-    schema(name: string): TableMigrator;
-    dropTable(name: string): Promise<void>;
-}

package/dist/fluent-mapper.js

@@ -1,470 +1,110 @@
 import { createMapper } from './mapper.js';
-import { TableMigrator } from './migrator.js';
-export class FluentQueryBuilder {
-    constructor(mapper, schemaName, connectionName) {
-        this.mapper = mapper;
-        this.schemaName = schemaName;
-        try {
-            this.query = mapper.use(schemaName);
-            if (connectionName) {
-                const def = this.getDef();
-                if (def)
-                    def.connectionName = connectionName;
-            }
-        }
-        catch (e) {
-            // Auto-register schema if missing (Automatically schemas!)
-            mapper.getSchemaManager().create(schemaName).use({ connection: connectionName || 'default', collection: schemaName }).setStructure({});
-            this.query = mapper.use(schemaName);
-        }
-    }
-    getDef() {
-        return this.mapper.getSchemaManager().schemas.get(this.schemaName);
-    }
-    set fields(config) {
-        const def = this.getDef();
-        if (def) {
-            const parsed = parseDescriptorStructure(config);
-            def.fields = parsed.fields;
-            def.fieldsMap = new Map();
-            def.fields.forEach((f) => def.fieldsMap.set(f.name, f));
-            def.allowUndefinedFields = parsed.allowUndefinedFields;
-        }
-    }
-    set insertableFields(val) {
-        const def = this.getDef();
-        if (def)
-            def.insertableFields = val;
-    }
-    set updatableFields(val) {
-        const def = this.getDef();
-        if (def)
-            def.updatableFields = val;
-    }
-    set deleteType(val) {
-        const def = this.getDef();
-        if (def)
-            def.deleteType = val;
-    }
-    set massDeleteAllowed(val) {
-        const def = this.getDef();
-        if (def)
-            def.massDeleteAllowed = val;
-    }
-    set massEditAllowed(val) {
-        const def = this.getDef();
-        if (def)
-            def.massEditAllowed = val;
-    }
-    structure(config) {
-        this.fields = config;
-        return this;
-    }
-    collection(collectionName) {
-        const def = this.getDef();
-        if (def)
-            def.collectionName = collectionName;
-        return this;
-    }
-    get migrator() {
-        if (!this._migrator) {
-            this._migrator = new TableMigrator(this.schemaName);
-            // Sync connection if already set on query
-            const def = this.getDef();
-            if (def === null || def === void 0 ? void 0 : def.connectionName) {
-                this._migrator.useConnection(def.connectionName);
-            }
-        }
-        return this._migrator;
-    }
-    // Migration/DDL Methods (Proxied to internal migrator)
-    useConnection(name) {
-        this.migrator.useConnection(name);
-        const def = this.getDef();
-        if (def)
-            def.connectionName = name;
-        return this;
-    }
-    addColumn(name) { return this.migrator.addColumn(name); }
-    selectColumn(name) { return this.migrator.selectColumn(name); }
-    dropColumn(name) { this.migrator.dropColumn(name); return this; }
-    drop() { this.migrator.drop(); return this; }
-    async exec() {
-        return this.migrator.exec();
-    }
-    async dropTable() {
-        return this.migrator.drop().exec();
-    }
-    where(field, value, operator) {
-        this.query.where(field, value, operator);
-        return this;
-    }
-    whereComplex(raw) {
-        this.query.whereComplex(raw);
-        return this;
-    }
-    limit(n) {
-        this.query.limit(n);
-        return this;
-    }
-    offset(n) {
-        this.query.offset(n);
-        return this;
-    }
-    to(update) {
-        this.query.to(update);
-        return this;
-    }
-    // If args provided, act as SELECT (projection) and return this.
-    // If no args, act as execute() (but this class is thenable so we can just return this if we want consistency, 
-    // but existing API returns Promise directly. To check user intent:
-    // User: get('f1').limit(1).
-    // So get('f1') must return this.
-    get(...fields) {
-        if (fields.length > 0) {
-            // Apply field selection? SchemaQuery needs a way to filter fields.
-            // We'll add this capability to Field filtering in SchemaQuery or just use 'fields' option in buildOptions.
-            // For now, let's assume we can modify the query's field list.
-            this.query.selectFields(fields);
-            return this;
-        }
-        return this.query.get(); // Promise
-    }
-    // Make the builder thenable
-    then(onfulfilled, onrejected) {
-        return this.query.get().then(onfulfilled, onrejected);
-    }
-    async getOne() {
-        return this.query.getOne();
-    }
-    async add(data) {
-        return this.mapper.add(this.schemaName, data);
-    }
-    async insert(data) {
-        return this.add(data);
-    }
-    async update() {
-        return this.query.update();
-    }
-    async delete() {
-        return this.query.delete();
-    }
-    async deleteOne() {
-        return this.query.deleteOne();
-    }
-    async updateOne() {
-        return this.query.updateOne();
-    }
-}
+// Import segregated builders
+import { BaseDispatcher } from './builders/base-dispatcher.js';
+import { RawBuilder } from './builders/raw-builder.js';
+import { SchemaDispatcher } from './builders/schema-builders.js';
+// Re-export for external usage
+export { BaseDispatcher, RawBuilder, SchemaDispatcher };
+export * from './builders/dml-builders.js';
+export * from './builders/schema-builders.js';
+export * from './builders/raw-builder.js';
+export * from './builders/clause-builder.js';
+// =========================================================================================
+// CONNECTION & MAPPER WRAPPERS
+// =========================================================================================
 export class FluentConnectionBuilder {
-    constructor(mapper, connectionName, connectionType, config) {
+    constructor(mapper, name, type, config) {
+        this.name = name;
+        this.type = type;
         this.mapper = mapper;
-        this.connectionName = connectionName;
-        this.connectionType = connectionType;
-        this.connectionConfig = config;
-        // Create the connection immediately
-        this.mapper.connect(connectionName, connectionType, config);
-    }
-    schema(schemaName) {
-        return new FluentSchemaBuilder(this.mapper, schemaName, this.connectionName);
-    }
-    query(schemaName) {
-        return new FluentQueryBuilder(this.mapper, schemaName);
-    }
-    useConnection(connectionName) {
-        return new FluentConnectionSelector(this.mapper, connectionName);
-    }
-}
-export class FluentSchemaBuilder {
-    constructor(mapper, schemaName, connectionName) {
-        this.mapper = mapper;
-        this.schemaName = schemaName;
-        this.connectionName = connectionName;
-    }
-    collection(collectionName) {
-        return new FluentSchemaCollectionBuilder(this.mapper, this.schemaName, this.connectionName, collectionName);
-    }
-}
-export class FluentSchemaCollectionBuilder {
-    constructor(mapper, schemaName, connectionName, collectionName) {
-        this.mapper = mapper;
-        this.schemaName = schemaName;
-        this.connectionName = connectionName;
-        this.collectionName = collectionName;
-    }
-    structure(structure) {
-        this.mapper.schema(this.schemaName)
-            .use({ connection: this.connectionName, collection: this.collectionName })
-            .setStructure(structure);
-        return new FluentMapper(this.mapper);
-    }
-}
-export class FluentApiRequestBuilder {
-    constructor(mapper, connectionName, path = '') {
-        this.mapper = mapper;
-        this.connectionName = connectionName;
-        this._path = '';
-        this._headers = {};
-        this._path = path;
-    }
-    path(p) {
-        if (this._path === '') {
-            this._path = p;
-        }
-        else {
-            if (!p.startsWith('/') && !this._path.endsWith('/')) {
-                this._path += '/';
-            }
-            this._path += p;
-        }
-        return this;
+        this.mapper.connect(name, type, config);
     }
-    header(key, value) {
-        if (typeof key === 'object') {
-            Object.entries(key).forEach(([k, v]) => this.header(k, v));
-        }
-        else if (value !== undefined) {
-            if (this._headers[key]) {
-                const existing = this._headers[key];
-                if (Array.isArray(existing)) {
-                    if (Array.isArray(value)) {
-                        existing.push(...value);
-                    }
-                    else {
-                        existing.push(value);
-                    }
-                }
-                else {
-                    this._headers[key] = [existing, ...(Array.isArray(value) ? value : [value])];
-                }
-            }
-            else {
-                this._headers[key] = value;
-            }
-        }
-        else {
-            // Check for "Key: Value" string
-            if (key.includes(':')) {
-                const [k, ...v] = key.split(':');
-                this.header(k.trim(), v.join(':').trim());
-            }
-        }
-        return this;
+    base(target) {
+        return new BaseDispatcher(this.mapper, target);
     }
-    headers(h) {
-        if (Array.isArray(h)) {
-            h.forEach(item => this.header(item));
-        }
-        else {
-            this.header(h);
-        }
-        return this;
-    }
-    async get() { return this.execute('GET'); }
-    async post(data) { return this.execute('POST', data); }
-    async put(data) { return this.execute('PUT', data); }
-    async patch(data) { return this.execute('PATCH', data); }
-    async delete() { return this.execute('DELETE'); }
-    async execute(method, data) {
-        const adapter = this.mapper.getConnections().getAdapter(this.connectionName);
-        if (!adapter || typeof adapter.request !== 'function') {
-            throw new Error(`Connection "${this.connectionName}" does not support custom requests.`);
-        }
-        return adapter.request(method, this._path, data, this._headers);
+    query(target) {
+        return this.base(target);
     }
 }
 export class FluentConnectionSelector {
-    constructor(mapper, connectionName) {
+    constructor(mapper, name) {
         this.mapper = mapper;
-        this.connectionName = connectionName;
-    }
-    schema(schemaName) {
-        return new FluentQueryBuilder(this.mapper, schemaName, this.connectionName);
-    }
-    schemas(schemaName) {
-        return this.schema(schemaName);
-    }
-    query(schemaName) {
-        return this.schema(schemaName);
-    }
-    table(tableName) {
-        return this.schema(tableName);
-    }
-    collection(collectionName) {
-        return this.schema(collectionName);
+        this.name = name;
     }
-    // API Request methods
-    path(path) {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName, path);
+    base(target) {
+        // Determine how to pass context? BaseDispatcher usually gets just mapper and target.
+        // If we need specific connection, we might need to assume 'useConnection' behavior.
+        // For now, simple forwarding.
+        return new BaseDispatcher(this.mapper, target);
     }
-    header(key, value) {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName).header(key, value);
-    }
-    headers(headers) {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName).headers(headers);
-    }
-    get() {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName).get();
-    }
-    post(data) {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName).post(data);
-    }
-    put(data) {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName).put(data);
-    }
-    patch(data) {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName).patch(data);
-    }
-    delete() {
-        return new FluentApiRequestBuilder(this.mapper, this.connectionName).delete();
+    query(target) {
+        return this.base(target);
     }
 }
 export class FluentMapper {
     constructor(mapper) {
         this.mapper = mapper;
     }
-    query(schemaName) {
-        return new FluentQueryBuilder(this.mapper, schemaName);
+    // Entry Point: BASE (DML)
+    base(target) {
+        return new BaseDispatcher(this.mapper, target);
+    }
+    // Entry Point: QUERY (Alias for Base)
+    query(target) {
+        return this.base(target);
     }
+    // Entry Point: SCHEMA (DDL)
     schema(name) {
-        return this.query(name);
+        return new SchemaDispatcher(this.mapper, name);
     }
-    table(name) {
-        return this.query(name);
+    // Entry Point: RAW
+    raw(sql) {
+        return new RawBuilder(this.mapper, sql);
     }
+    // Connection Management
     makeConnection(name, type, config) {
         return new FluentConnectionBuilder(this.mapper, name, type, config);
     }
-    // Deprecated: use connection() instead
-    useConnection(connectionName) {
-        return new FluentConnectionSelector(this.mapper, connectionName);
-    }
-    connection(connectionOrConfig) {
-        if (typeof connectionOrConfig === 'string') {
-            return new FluentConnectionSelector(this.mapper, connectionOrConfig);
-        }
-        // Handle object config: create temp connection
-        // Expected format: { type: '...', ...others }
-        const type = connectionOrConfig.type;
-        if (!type) {
-            throw new Error("Connection configuration must specify 'type'");
-        }
-        const config = { ...connectionOrConfig };
-        delete config.type;
-        // Create temp connection
-        const tempName = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        new FluentConnectionBuilder(this.mapper, tempName, type, config); // Registers it
-        return new FluentConnectionSelector(this.mapper, tempName);
-    }
-    makeTempConnection(type, config) {
-        const tempName = `temp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        return new FluentConnectionBuilder(this.mapper, tempName, type, config);
-    }
-    // Direct query methods for quick usage
-    async get(schemaName, filters) {
-        return this.mapper.get(schemaName, filters);
-    }
-    async getOne(schemaName, filters) {
-        return this.mapper.getOne(schemaName, filters);
-    }
-    async add(schemaName, data) {
-        return this.mapper.add(schemaName, data);
-    }
-    async update(schemaName, filters, data) {
-        return this.mapper.update(schemaName, filters, data);
-    }
-    async delete(schemaName, filters) {
-        return this.mapper.delete(schemaName, filters);
-    }
-    async dropTable(name) {
-        return new TableMigrator(name).drop().exec();
+    connection(configOrName) {
+        if (typeof configOrName === 'string')
+            return new FluentConnectionSelector(this.mapper, configOrName);
+        // Temp connection logic could go here
+        return new FluentConnectionSelector(this.mapper, 'default');
+    }
+    // Direct shortcuts (Legacy support maintenance)
+    async get(target) { return this.base(target).select().get(); }
+    async add(target, data) { return this.base(target).insert(data).run(); }
+    async update(target, filter, data) {
+        let b = this.base(target).update(data);
+        Object.keys(filter).forEach(k => b.where(k, filter[k]));
+        return b.run();
+    }
+    async delete(target, filter) {
+        let b = this.base(target).delete();
+        Object.keys(filter).forEach(k => b.where(k, filter[k]));
+        return b.run();
     }
 }
-// Static API class that provides the fluent interface
 export class StaticMapper {
     static getFluentMapper() {
         if (!StaticMapper.instance) {
-            const baseMapper = createMapper();
-            StaticMapper.instance = new FluentMapper(baseMapper);
+            StaticMapper.instance = new FluentMapper(createMapper());
         }
         return StaticMapper.instance;
     }
-    static makeConnection(name, type, config) {
-        return StaticMapper.getFluentMapper().makeConnection(name, type, config);
-    }
-    static makeTempConnection(type, config) {
-        return StaticMapper.getFluentMapper().makeTempConnection(type, config);
-    }
-    static query(schemaName) {
-        return StaticMapper.getFluentMapper().query(schemaName);
-    }
-    static schema(name) {
-        if (name)
-            return StaticMapper.getFluentMapper().schema(name);
-        return StaticMapper.schemas();
-    }
-    static table(name) {
-        return StaticMapper.schema(name);
-    }
-    // New API
-    static connection(connectionOrConfig) {
-        return StaticMapper.getFluentMapper().connection(connectionOrConfig);
-    }
-    // Deprecated alias
-    static useConnection(connectionName) {
-        return StaticMapper.connection(connectionName);
-    }
-    static schemas(name) {
-        if (name)
-            return StaticMapper.schema(name);
-        return new SchemaManagerWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager());
-    }
-    // Direct static methods
-    static async get(schemaName, filters) {
-        return StaticMapper.getFluentMapper().get(schemaName, filters);
-    }
-    static async getOne(schemaName, filters) {
-        return StaticMapper.getFluentMapper().getOne(schemaName, filters);
-    }
-    static async add(schemaName, data) {
-        return StaticMapper.getFluentMapper().add(schemaName, data);
-    }
-    static async update(schemaName, filters, data) {
-        return StaticMapper.getFluentMapper().update(schemaName, filters, data);
-    }
-    static async delete(schemaName, filters) {
-        return StaticMapper.getFluentMapper().delete(schemaName, filters);
-    }
-    static async dropTable(name) {
-        return StaticMapper.getFluentMapper().dropTable(name);
-    }
-    static getConnections() {
-        return StaticMapper.getFluentMapper().mapper.getConnections();
-    }
+    static base(target) { return StaticMapper.getFluentMapper().base(target); }
+    static query(target) { return StaticMapper.getFluentMapper().query(target); }
+    static schema(name) { return StaticMapper.getFluentMapper().schema(name); }
+    static raw(sql) { return StaticMapper.getFluentMapper().raw(sql); }
+    static connection(arg) { return StaticMapper.getFluentMapper().connection(arg); }
+    static makeConnection(n, t, c) { return StaticMapper.getFluentMapper().makeConnection(n, t, c); }
     static async discover() {
         const { discover } = await import('./discovery.js');
         return discover();
     }
+    // Helpers for simple usage
+    static async get(t) { return StaticMapper.getFluentMapper().get(t); }
+    static async add(t, d) { return StaticMapper.getFluentMapper().add(t, d); }
 }
-// Export a default instance for convenience
 export const Mapper = StaticMapper;
 export default Mapper;
-// Helper to access parseDescriptorStructure from index.ts if not exported?
-// It is NOT exported. I need to export it or duplicate logic.
-// I'll export it from index.ts.
-import { parseDescriptorStructure } from './index.js'; // fixed import at bottom
-export class SchemaManagerWrapper {
-    constructor(manager) {
-        this.manager = manager;
-    }
-    table(name) {
-        // This allows Mapper.schemas().table('name') to return a migrator
-        return new TableMigrator(name);
-    }
-    schema(name) {
-        return this.table(name);
-    }
-    async dropTable(name) {
-        return new TableMigrator(name).drop().exec();
-    }
-}

package/dist/index.d.ts

@@ -127,8 +127,8 @@ export type { EnvDslConnections, NormalizedConnection } from './env.js';
 export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs.js';
 export { Mapper, createMapper } from './mapper.js';
 export { default } from './mapper.js';
-export { StaticMapper } from './fluent-mapper.js';
-export type { FluentQueryBuilder, FluentConnectionBuilder, FluentSchemaBuilder, FluentSchemaCollectionBuilder, FluentConnectionSelector, FluentMapper } from './fluent-mapper.js';
+export { StaticMapper, RawBuilder, BaseDispatcher } from './fluent-mapper.js';
+export type { FluentConnectionBuilder, FluentConnectionSelector, FluentMapper } from './fluent-mapper.js';
 export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config.js';
 export type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig, SqliteConnectionConfig, ConfigSchema } from './config.js';
 export { MySQLAdapter, createMySQLAdapter, PostgreSQLAdapter, createPostgreSQLAdapter, MongoDBAdapter, createMongoDBAdapter, APIAdapter, createAPIAdapter, SQLiteAdapter, createSQLiteAdapter, createAdapter, createAdapterFromUrl, autoAttachAdapter } from './adapters/index.js';

package/dist/index.js

@@ -396,8 +396,7 @@ export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs.js
 // Export the simplified Mapper and default instance
 export { Mapper, createMapper } from './mapper.js';
 export { default } from './mapper.js';
-// Export the new fluent/static API
-export { StaticMapper } from './fluent-mapper.js';
+export { StaticMapper, RawBuilder, BaseDispatcher } from './fluent-mapper.js';
 // Export the new config-based system
 export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config.js';
 // Export database adapters

package/package.json

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