@neupgroup/mapper 1.2.2 → 1.2.4

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

@@ -0,0 +1,45 @@
+import type { DbAdapter, QueryOptions, DocumentData } from '../orm/types';
+export interface APIAdapterConfig {
+    baseUrl: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    endpoints?: {
+        get?: string;
+        getOne?: string;
+        create?: string;
+        update?: string;
+        delete?: string;
+    };
+    queryParamMapping?: {
+        filters?: string;
+        limit?: string;
+        offset?: string;
+        sort?: string;
+        fields?: string;
+    };
+}
+/**
+ * REST API Adapter
+ * Works with standard REST APIs
+ */
+export declare class APIAdapter implements DbAdapter {
+    private config;
+    constructor(config: APIAdapterConfig);
+    private buildUrl;
+    private buildQueryParams;
+    private fetch;
+    get(options: QueryOptions): Promise<DocumentData[]>;
+    getOne(options: QueryOptions): Promise<DocumentData | null>;
+    getDocuments(options: QueryOptions): Promise<DocumentData[]>;
+    addDocument(collectionName: string, data: DocumentData): Promise<string>;
+    updateDocument(collectionName: string, docId: string, data: DocumentData): Promise<void>;
+    deleteDocument(collectionName: string, docId: string): Promise<void>;
+    /**
+     * Make a custom API request
+     */
+    request(method: string, endpoint: string, data?: any, customHeaders?: Record<string, string>): Promise<any>;
+}
+/**
+ * Factory function to create API adapter
+ */
+export declare function createAPIAdapter(config: APIAdapterConfig): APIAdapter;

package/dist/adapters/api-adapter.js

@@ -0,0 +1,170 @@
+/**
+ * REST API Adapter
+ * Works with standard REST APIs
+ */
+export class APIAdapter {
+    constructor(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        this.config = {
+            baseUrl: config.baseUrl.replace(/\/$/, ''), // Remove trailing slash
+            headers: config.headers || {},
+            timeout: config.timeout || 30000,
+            endpoints: {
+                get: ((_a = config.endpoints) === null || _a === void 0 ? void 0 : _a.get) || '/{collection}',
+                getOne: ((_b = config.endpoints) === null || _b === void 0 ? void 0 : _b.getOne) || '/{collection}/{id}',
+                create: ((_c = config.endpoints) === null || _c === void 0 ? void 0 : _c.create) || '/{collection}',
+                update: ((_d = config.endpoints) === null || _d === void 0 ? void 0 : _d.update) || '/{collection}/{id}',
+                delete: ((_e = config.endpoints) === null || _e === void 0 ? void 0 : _e.delete) || '/{collection}/{id}',
+            },
+            queryParamMapping: {
+                filters: ((_f = config.queryParamMapping) === null || _f === void 0 ? void 0 : _f.filters) || 'filter',
+                limit: ((_g = config.queryParamMapping) === null || _g === void 0 ? void 0 : _g.limit) || 'limit',
+                offset: ((_h = config.queryParamMapping) === null || _h === void 0 ? void 0 : _h.offset) || 'offset',
+                sort: ((_j = config.queryParamMapping) === null || _j === void 0 ? void 0 : _j.sort) || 'sort',
+                fields: ((_k = config.queryParamMapping) === null || _k === void 0 ? void 0 : _k.fields) || 'fields',
+            },
+        };
+    }
+    buildUrl(template, params) {
+        let url = template;
+        for (const [key, value] of Object.entries(params)) {
+            url = url.replace(`{${key}}`, encodeURIComponent(value));
+        }
+        return `${this.config.baseUrl}${url}`;
+    }
+    buildQueryParams(options) {
+        const params = new URLSearchParams();
+        // Add filters
+        if (options.filters.length > 0) {
+            const filterObj = {};
+            options.filters.forEach(f => {
+                filterObj[f.field] = { [f.operator || 'eq']: f.value };
+            });
+            params.append(this.config.queryParamMapping.filters, JSON.stringify(filterObj));
+        }
+        // Add raw where if present
+        if (options.rawWhere) {
+            params.append(this.config.queryParamMapping.filters, options.rawWhere);
+        }
+        // Add limit
+        if (options.limit !== null) {
+            params.append(this.config.queryParamMapping.limit, String(options.limit));
+        }
+        // Add offset
+        if (options.offset !== null) {
+            params.append(this.config.queryParamMapping.offset, String(options.offset));
+        }
+        // Add sort
+        if (options.sortBy) {
+            const sortValue = `${options.sortBy.direction === 'desc' ? '-' : ''}${options.sortBy.field}`;
+            params.append(this.config.queryParamMapping.sort, sortValue);
+        }
+        // Add fields
+        if (options.fields.length > 0) {
+            params.append(this.config.queryParamMapping.fields, options.fields.join(','));
+        }
+        return params;
+    }
+    async fetch(url, options = {}) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+        try {
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.config.headers,
+                    ...options.headers,
+                },
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API request failed: ${response.status} ${response.statusText}\n${errorText}`);
+            }
+            const contentType = response.headers.get('content-type');
+            if (contentType && contentType.includes('application/json')) {
+                return await response.json();
+            }
+            return await response.text();
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error.name === 'AbortError') {
+                throw new Error(`API request timeout after ${this.config.timeout}ms`);
+            }
+            throw error;
+        }
+    }
+    async get(options) {
+        const url = this.buildUrl(this.config.endpoints.get, {
+            collection: options.collectionName,
+        });
+        const params = this.buildQueryParams(options);
+        const fullUrl = `${url}?${params.toString()}`;
+        const response = await this.fetch(fullUrl, { method: 'GET' });
+        // Handle different response formats
+        if (Array.isArray(response)) {
+            return response;
+        }
+        if (response.data && Array.isArray(response.data)) {
+            return response.data;
+        }
+        if (response.results && Array.isArray(response.results)) {
+            return response.results;
+        }
+        return [response];
+    }
+    async getOne(options) {
+        const results = await this.get({ ...options, limit: 1 });
+        return results[0] || null;
+    }
+    async getDocuments(options) {
+        return this.get(options);
+    }
+    async addDocument(collectionName, data) {
+        var _a;
+        const url = this.buildUrl(this.config.endpoints.create, { collection: collectionName });
+        const response = await this.fetch(url, {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+        // Try to extract ID from response
+        return response.id || response._id || ((_a = response.data) === null || _a === void 0 ? void 0 : _a.id) || String(Date.now());
+    }
+    async updateDocument(collectionName, docId, data) {
+        const url = this.buildUrl(this.config.endpoints.update, {
+            collection: collectionName,
+            id: docId,
+        });
+        await this.fetch(url, {
+            method: 'PUT',
+            body: JSON.stringify(data),
+        });
+    }
+    async deleteDocument(collectionName, docId) {
+        const url = this.buildUrl(this.config.endpoints.delete, {
+            collection: collectionName,
+            id: docId,
+        });
+        await this.fetch(url, { method: 'DELETE' });
+    }
+    /**
+     * Make a custom API request
+     */
+    async request(method, endpoint, data, customHeaders) {
+        const url = `${this.config.baseUrl}${endpoint}`;
+        return this.fetch(url, {
+            method,
+            body: data ? JSON.stringify(data) : undefined,
+            headers: customHeaders,
+        });
+    }
+}
+/**
+ * Factory function to create API adapter
+ */
+export function createAPIAdapter(config) {
+    return new APIAdapter(config);
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,34 @@
+export { MySQLAdapter, createMySQLAdapter, type MySQLConfig } from './mysql-adapter.js';
+export { PostgreSQLAdapter, createPostgreSQLAdapter, type PostgreSQLConfig } from './postgres-adapter.js';
+export { MongoDBAdapter, createMongoDBAdapter, type MongoDBConfig } from './mongodb-adapter.js';
+export { APIAdapter, createAPIAdapter, type APIAdapterConfig } from './api-adapter.js';
+import type { DbAdapter } from '../orm/types.js';
+import { type MySQLConfig } from './mysql-adapter.js';
+import { type PostgreSQLConfig } from './postgres-adapter.js';
+import { type MongoDBConfig } from './mongodb-adapter.js';
+import { type APIAdapterConfig } from './api-adapter.js';
+export type AdapterConfig = {
+    type: 'mysql';
+    config: MySQLConfig;
+} | {
+    type: 'postgres' | 'postgresql' | 'sql';
+    config: PostgreSQLConfig;
+} | {
+    type: 'mongodb' | 'mongo';
+    config: MongoDBConfig;
+} | {
+    type: 'api' | 'rest';
+    config: APIAdapterConfig;
+};
+/**
+ * Auto-create adapter based on connection type
+ */
+export declare function createAdapter(adapterConfig: AdapterConfig): DbAdapter;
+/**
+ * Create adapter from connection URL
+ */
+export declare function createAdapterFromUrl(url: string): DbAdapter;
+/**
+ * Helper to auto-attach adapter to connection
+ */
+export declare function autoAttachAdapter(connections: any, connectionName: string, connectionType: string, connectionKey: any): void;

package/dist/adapters/index.js

@@ -0,0 +1,91 @@
+// Export all adapters
+export { MySQLAdapter, createMySQLAdapter } from './mysql-adapter.js';
+export { PostgreSQLAdapter, createPostgreSQLAdapter } from './postgres-adapter.js';
+export { MongoDBAdapter, createMongoDBAdapter } from './mongodb-adapter.js';
+export { APIAdapter, createAPIAdapter } from './api-adapter.js';
+import { createMySQLAdapter } from './mysql-adapter.js';
+import { createPostgreSQLAdapter } from './postgres-adapter.js';
+import { createMongoDBAdapter } from './mongodb-adapter.js';
+import { createAPIAdapter } from './api-adapter.js';
+/**
+ * Auto-create adapter based on connection type
+ */
+export function createAdapter(adapterConfig) {
+    switch (adapterConfig.type) {
+        case 'mysql':
+            return createMySQLAdapter(adapterConfig.config);
+        case 'postgres':
+        case 'postgresql':
+        case 'sql':
+            return createPostgreSQLAdapter(adapterConfig.config);
+        case 'mongodb':
+        case 'mongo':
+            return createMongoDBAdapter(adapterConfig.config);
+        case 'api':
+        case 'rest':
+            return createAPIAdapter(adapterConfig.config);
+        default:
+            throw new Error(`Unknown adapter type: ${adapterConfig.type}`);
+    }
+}
+/**
+ * Create adapter from connection URL
+ */
+export function createAdapterFromUrl(url) {
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol.replace(':', '');
+    switch (protocol) {
+        case 'mysql':
+            return createMySQLAdapter({
+                host: urlObj.hostname,
+                port: urlObj.port ? parseInt(urlObj.port) : 3306,
+                user: urlObj.username,
+                password: urlObj.password,
+                database: urlObj.pathname.replace('/', ''),
+            });
+        case 'postgres':
+        case 'postgresql':
+            return createPostgreSQLAdapter({
+                host: urlObj.hostname,
+                port: urlObj.port ? parseInt(urlObj.port) : 5432,
+                user: urlObj.username,
+                password: urlObj.password,
+                database: urlObj.pathname.replace('/', ''),
+            });
+        case 'mongodb':
+            return createMongoDBAdapter({
+                uri: url,
+                database: urlObj.pathname.replace('/', ''),
+            });
+        case 'http':
+        case 'https':
+            return createAPIAdapter({
+                baseUrl: url,
+            });
+        default:
+            throw new Error(`Unsupported protocol: ${protocol}`);
+    }
+}
+/**
+ * Helper to auto-attach adapter to connection
+ */
+export function autoAttachAdapter(connections, connectionName, connectionType, connectionKey) {
+    try {
+        let adapter;
+        // If connectionKey has a URL, use it
+        if (connectionKey.url) {
+            adapter = createAdapterFromUrl(connectionKey.url);
+        }
+        else {
+            // Create adapter based on type
+            adapter = createAdapter({
+                type: connectionType,
+                config: connectionKey,
+            });
+        }
+        connections.attachAdapter(connectionName, adapter);
+    }
+    catch (error) {
+        console.warn(`Failed to auto-attach adapter for ${connectionName}:`, error.message);
+    }
+}

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

@@ -0,0 +1,56 @@
+import type { DbAdapter, QueryOptions, DocumentData } from '../orm/types';
+export interface MongoDBConfig {
+    uri: string;
+    database: string;
+    options?: {
+        maxPoolSize?: number;
+        minPoolSize?: number;
+        serverSelectionTimeoutMS?: number;
+    };
+}
+/**
+ * MongoDB Database Adapter
+ * Requires: npm install mongodb
+ */
+export declare class MongoDBAdapter implements DbAdapter {
+    private config;
+    private client;
+    private db;
+    private mongodb;
+    constructor(config: MongoDBConfig);
+    /**
+     * Connect to MongoDB
+     */
+    connect(): Promise<void>;
+    /**
+     * Ensure connection is established
+     */
+    private ensureConnected;
+    private buildMongoQuery;
+    get(options: QueryOptions): Promise<DocumentData[]>;
+    getOne(options: QueryOptions): Promise<DocumentData | null>;
+    getDocuments(options: QueryOptions): Promise<DocumentData[]>;
+    addDocument(collectionName: string, data: DocumentData): Promise<string>;
+    updateDocument(collectionName: string, docId: string, data: DocumentData): Promise<void>;
+    deleteDocument(collectionName: string, docId: string): Promise<void>;
+    /**
+     * Close the MongoDB connection
+     */
+    close(): Promise<void>;
+    /**
+     * Execute aggregation pipeline
+     */
+    aggregate(collectionName: string, pipeline: any[]): Promise<DocumentData[]>;
+    /**
+     * Create an index
+     */
+    createIndex(collectionName: string, fields: any, options?: any): Promise<string>;
+    /**
+     * Get collection statistics
+     */
+    getStats(collectionName: string): Promise<any>;
+}
+/**
+ * Factory function to create MongoDB adapter
+ */
+export declare function createMongoDBAdapter(config: MongoDBConfig): MongoDBAdapter;

package/dist/adapters/mongodb-adapter.js

@@ -0,0 +1,227 @@
+/**
+ * MongoDB Database Adapter
+ * Requires: npm install mongodb
+ */
+export class MongoDBAdapter {
+    constructor(config) {
+        this.config = config;
+        try {
+            // Dynamically import mongodb to avoid bundling if not used
+            this.mongodb = require('mongodb');
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize MongoDB adapter: ${error.message}\n` +
+                `Make sure to install mongodb: npm install mongodb`);
+        }
+    }
+    /**
+     * Connect to MongoDB
+     */
+    async connect() {
+        var _a, _b, _c;
+        if (this.client)
+            return;
+        const { MongoClient } = this.mongodb;
+        this.client = new MongoClient(this.config.uri, {
+            maxPoolSize: ((_a = this.config.options) === null || _a === void 0 ? void 0 : _a.maxPoolSize) || 10,
+            minPoolSize: ((_b = this.config.options) === null || _b === void 0 ? void 0 : _b.minPoolSize) || 2,
+            serverSelectionTimeoutMS: ((_c = this.config.options) === null || _c === void 0 ? void 0 : _c.serverSelectionTimeoutMS) || 5000,
+        });
+        await this.client.connect();
+        this.db = this.client.db(this.config.database);
+    }
+    /**
+     * Ensure connection is established
+     */
+    async ensureConnected() {
+        if (!this.client) {
+            await this.connect();
+        }
+    }
+    buildMongoQuery(options) {
+        const query = {};
+        // Handle raw WHERE clause
+        if (options.rawWhere) {
+            try {
+                return JSON.parse(options.rawWhere);
+            }
+            catch {
+                return {};
+            }
+        }
+        // Build query from filters
+        for (const filter of options.filters) {
+            const { field, operator, value } = filter;
+            switch (operator) {
+                case '=':
+                    query[field] = value;
+                    break;
+                case '>':
+                    query[field] = { $gt: value };
+                    break;
+                case '<':
+                    query[field] = { $lt: value };
+                    break;
+                case '>=':
+                    query[field] = { $gte: value };
+                    break;
+                case '<=':
+                    query[field] = { $lte: value };
+                    break;
+                case '!=':
+                    query[field] = { $ne: value };
+                    break;
+                case 'IN':
+                    query[field] = { $in: Array.isArray(value) ? value : [value] };
+                    break;
+                case 'LIKE':
+                    // Convert SQL LIKE to MongoDB regex
+                    const pattern = value.replace(/%/g, '.*').replace(/_/g, '.');
+                    query[field] = { $regex: new RegExp(pattern, 'i') };
+                    break;
+                default:
+                    query[field] = value;
+            }
+        }
+        return query;
+    }
+    async get(options) {
+        await this.ensureConnected();
+        const collection = this.db.collection(options.collectionName);
+        const query = this.buildMongoQuery(options);
+        let cursor = collection.find(query);
+        // Add projection (field selection)
+        if (options.fields.length > 0) {
+            const projection = {};
+            options.fields.forEach(field => {
+                projection[field] = 1;
+            });
+            cursor = cursor.project(projection);
+        }
+        // Add sorting
+        if (options.sortBy) {
+            const sort = {};
+            sort[options.sortBy.field] = options.sortBy.direction === 'asc' ? 1 : -1;
+            cursor = cursor.sort(sort);
+        }
+        // Add limit and offset
+        if (options.offset !== null) {
+            cursor = cursor.skip(options.offset);
+        }
+        if (options.limit !== null) {
+            cursor = cursor.limit(options.limit);
+        }
+        const results = await cursor.toArray();
+        // Convert _id to string for consistency
+        return results.map((doc) => {
+            var _a;
+            return ({
+                ...doc,
+                _id: (_a = doc._id) === null || _a === void 0 ? void 0 : _a.toString(),
+            });
+        });
+    }
+    async getOne(options) {
+        var _a;
+        await this.ensureConnected();
+        const collection = this.db.collection(options.collectionName);
+        const query = this.buildMongoQuery(options);
+        const projection = {};
+        if (options.fields.length > 0) {
+            options.fields.forEach(field => {
+                projection[field] = 1;
+            });
+        }
+        const result = await collection.findOne(query, { projection });
+        if (!result)
+            return null;
+        return {
+            ...result,
+            _id: (_a = result._id) === null || _a === void 0 ? void 0 : _a.toString(),
+        };
+    }
+    async getDocuments(options) {
+        return this.get(options);
+    }
+    async addDocument(collectionName, data) {
+        await this.ensureConnected();
+        const collection = this.db.collection(collectionName);
+        const result = await collection.insertOne(data);
+        return result.insertedId.toString();
+    }
+    async updateDocument(collectionName, docId, data) {
+        await this.ensureConnected();
+        const collection = this.db.collection(collectionName);
+        const { ObjectId } = this.mongodb;
+        // Try to convert docId to ObjectId, fallback to string
+        let query;
+        try {
+            query = { _id: new ObjectId(docId) };
+        }
+        catch {
+            query = { _id: docId };
+        }
+        await collection.updateOne(query, { $set: data });
+    }
+    async deleteDocument(collectionName, docId) {
+        await this.ensureConnected();
+        const collection = this.db.collection(collectionName);
+        const { ObjectId } = this.mongodb;
+        // Try to convert docId to ObjectId, fallback to string
+        let query;
+        try {
+            query = { _id: new ObjectId(docId) };
+        }
+        catch {
+            query = { _id: docId };
+        }
+        await collection.deleteOne(query);
+    }
+    /**
+     * Close the MongoDB connection
+     */
+    async close() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+            this.db = null;
+        }
+    }
+    /**
+     * Execute aggregation pipeline
+     */
+    async aggregate(collectionName, pipeline) {
+        await this.ensureConnected();
+        const collection = this.db.collection(collectionName);
+        const results = await collection.aggregate(pipeline).toArray();
+        return results.map((doc) => {
+            var _a;
+            return ({
+                ...doc,
+                _id: (_a = doc._id) === null || _a === void 0 ? void 0 : _a.toString(),
+            });
+        });
+    }
+    /**
+     * Create an index
+     */
+    async createIndex(collectionName, fields, options) {
+        await this.ensureConnected();
+        const collection = this.db.collection(collectionName);
+        return await collection.createIndex(fields, options);
+    }
+    /**
+     * Get collection statistics
+     */
+    async getStats(collectionName) {
+        await this.ensureConnected();
+        const collection = this.db.collection(collectionName);
+        return await collection.stats();
+    }
+}
+/**
+ * Factory function to create MongoDB adapter
+ */
+export function createMongoDBAdapter(config) {
+    return new MongoDBAdapter(config);
+}

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

@@ -0,0 +1,38 @@
+import type { DbAdapter, QueryOptions, DocumentData } from '../orm/types';
+export interface MySQLConfig {
+    host: string;
+    port?: number;
+    user: string;
+    password: string;
+    database: string;
+    connectionLimit?: number;
+    ssl?: boolean;
+}
+/**
+ * MySQL Database Adapter
+ * Requires: npm install mysql2
+ */
+export declare class MySQLAdapter implements DbAdapter {
+    private pool;
+    private mysql;
+    constructor(config: MySQLConfig);
+    private buildWhereClause;
+    get(options: QueryOptions): Promise<DocumentData[]>;
+    getOne(options: QueryOptions): Promise<DocumentData | null>;
+    getDocuments(options: QueryOptions): Promise<DocumentData[]>;
+    addDocument(collectionName: string, data: DocumentData): Promise<string>;
+    updateDocument(collectionName: string, docId: string, data: DocumentData): Promise<void>;
+    deleteDocument(collectionName: string, docId: string): Promise<void>;
+    /**
+     * Close all connections in the pool
+     */
+    close(): Promise<void>;
+    /**
+     * Execute a raw SQL query
+     */
+    raw(sql: string, values?: any[]): Promise<any>;
+}
+/**
+ * Factory function to create MySQL adapter
+ */
+export declare function createMySQLAdapter(config: MySQLConfig): MySQLAdapter;