@neupgroup/mapper 1.2.1 → 1.2.2

package/dist/mapper.js

@@ -0,0 +1,144 @@
+import { Connections, SchemaManager } from './index';
+export class Mapper {
+    constructor() {
+        this.connections = new Connections();
+        this.schemaManager = new SchemaManager(this.connections);
+    }
+    static getInstance() {
+        if (!Mapper.instance) {
+            Mapper.instance = new Mapper();
+        }
+        return Mapper.instance;
+    }
+    // Auto-configuration based on environment or defaults
+    autoConfigure() {
+        // Check for environment variables or config files
+        const envConfig = this.detectEnvironmentConfig();
+        if (envConfig) {
+            this.applyConfig(envConfig);
+        }
+        else {
+            // Use sensible defaults
+            this.applyDefaultConfig();
+        }
+        return this;
+    }
+    detectEnvironmentConfig() {
+        // Check for common environment variables or config files
+        if (typeof process !== 'undefined' && process.env) {
+            // Node.js environment
+            const dbUrl = process.env.DATABASE_URL;
+            if (dbUrl) {
+                return {
+                    connection: {
+                        name: 'default',
+                        type: this.inferConnectionType(dbUrl),
+                        key: { url: dbUrl }
+                    }
+                };
+            }
+        }
+        // Check for browser environment with global config
+        if (typeof window !== 'undefined' && window.__MAPPER_CONFIG__) {
+            return window.__MAPPER_CONFIG__;
+        }
+        return null;
+    }
+    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 'api';
+    }
+    applyConfig(config) {
+        if (config.connection) {
+            const conn = config.connection;
+            this.connections.create(conn.name, conn.type).key(conn.key);
+        }
+        if (config.schemas) {
+            for (const schemaConfig of config.schemas) {
+                this.createSchema(schemaConfig);
+            }
+        }
+    }
+    applyDefaultConfig() {
+        // Create a default in-memory connection for quick start
+        this.connections.create('default', 'api').key({ endpoint: 'memory' });
+    }
+    createSchema(config) {
+        const builder = this.schemaManager.create(config.name);
+        if (config.connection && config.collection) {
+            builder.use({ connection: config.connection, collection: config.collection });
+        }
+        if (config.structure) {
+            builder.setStructure(config.structure);
+        }
+    }
+    // Simplified API methods
+    connect(name, type, config) {
+        this.connections.create(name, type).key(config);
+        return this;
+    }
+    schema(name) {
+        return this.schemaManager.create(name);
+    }
+    use(schemaName) {
+        return this.schemaManager.use(schemaName);
+    }
+    // Quick query methods
+    async get(schemaName, filters) {
+        const query = this.use(schemaName);
+        if (filters) {
+            Object.entries(filters).forEach(([field, value]) => {
+                query.where(field, value);
+            });
+        }
+        return query.get();
+    }
+    async getOne(schemaName, filters) {
+        const query = this.use(schemaName);
+        if (filters) {
+            Object.entries(filters).forEach(([field, value]) => {
+                query.where(field, value);
+            });
+        }
+        return query.getOne();
+    }
+    async add(schemaName, data) {
+        return this.use(schemaName).add(data);
+    }
+    async update(schemaName, filters, data) {
+        const query = this.use(schemaName);
+        Object.entries(filters).forEach(([field, value]) => {
+            query.where(field, value);
+        });
+        await query.to(data).update();
+    }
+    async delete(schemaName, filters) {
+        const query = this.use(schemaName);
+        Object.entries(filters).forEach(([field, value]) => {
+            query.where(field, value);
+        });
+        await query.delete();
+    }
+    // Get the underlying managers for advanced usage
+    getConnections() {
+        return this.connections;
+    }
+    getSchemaManager() {
+        return this.schemaManager;
+    }
+}
+// Create and configure the default instance
+export const createMapper = () => {
+    const mapper = Mapper.getInstance();
+    mapper.autoConfigure();
+    return mapper;
+};
+// Export a ready-to-use default instance
+export default createMapper();

package/dist/orm/index.d.ts

@@ -1,8 +1,8 @@
 import type { DbAdapter, QueryOptions } from './types';
 export declare function createOrm(adapter: DbAdapter): {
-    get(options: QueryOptions): Promise<import("@firebase/firestore").DocumentData[]>;
+    get(options: QueryOptions): Promise<import("./types").DocumentData[]>;
     getOne(options: QueryOptions): Promise<any>;
-    getDocuments(options: QueryOptions): Promise<import("@firebase/firestore").DocumentData[]>;
+    getDocuments(options: QueryOptions): Promise<import("./types").DocumentData[]>;
     addDocument(collectionName: string, data: Record<string, any>): Promise<string>;
     updateDocument(collectionName: string, docId: string, data: Record<string, any>): Promise<void>;
     deleteDocument(collectionName: string, docId: string): Promise<void>;

package/dist/orm/types.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentData } from 'firebase/firestore';
+export type DocumentData = Record<string, any>;
 export interface QueryOptions {
     collectionName: string;
     filters: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neupgroup/mapper",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Neup.Mapper core library for schema and mapping utilities",
   "type": "module",
   "main": "dist/index.js",
@@ -15,6 +15,9 @@
   },
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
   }
 }
-