@neupgroup/mapper 1.6.1 → 1.7.0

package/dist/cli/create-migration.js

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

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

@@ -4,9 +4,10 @@ export declare class FluentQueryBuilder {
     private mapper;
     private schemaName;
     private query;
-    constructor(mapper: any, schemaName: string);
+    constructor(mapper: any, schemaName: string, connectionName?: 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;
     to(update: Record<string, any>): this;
@@ -15,10 +16,32 @@ export declare class FluentQueryBuilder {
     getOne(): Promise<Record<string, any> | null>;
     add(data: Record<string, any>): Promise<any>;
     insert(data: Record<string, any>): Promise<any>;
-    update(): Promise<void>;
+    update(data?: Record<string, any>): Promise<void>;
     delete(): Promise<void>;
     deleteOne(): Promise<void>;
-    updateOne(): Promise<void>;
+    updateOne(data?: Record<string, any>): Promise<void>;
+}
+export declare class FluentSchemaBuilder {
+    private mapper;
+    private schemaName;
+    private _migrator?;
+    constructor(mapper: any, schemaName: string, connectionName?: string);
+    private getDef;
+    set fields(config: any);
+    structure(config: any): this;
+    collection(collectionName: string): this;
+    set insertableFields(val: string[]);
+    set updatableFields(val: string[]);
+    set deleteType(val: 'softDelete' | 'hardDelete');
+    set massDeleteAllowed(val: boolean);
+    set massEditAllowed(val: boolean);
+    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>;
 }
 export declare class FluentConnectionBuilder {
     private mapper;
@@ -30,24 +53,33 @@ export declare class FluentConnectionBuilder {
     query(schemaName: string): FluentQueryBuilder;
     useConnection(connectionName: string): FluentConnectionSelector;
 }
-export declare class FluentSchemaBuilder {
+export declare class RawQueryBuilder {
     private mapper;
-    private schemaName;
-    private connectionName;
-    constructor(mapper: any, schemaName: string, connectionName: string);
-    collection(collectionName: string): FluentSchemaCollectionBuilder;
+    private sql;
+    private _bindings;
+    constructor(mapper: any, sql: string);
+    bind(bindings: any[] | any): this;
+    run(): Promise<any>;
 }
-export declare class FluentSchemaCollectionBuilder {
+export declare class BaseQueryBuilder {
     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;
+    private target;
+    private queryBuilder;
+    private _select;
+    private _insertData?;
+    private _updateData?;
+    private _action;
+    constructor(mapper: any, target: string);
+    select(fields: string[]): this;
+    where(field: string, value: any, operator?: string): this;
+    whereRaw(raw: string): this;
+    limit(n: number): this;
+    offset(n: number): this;
+    insert(data: any): this;
+    update(data: any): this;
+    get(): Promise<any>;
+    getOne(): Promise<any>;
+    run(): Promise<any>;
 }
 export declare class FluentApiRequestBuilder {
     private mapper;
@@ -70,10 +102,10 @@ export declare class FluentConnectionSelector {
     private connectionName;
     constructor(mapper: any, connectionName: string);
     schema(schemaName: string): FluentSchemaBuilder;
+    schemas(schemaName: string): FluentSchemaBuilder;
     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,7 +119,10 @@ export declare class FluentMapper {
     private mapper;
     constructor(mapper: any);
     query(schemaName: string): FluentQueryBuilder;
+    schema(name: string): FluentSchemaBuilder;
     table(name: string): FluentQueryBuilder;
+    raw(sql: string): RawQueryBuilder;
+    base(target: string): BaseQueryBuilder;
     makeConnection(name: string, type: ConnectionType, config: Record<string, any>): FluentConnectionBuilder;
     useConnection(connectionName: string): FluentConnectionSelector;
     connection(connectionOrConfig: string | Record<string, any>): FluentConnectionSelector;
@@ -105,10 +140,14 @@ 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): FluentSchemaBuilder;
+    static schema(): SchemaManagerWrapper;
     static table(name: string): FluentQueryBuilder;
+    static raw(sql: string): RawQueryBuilder;
+    static base(target: string): BaseQueryBuilder;
     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>;
@@ -120,27 +159,10 @@ export declare class StaticMapper {
 }
 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>;
-    dropTable(): Promise<void>;
-}
 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,10 +1,23 @@
 import { createMapper } from './mapper.js';
 import { TableMigrator } from './migrator.js';
+// DML Builder (Querying)
 export class FluentQueryBuilder {
-    constructor(mapper, schemaName) {
+    constructor(mapper, schemaName, connectionName) {
         this.mapper = mapper;
         this.schemaName = schemaName;
-        this.query = mapper.use(schemaName);
+        try {
+            this.query = mapper.use(schemaName);
+            // Auto-update connection if provided override
+            if (connectionName) {
+                // We can't easily update the schema def from query builder purely, 
+                // but the Use() call presumably set up the schemaQuery.
+            }
+        }
+        catch (e) {
+            // Auto-register schema if missing
+            mapper.getSchemaManager().create(schemaName).use({ connection: connectionName || 'default', collection: schemaName }).setStructure({});
+            this.query = mapper.use(schemaName);
+        }
     }
     where(field, value, operator) {
         this.query.where(field, value, operator);
@@ -14,6 +27,9 @@ export class FluentQueryBuilder {
         this.query.whereComplex(raw);
         return this;
     }
+    whereRaw(raw) {
+        return this.whereComplex(raw);
+    }
     limit(n) {
         this.query.limit(n);
         return this;
@@ -26,22 +42,13 @@ export class FluentQueryBuilder {
         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
+        return this.query.get();
     }
-    // Make the builder thenable
     then(onfulfilled, onrejected) {
         return this.query.get().then(onfulfilled, onrejected);
     }
@@ -54,7 +61,10 @@ export class FluentQueryBuilder {
     async insert(data) {
         return this.add(data);
     }
-    async update() {
+    async update(data) {
+        if (data) {
+            this.query.to(data);
+        }
         return this.query.update();
     }
     async delete() {
@@ -63,10 +73,106 @@ export class FluentQueryBuilder {
     async deleteOne() {
         return this.query.deleteOne();
     }
-    async updateOne() {
+    async updateOne(data) {
+        if (data) {
+            this.query.to(data);
+        }
         return this.query.updateOne();
     }
 }
+// DDL Builder (Migrations & Schema Definition)
+export class FluentSchemaBuilder {
+    constructor(mapper, schemaName, connectionName) {
+        this.mapper = mapper;
+        this.schemaName = schemaName;
+        // Ensure schema exists for configuration
+        const manager = mapper.getSchemaManager();
+        const exists = manager.schemas.has(schemaName);
+        if (!exists) {
+            manager.create(schemaName).use({ connection: connectionName || 'default', collection: schemaName }).setStructure({});
+        }
+        // If connectionName provided, update it
+        if (connectionName) {
+            const def = this.getDef();
+            if (def)
+                def.connectionName = connectionName;
+        }
+    }
+    getDef() {
+        return this.mapper.getSchemaManager().schemas.get(this.schemaName);
+    }
+    // Schema Configuration Proxies
+    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;
+        }
+    }
+    structure(config) {
+        this.fields = config;
+        return this;
+    }
+    collection(collectionName) {
+        const def = this.getDef();
+        if (def)
+            def.collectionName = collectionName;
+        return this;
+    }
+    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;
+    }
+    // Migration / DDL Methods
+    get migrator() {
+        if (!this._migrator) {
+            this._migrator = new TableMigrator(this.schemaName);
+            const def = this.getDef();
+            if (def === null || def === void 0 ? void 0 : def.connectionName) {
+                this._migrator.useConnection(def.connectionName);
+            }
+        }
+        return this._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();
+    }
+}
 export class FluentConnectionBuilder {
     constructor(mapper, connectionName, connectionType, config) {
         this.mapper = mapper;
@@ -86,28 +192,94 @@ export class FluentConnectionBuilder {
         return new FluentConnectionSelector(this.mapper, connectionName);
     }
 }
-export class FluentSchemaBuilder {
-    constructor(mapper, schemaName, connectionName) {
+export class RawQueryBuilder {
+    constructor(mapper, sql) {
         this.mapper = mapper;
-        this.schemaName = schemaName;
-        this.connectionName = connectionName;
+        this.sql = sql;
+        this._bindings = [];
     }
-    collection(collectionName) {
-        return new FluentSchemaCollectionBuilder(this.mapper, this.schemaName, this.connectionName, collectionName);
+    bind(bindings) {
+        if (Array.isArray(bindings)) {
+            this._bindings = bindings;
+        }
+        else {
+            this._bindings = [bindings];
+        }
+        return this;
+    }
+    async run() {
+        // Find a default connection or use one if specified (not currently supported in raw() entry point args, defaulting to 'default')
+        // To support explicit connection for raw, we might need Mapper.connection('name').raw(...)
+        const connections = this.mapper.getConnections();
+        const conn = connections.get('default'); // Default fallback
+        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.`);
     }
 }
-export class FluentSchemaCollectionBuilder {
-    constructor(mapper, schemaName, connectionName, collectionName) {
+export class BaseQueryBuilder {
+    constructor(mapper, target) {
         this.mapper = mapper;
-        this.schemaName = schemaName;
-        this.connectionName = connectionName;
-        this.collectionName = collectionName;
+        this.target = target;
+        this._select = [];
+        this._action = 'select';
+        this.queryBuilder = new FluentQueryBuilder(mapper, target);
+    }
+    select(fields) {
+        this._select = fields;
+        this._action = 'select';
+        return this;
     }
-    structure(structure) {
-        this.mapper.schema(this.schemaName)
-            .use({ connection: this.connectionName, collection: this.collectionName })
-            .setStructure(structure);
-        return new FluentMapper(this.mapper);
+    where(field, value, operator) {
+        this.queryBuilder.where(field, value, operator);
+        return this;
+    }
+    whereRaw(raw) {
+        this.queryBuilder.whereRaw(raw);
+        return this;
+    }
+    limit(n) {
+        this.queryBuilder.limit(n);
+        return this;
+    }
+    offset(n) {
+        this.queryBuilder.offset(n);
+        return this;
+    }
+    insert(data) {
+        this._insertData = data;
+        this._action = 'insert';
+        return this;
+    }
+    update(data) {
+        this._updateData = data;
+        this._action = 'update';
+        return this;
+    }
+    async get() {
+        return this.queryBuilder.get(...this._select);
+    }
+    async getOne() {
+        // If select fields were provided, apply them first (though getOne usually fetches all or requires separate select handling in standard query)
+        // FluentQueryBuilder.getOne doesn't take args, but we can ensure fields are selected if underlying support exists.
+        // Current FluentQueryBuilder doesn't support select() state persistence easily without get() args.
+        // We'll proceed with getOne(). To support partial select on getOne, we might need to enhance FluentQueryBuilder or just fetch all.
+        // For now, delegating effectively:
+        return this.queryBuilder.getOne();
+    }
+    async run() {
+        if (this._action === 'insert') {
+            return this.queryBuilder.insert(this._insertData);
+        }
+        if (this._action === 'update') {
+            return this.queryBuilder.update(this._updateData);
+        }
+        // Fallback or other actions
+        return this.get();
     }
 }
 export class FluentApiRequestBuilder {
@@ -192,8 +364,11 @@ export class FluentConnectionSelector {
     schema(schemaName) {
         return new FluentSchemaBuilder(this.mapper, schemaName, this.connectionName);
     }
+    schemas(schemaName) {
+        return this.schema(schemaName);
+    }
     query(schemaName) {
-        return new FluentQueryBuilder(this.mapper, schemaName);
+        return new FluentQueryBuilder(this.mapper, schemaName, this.connectionName);
     }
     table(tableName) {
         return this.query(tableName);
@@ -201,9 +376,6 @@ export class FluentConnectionSelector {
     collection(collectionName) {
         return this.query(collectionName);
     }
-    schemas(schemaName) {
-        return new FluentSchemaWrapper(this.mapper.getSchemaManager(), schemaName, this.connectionName);
-    }
     // API Request methods
     path(path) {
         return new FluentApiRequestBuilder(this.mapper, this.connectionName, path);
@@ -237,9 +409,18 @@ export class FluentMapper {
     query(schemaName) {
         return new FluentQueryBuilder(this.mapper, schemaName);
     }
+    schema(name) {
+        return new FluentSchemaBuilder(this.mapper, name);
+    }
     table(name) {
         return this.query(name);
     }
+    raw(sql) {
+        return new RawQueryBuilder(this.mapper, sql);
+    }
+    base(target) {
+        return new BaseQueryBuilder(this.mapper, target);
+    }
     makeConnection(name, type, config) {
         return new FluentConnectionBuilder(this.mapper, name, type, config);
     }
@@ -306,9 +487,20 @@ export class StaticMapper {
     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.query(name);
     }
+    static raw(sql) {
+        return StaticMapper.getFluentMapper().raw(sql);
+    }
+    static base(target) {
+        return StaticMapper.getFluentMapper().base(target);
+    }
     // New API
     static connection(connectionOrConfig) {
         return StaticMapper.getFluentMapper().connection(connectionOrConfig);
@@ -318,9 +510,8 @@ export class StaticMapper {
         return StaticMapper.connection(connectionName);
     }
     static schemas(name) {
-        if (name) {
-            return new FluentSchemaWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager(), name);
-        }
+        if (name)
+            return StaticMapper.schema(name);
         return new SchemaManagerWrapper(StaticMapper.getFluentMapper().mapper.getSchemaManager());
     }
     // Direct static methods
@@ -353,98 +544,6 @@ export class StaticMapper {
 // Export a default instance for convenience
 export const Mapper = StaticMapper;
 export default Mapper;
-export class FluentSchemaWrapper {
-    // builder unused
-    constructor(manager, name, connectionName) {
-        this.manager = manager;
-        this.name = name;
-        this.connectionName = connectionName;
-        // Ensure schema exists or create it?
-        // User pattern: Mapper.schemas('name').fields = ...
-        // So we likely need to create it if missing, or update it.
-        try {
-            this.manager.create(name).use({ connection: connectionName || 'default', collection: name }).setStructure({});
-        }
-        catch (e) {
-            // Ignore if exists, but maybe update connection if strictly provided?
-            // Use existing definition if available.
-        }
-    }
-    getDef() {
-        // Access private map from manager? Or expose a get method.
-        // Manager has .schemas map.
-        return this.manager.schemas.get(this.name);
-    }
-    set fields(config) {
-        // Update schema structure
-        const builder = new FluentSchemaBuilder(null, this.name, ''); // Dummy wrapper or use internal
-        // Easier: use Manager.create(name) returns SchemaBuilder which has setStructure.
-        // But if it exists, create() throws.
-        // We need 'update' or direct access.
-        // Let's hack: re-register or update def.
-        const def = this.getDef();
-        if (def) {
-            // Re-parse
-            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;
-    }
-    // Delegation to QueryBuilder
-    get(...fields) {
-        const q = new FluentQueryBuilder({ use: (n) => this.manager.use(n) }, this.name);
-        return q.get(...fields);
-    }
-    limit(n) {
-        const q = new FluentQueryBuilder({ use: (n) => this.manager.use(n) }, this.name);
-        return q.limit(n);
-    }
-    offset(n) {
-        const q = new FluentQueryBuilder({ use: (n) => this.manager.use(n) }, this.name);
-        return q.offset(n);
-    }
-    async insert(data) {
-        const q = new FluentQueryBuilder({
-            use: (n) => this.manager.use(n),
-            add: (n, d) => this.manager.use(n).add(d)
-        }, this.name);
-        return q.insert(data);
-    }
-    async dropTable() {
-        const migrator = new TableMigrator(this.name);
-        if (this.connectionName) {
-            migrator.useConnection(this.connectionName);
-        }
-        return migrator.drop().exec();
-    }
-}
 // 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.
@@ -457,6 +556,9 @@ export class SchemaManagerWrapper {
         // 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, RawQueryBuilder, BaseQueryBuilder } from './fluent-mapper.js';
+export type { FluentQueryBuilder, FluentConnectionBuilder, FluentSchemaBuilder, 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

@@ -397,7 +397,7 @@ export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs.js
 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, RawQueryBuilder, BaseQueryBuilder } 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.1",
+  "version": "1.7.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",