@neupgroup/mapper 1.6.2 → 1.7.0

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/fluent-mapper.d.ts

@@ -1,20 +1,40 @@
-import { Connections, SchemaManager, type SchemaDef, ConnectionType } from './index.js';
+import { Connections, SchemaManager, ConnectionType } from './index.js';
 import { TableMigrator } from './migrator.js';
 export declare class FluentQueryBuilder {
     private mapper;
     private schemaName;
     private query;
+    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;
+    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(data?: Record<string, any>): Promise<void>;
+    delete(): Promise<void>;
+    deleteOne(): 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);
-    getDef(): SchemaDef;
+    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);
-    structure(config: any): this;
-    collection(collectionName: string): this;
     get migrator(): TableMigrator;
     useConnection(name: string): this;
     addColumn(name: string): import("./migrator.js").ColumnBuilder;
@@ -22,21 +42,6 @@ export declare class FluentQueryBuilder {
     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>;
 }
 export declare class FluentConnectionBuilder {
     private mapper;
@@ -48,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;
@@ -87,8 +101,8 @@ export declare class FluentConnectionSelector {
     private mapper;
     private connectionName;
     constructor(mapper: any, connectionName: string);
-    schema(schemaName: string): FluentQueryBuilder;
-    schemas(schemaName: string): FluentQueryBuilder;
+    schema(schemaName: string): FluentSchemaBuilder;
+    schemas(schemaName: string): FluentSchemaBuilder;
     query(schemaName: string): FluentQueryBuilder;
     table(tableName: string): FluentQueryBuilder;
     collection(collectionName: string): FluentQueryBuilder;
@@ -105,8 +119,10 @@ export declare class FluentMapper {
     private mapper;
     constructor(mapper: any);
     query(schemaName: string): FluentQueryBuilder;
-    schema(name: 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;
@@ -124,9 +140,11 @@ 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(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): any;

package/dist/fluent-mapper.js

@@ -1,26 +1,107 @@
 import { createMapper } from './mapper.js';
 import { TableMigrator } from './migrator.js';
+// DML Builder (Querying)
 export class FluentQueryBuilder {
     constructor(mapper, schemaName, connectionName) {
         this.mapper = mapper;
         this.schemaName = schemaName;
         try {
             this.query = mapper.use(schemaName);
+            // Auto-update connection if provided override
             if (connectionName) {
-                const def = this.getDef();
-                if (def)
-                    def.connectionName = 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 (Automatically schemas!)
+            // 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);
+        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;
+    }
+    to(update) {
+        this.query.to(update);
+        return this;
+    }
+    get(...fields) {
+        if (fields.length > 0) {
+            this.query.selectFields(fields);
+            return this;
+        }
+        return this.query.get();
+    }
+    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(data) {
+        if (data) {
+            this.query.to(data);
+        }
+        return this.query.update();
+    }
+    async delete() {
+        return this.query.delete();
+    }
+    async deleteOne() {
+        return this.query.deleteOne();
+    }
+    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) {
@@ -31,6 +112,16 @@ export class FluentQueryBuilder {
             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)
@@ -56,20 +147,10 @@ export class FluentQueryBuilder {
         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;
-    }
+    // Migration / DDL Methods
     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);
@@ -77,7 +158,6 @@ export class FluentQueryBuilder {
         }
         return this._migrator;
     }
-    // Migration/DDL Methods (Proxied to internal migrator)
     useConnection(name) {
         this.migrator.useConnection(name);
         const def = this.getDef();
@@ -92,69 +172,6 @@ export class FluentQueryBuilder {
     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();
-    }
 }
 export class FluentConnectionBuilder {
     constructor(mapper, connectionName, connectionType, config) {
@@ -175,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;
+    }
+    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;
     }
-    structure(structure) {
-        this.mapper.schema(this.schemaName)
-            .use({ connection: this.connectionName, collection: this.collectionName })
-            .setStructure(structure);
-        return new FluentMapper(this.mapper);
+    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 {
@@ -279,19 +362,19 @@ export class FluentConnectionSelector {
         this.connectionName = connectionName;
     }
     schema(schemaName) {
-        return new FluentQueryBuilder(this.mapper, schemaName, this.connectionName);
+        return new FluentSchemaBuilder(this.mapper, schemaName, this.connectionName);
     }
     schemas(schemaName) {
         return this.schema(schemaName);
     }
     query(schemaName) {
-        return this.schema(schemaName);
+        return new FluentQueryBuilder(this.mapper, schemaName, this.connectionName);
     }
     table(tableName) {
-        return this.schema(tableName);
+        return this.query(tableName);
     }
     collection(collectionName) {
-        return this.schema(collectionName);
+        return this.query(collectionName);
     }
     // API Request methods
     path(path) {
@@ -327,11 +410,17 @@ export class FluentMapper {
         return new FluentQueryBuilder(this.mapper, schemaName);
     }
     schema(name) {
-        return this.query(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);
     }
@@ -404,7 +493,13 @@ export class StaticMapper {
         return StaticMapper.schemas();
     }
     static table(name) {
-        return StaticMapper.schema(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) {

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.2",
+  "version": "1.7.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",