@neupgroup/mapper 1.2.1 → 1.2.2

package/dist/config-wrapper.d.ts

@@ -0,0 +1,6 @@
+import { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper } from './config';
+import type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig } from './config';
+export { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper };
+export type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig };
+export declare const mapper: ConfigBasedMapper;
+export default mapper;

package/dist/config-wrapper.js

@@ -0,0 +1,7 @@
+import { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper } from './config';
+// Re-export the config-based system as the primary interface
+export { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper };
+// Create and export a default configured mapper instance
+export const mapper = createDefaultMapper();
+// Export the config-based mapper as the default export
+export default mapper;

package/dist/config.d.ts

@@ -0,0 +1,68 @@
+import { Connections, SchemaManager } from './index';
+export interface DatabaseConnectionConfig {
+    name: string;
+    type: 'mysql' | 'sql' | 'firestore' | 'mongodb';
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password?: string;
+    ssl?: boolean;
+    [key: string]: any;
+}
+export interface ApiConnectionConfig {
+    name: string;
+    type: 'api';
+    url: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    [key: string]: any;
+}
+export type ConnectionConfig = DatabaseConnectionConfig | ApiConnectionConfig;
+export interface ConfigSchema {
+    name: string;
+    connection: string;
+    collection: string;
+    structure?: Record<string, string> | Array<{
+        name: string;
+        type: 'string' | 'number' | 'boolean' | 'date' | 'int';
+        [key: string]: any;
+    }>;
+}
+export interface MapperConfig {
+    connections: ConnectionConfig[];
+    schemas?: ConfigSchema[];
+}
+export declare class ConfigLoader {
+    private static instance;
+    private config?;
+    static getInstance(): ConfigLoader;
+    load(config: MapperConfig): void;
+    loadFromFile(path: string): void;
+    getConfig(): MapperConfig | undefined;
+}
+export declare class ConfigBasedMapper {
+    private mapper;
+    private configLoader;
+    private initialized;
+    constructor();
+    configure(config: MapperConfig): this;
+    configureFromFile(path: string): this;
+    private initializeFromConfig;
+    private initializeConnection;
+    private initializeSchema;
+    getConnections(): Connections;
+    getSchemaManager(): SchemaManager;
+    use(schemaName: string): any;
+    schema(name: string): any;
+    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): import("./mapper").Mapper;
+    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>;
+}
+export declare function createConfigMapper(config?: MapperConfig): ConfigBasedMapper;
+export declare function getConfigMapper(): ConfigBasedMapper;
+export declare function createDefaultMapper(config?: MapperConfig): ConfigBasedMapper;
+export default ConfigBasedMapper;

package/dist/config.js

@@ -0,0 +1,234 @@
+import { createMapper } from './mapper';
+export class ConfigLoader {
+    static getInstance() {
+        if (!ConfigLoader.instance) {
+            ConfigLoader.instance = new ConfigLoader();
+        }
+        return ConfigLoader.instance;
+    }
+    load(config) {
+        this.config = config;
+    }
+    loadFromFile(path) {
+        try {
+            // In Node.js environment
+            if (typeof require !== 'undefined') {
+                const fs = require('fs');
+                const configData = fs.readFileSync(path, 'utf8');
+                this.config = JSON.parse(configData);
+            }
+            else {
+                // In browser environment, fetch the config file
+                fetch(path)
+                    .then(response => response.json())
+                    .then(config => {
+                    this.config = config;
+                })
+                    .catch((error) => {
+                    throw new Error(`Failed to load config from ${path}: ${error.message}`);
+                });
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load config from ${path}: ${error.message}`);
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+}
+export class ConfigBasedMapper {
+    constructor() {
+        this.initialized = false;
+        this.mapper = createMapper();
+        this.configLoader = ConfigLoader.getInstance();
+    }
+    configure(config) {
+        this.configLoader.load(config);
+        this.initializeFromConfig();
+        return this;
+    }
+    configureFromFile(path) {
+        this.configLoader.loadFromFile(path);
+        this.initializeFromConfig();
+        return this;
+    }
+    initializeFromConfig() {
+        const config = this.configLoader.getConfig();
+        if (!config) {
+            throw new Error('No configuration loaded');
+        }
+        // Initialize connections
+        for (const connectionConfig of config.connections) {
+            this.initializeConnection(connectionConfig);
+        }
+        // Initialize schemas
+        if (config.schemas) {
+            for (const schemaConfig of config.schemas) {
+                this.initializeSchema(schemaConfig);
+            }
+        }
+        this.initialized = true;
+    }
+    initializeConnection(config) {
+        const { name, type } = config;
+        if (type === 'api') {
+            const apiConfig = config;
+            this.mapper.connect(name, type, apiConfig);
+        }
+        else {
+            const dbConfig = config;
+            this.mapper.connect(name, type, dbConfig);
+        }
+    }
+    initializeSchema(config) {
+        const schemaBuilder = this.mapper.schema(config.name);
+        schemaBuilder.use({ connection: config.connection, collection: config.collection });
+        if (config.structure) {
+            schemaBuilder.setStructure(config.structure);
+        }
+    }
+    // Delegate methods to the underlying mapper
+    getConnections() {
+        return this.mapper.getConnections();
+    }
+    getSchemaManager() {
+        return this.mapper.getSchemaManager();
+    }
+    use(schemaName) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.use(schemaName);
+    }
+    schema(name) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.schema(name);
+    }
+    connect(name, type, config) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.connect(name, type, config);
+    }
+    // Quick query methods
+    async get(schemaName, filters) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.get(schemaName, filters);
+    }
+    async getOne(schemaName, filters) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.getOne(schemaName, filters);
+    }
+    async add(schemaName, data) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.add(schemaName, data);
+    }
+    async update(schemaName, filters, data) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.update(schemaName, filters, data);
+    }
+    async delete(schemaName, filters) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.delete(schemaName, filters);
+    }
+}
+// Create a default instance
+let defaultConfigMapper = null;
+export function createConfigMapper(config) {
+    const mapper = new ConfigBasedMapper();
+    if (config) {
+        mapper.configure(config);
+    }
+    defaultConfigMapper = mapper;
+    return mapper;
+}
+// Export a function to get the default instance
+export function getConfigMapper() {
+    if (!defaultConfigMapper) {
+        defaultConfigMapper = new ConfigBasedMapper();
+    }
+    return defaultConfigMapper;
+}
+// Create a default configured mapper instance
+export function createDefaultMapper(config) {
+    const mapper = new ConfigBasedMapper();
+    // If no config provided, try to load from environment or default locations
+    if (!config) {
+        // Try to load from environment
+        const envConfig = loadConfigFromEnvironment();
+        if (envConfig) {
+            mapper.configure(envConfig);
+        }
+        else {
+            // Try to load from default config file locations
+            const defaultPaths = ['./mapper.config.json', './config/mapper.json', '/etc/mapper/config.json'];
+            for (const path of defaultPaths) {
+                try {
+                    mapper.configureFromFile(path);
+                    break;
+                }
+                catch (error) {
+                    // Continue trying other paths
+                }
+            }
+        }
+    }
+    else {
+        mapper.configure(config);
+    }
+    return mapper;
+}
+function loadConfigFromEnvironment() {
+    if (typeof process !== 'undefined' && process.env) {
+        // Check for MAPPER_CONFIG environment variable
+        const envConfig = process.env.MAPPER_CONFIG;
+        if (envConfig) {
+            try {
+                return JSON.parse(envConfig);
+            }
+            catch (error) {
+                console.warn('Failed to parse MAPPER_CONFIG environment variable:', error);
+            }
+        }
+        // Check for individual database connection environment variables
+        const databaseUrl = process.env.DATABASE_URL;
+        if (databaseUrl) {
+            return {
+                connections: [{
+                        name: 'default',
+                        type: inferConnectionType(databaseUrl),
+                        host: databaseUrl,
+                        port: 5432,
+                        database: 'default',
+                        user: 'default'
+                    }]
+            };
+        }
+    }
+    return null;
+}
+function inferConnectionType(url) {
+    if (url.includes('mysql'))
+        return 'mysql';
+    if (url.includes('postgres') || url.includes('postgresql'))
+        return 'sql';
+    if (url.includes('mongodb'))
+        return 'mongodb';
+    if (url.includes('firestore'))
+        return 'firestore';
+    return 'sql'; // default to sql
+}
+export default ConfigBasedMapper;

package/dist/fluent-mapper.d.ts

@@ -0,0 +1,80 @@
+export declare class FluentQueryBuilder {
+    private mapper;
+    private schemaName;
+    private query;
+    constructor(mapper: any, schemaName: string);
+    where(field: string, value: any, operator?: string): this;
+    whereComplex(raw: string): this;
+    to(update: Record<string, any>): this;
+    get(): Promise<Record<string, any>[]>;
+    getOne(): Promise<Record<string, any> | null>;
+    add(data: Record<string, any>): Promise<any>;
+    update(): Promise<void>;
+    delete(): Promise<void>;
+    deleteOne(): Promise<void>;
+    updateOne(): Promise<void>;
+}
+export declare class FluentConnectionBuilder {
+    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 FluentConnectionSelector {
+    private mapper;
+    private connectionName;
+    constructor(mapper: any, connectionName: string);
+    schema(schemaName: string): FluentSchemaBuilder;
+    query(schemaName: string): FluentQueryBuilder;
+}
+export declare class FluentMapper {
+    private mapper;
+    constructor(mapper: any);
+    query(schemaName: string): FluentQueryBuilder;
+    makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    useConnection(connectionName: string): FluentConnectionSelector;
+    makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', 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>;
+}
+export declare class StaticMapper {
+    private static instance;
+    private static getFluentMapper;
+    static makeConnection(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    static useConnection(connectionName: string): FluentConnectionSelector;
+    static makeTempConnection(type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): FluentConnectionBuilder;
+    static query(schemaName: string): FluentQueryBuilder;
+    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>;
+}
+export declare const Mapper: typeof StaticMapper;
+export default Mapper;

package/dist/fluent-mapper.js

@@ -0,0 +1,171 @@
+import { createMapper } from './mapper.js';
+export class FluentQueryBuilder {
+    constructor(mapper, schemaName) {
+        this.mapper = mapper;
+        this.schemaName = schemaName;
+        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;
+    }
+    to(update) {
+        this.query.to(update);
+        return this;
+    }
+    async get() {
+        return this.query.get();
+    }
+    async getOne() {
+        return this.query.getOne();
+    }
+    async add(data) {
+        return this.mapper.add(this.schemaName, 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) {
+        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 FluentConnectionSelector {
+    constructor(mapper, connectionName) {
+        this.mapper = mapper;
+        this.connectionName = connectionName;
+    }
+    schema(schemaName) {
+        return new FluentSchemaBuilder(this.mapper, schemaName, this.connectionName);
+    }
+    query(schemaName) {
+        return new FluentQueryBuilder(this.mapper, schemaName);
+    }
+}
+export class FluentMapper {
+    constructor(mapper) {
+        this.mapper = mapper;
+    }
+    query(schemaName) {
+        return new FluentQueryBuilder(this.mapper, schemaName);
+    }
+    makeConnection(name, type, config) {
+        return new FluentConnectionBuilder(this.mapper, name, type, config);
+    }
+    useConnection(connectionName) {
+        return new FluentConnectionSelector(this.mapper, connectionName);
+    }
+    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);
+    }
+}
+// Static API class that provides the fluent interface
+export class StaticMapper {
+    static getFluentMapper() {
+        if (!StaticMapper.instance) {
+            const baseMapper = createMapper();
+            StaticMapper.instance = new FluentMapper(baseMapper);
+        }
+        return StaticMapper.instance;
+    }
+    static makeConnection(name, type, config) {
+        return StaticMapper.getFluentMapper().makeConnection(name, type, config);
+    }
+    static useConnection(connectionName) {
+        return StaticMapper.getFluentMapper().useConnection(connectionName);
+    }
+    static makeTempConnection(type, config) {
+        return StaticMapper.getFluentMapper().makeTempConnection(type, config);
+    }
+    static query(schemaName) {
+        return StaticMapper.getFluentMapper().query(schemaName);
+    }
+    // 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);
+    }
+}
+// Export a default instance for convenience
+export const Mapper = StaticMapper;
+export default Mapper;

package/dist/index.d.ts

@@ -89,3 +89,9 @@ export type { DbAdapter, QueryOptions };
 export { parseConnectionsDsl, toNormalizedConnections } from './env';
 export type { EnvDslConnections, NormalizedConnection } from './env';
 export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';
+export { Mapper, createMapper } from './mapper';
+export { default } from './mapper';
+export { StaticMapper } from './fluent-mapper';
+export type { FluentQueryBuilder, FluentConnectionBuilder, FluentSchemaBuilder, FluentSchemaCollectionBuilder, FluentConnectionSelector, FluentMapper } from './fluent-mapper';
+export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config';
+export type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig, ConfigSchema } from './config';

package/dist/index.js

@@ -278,3 +278,10 @@ export const schemas = (() => {
 export { createOrm } from './orm';
 export { parseConnectionsDsl, toNormalizedConnections } from './env';
 export { documentationMd, markdownToHtml, getDocumentationHtml } from './docs';
+// Export the simplified Mapper as default
+export { Mapper, createMapper } from './mapper';
+export { default } from './mapper';
+// Export the new fluent/static API
+export { StaticMapper } from './fluent-mapper';
+// Export the new config-based system
+export { ConfigBasedMapper, ConfigLoader, createConfigMapper, getConfigMapper, createDefaultMapper } from './config';

package/dist/mapper.d.ts

@@ -0,0 +1,27 @@
+import { Connections, SchemaManager } from './index';
+export declare class Mapper {
+    private connections;
+    private schemaManager;
+    private static instance;
+    constructor();
+    static getInstance(): Mapper;
+    autoConfigure(): this;
+    private detectEnvironmentConfig;
+    private inferConnectionType;
+    private applyConfig;
+    private applyDefaultConfig;
+    private createSchema;
+    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): this;
+    schema(name: string): ReturnType<SchemaManager['create']>;
+    use(schemaName: string): ReturnType<SchemaManager['use']>;
+    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>;
+    getConnections(): Connections;
+    getSchemaManager(): SchemaManager;
+}
+export declare const createMapper: () => Mapper;
+declare const _default: Mapper;
+export default _default;