@medyll/idae-api 0.24.0 → 0.26.0

package/dist/client/IdaeApiClient.d.ts

@@ -1,6 +1,6 @@
-import { type IdaeApiClientConfigCoreOptions } from './IdaeApiClientConfig';
-import { IdaeApiClientCollection } from './IdaeApiClientCollection';
-import { IdaeApiClientRequest } from './IdaeApiClientRequest';
+import { type IdaeApiClientConfigCoreOptions } from "./IdaeApiClientConfig.js";
+import { IdaeApiClientCollection } from "./IdaeApiClientCollection.js";
+import { IdaeApiClientRequest } from "./IdaeApiClientRequest.js";
 type IdaeApiClientRequestParams<T = any> = Record<string, T>;
 declare class IdaeApiClient {
     private clientConfig;

package/dist/client/IdaeApiClient.js

@@ -1,7 +1,7 @@
 // packages\idae-api\src\lib\client\IdaeApiClient.ts
-import { IdaeApiClientConfig, IdaeApiClientConfigCore } from './IdaeApiClientConfig';
-import { IdaeApiClientCollection } from './IdaeApiClientCollection';
-import { IdaeApiClientRequest } from './IdaeApiClientRequest';
+import { IdaeApiClientConfig, IdaeApiClientConfigCore, } from "./IdaeApiClientConfig.js";
+import { IdaeApiClientCollection } from "./IdaeApiClientCollection.js";
+import { IdaeApiClientRequest } from "./IdaeApiClientRequest.js";
 class IdaeApiClient {
     constructor(clientConfig) {
         this.clientConfig = IdaeApiClientConfig;
@@ -12,15 +12,18 @@ class IdaeApiClient {
         return this._request;
     }
     async getDbList() {
-        return this._request.doRequest({ routeNamespace: 'methods/dbs' });
+        return this._request.doRequest({ routeNamespace: "methods/dbs" });
     }
     async getCollections(dbName) {
-        return this._request.doRequest({ dbName, routeNamespace: 'methods/collections' });
+        return this._request.doRequest({
+            dbName,
+            routeNamespace: "methods/collections",
+        });
     }
     db(dbName) {
         return {
             collection: (collectionName) => new IdaeApiClientCollection(this, dbName, collectionName),
-            getCollections: () => this.getCollections(dbName)
+            getCollections: () => this.getCollections(dbName),
         };
     }
     collection(collectionName, dbName) {

package/dist/client/IdaeApiClientCollection.d.ts

@@ -1,5 +1,5 @@
-import { IdaeApiClient } from './IdaeApiClient';
-import type { IdaeApiClientRequestParams } from './IdaeApiClient';
+import { IdaeApiClient } from "./IdaeApiClient.js";
+import type { IdaeApiClientRequestParams } from "./IdaeApiClient.js";
 declare class IdaeApiClientCollection {
     private apiClient;
     private meta;

package/dist/client/IdaeApiClientCollection.js

@@ -1,52 +1,52 @@
 // packages\idae-api\src\lib\client\IdaeApiClientCollection.ts
-import { IdaeApiClient } from './IdaeApiClient';
+import { IdaeApiClient } from "./IdaeApiClient.js";
 class IdaeApiClientCollection {
     constructor(apiClient, dbName, collectionName) {
         this.apiClient = apiClient;
         this.meta = {
             dbName,
-            collectionName
+            collectionName,
         };
     }
     async findAll(params) {
         return this.apiClient.request.doRequest({
             ...this.meta,
-            params
+            params,
         });
     }
     async findById(id) {
         return this.apiClient.request.doRequest({
             ...this.meta,
-            slug: id
+            slug: id,
         });
     }
     async create(body) {
         return this.apiClient.request.doRequest({
-            method: 'POST',
+            method: "POST",
             ...this.meta,
-            body
+            body,
         });
     }
     async update(id, body) {
         return this.apiClient.request.doRequest({
-            method: 'PUT',
+            method: "PUT",
             ...this.meta,
             body,
-            slug: id
+            slug: id,
         });
     }
     async deleteById(id) {
         return this.apiClient.request.doRequest({
-            method: 'DELETE',
+            method: "DELETE",
             ...this.meta,
-            slug: id
+            slug: id,
         });
     }
     async deleteManyByQuery(params) {
         return this.apiClient.request.doRequest({
-            method: 'DELETE',
+            method: "DELETE",
             ...this.meta,
-            params
+            params,
         });
     }
 }

package/dist/client/IdaeApiClientRequest.d.ts

@@ -1,6 +1,6 @@
-import { IdaeApiClientConfigCore } from './IdaeApiClientConfig';
-type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-type RouteNamespace = `methods/${'dbs' | 'collections'}` | undefined;
+import { IdaeApiClientConfigCore } from "./IdaeApiClientConfig.js";
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+type RouteNamespace = `methods/${"dbs" | "collections"}` | undefined;
 interface UrlParams {
     dbName?: string;
     collectionName?: string;
@@ -12,13 +12,13 @@ interface RequestOptions<T> extends UrlParams {
     baseUrl?: string;
     method?: HttpMethod;
     body?: T;
-    headers?: RequestInit['headers'];
+    headers?: RequestInit["headers"];
 }
 declare class IdaeApiClientRequest {
     private baseUrl;
     private clientConfig;
     constructor(clientConfig: IdaeApiClientConfigCore);
-    doRequest<T>({ baseUrl, method, body, headers, dbName, collectionName, slug, params, routeNamespace }: RequestOptions<T>): Promise<Response>;
+    doRequest<T>({ baseUrl, method, body, headers, dbName, collectionName, slug, params, routeNamespace, }: RequestOptions<T>): Promise<Response>;
     private buildUrl;
 }
-export { IdaeApiClientRequest, type HttpMethod, type RouteNamespace, type UrlParams, type RequestOptions };
+export { IdaeApiClientRequest, type HttpMethod, type RouteNamespace, type UrlParams, type RequestOptions, };

package/dist/client/IdaeApiClientRequest.js

@@ -1,24 +1,24 @@
 // packages\idae-api\src\lib\client\IdaeApiClientRequest.ts
-import { IdaeApiClientConfigCore } from './IdaeApiClientConfig';
+import { IdaeApiClientConfigCore } from "./IdaeApiClientConfig.js";
 class IdaeApiClientRequest {
     constructor(clientConfig) {
         this.clientConfig = clientConfig;
         this.baseUrl = `${this.clientConfig.method}:${this.clientConfig.separator}${this.clientConfig.host}:${this.clientConfig.port}`;
     }
-    async doRequest({ baseUrl = this.baseUrl, method = 'GET', body, headers = {
-        'Content-Type': 'application/json'
-    }, dbName = this.clientConfig.defaultDb, collectionName, slug, params, routeNamespace }) {
+    async doRequest({ baseUrl = this.baseUrl, method = "GET", body, headers = {
+        "Content-Type": "application/json",
+    }, dbName = this.clientConfig.defaultDb, collectionName, slug, params, routeNamespace, }) {
         const url = this.buildUrl({
             routeNamespace,
             dbName,
             collectionName,
             slug,
-            params
-        }).replace('//', '/');
+            params,
+        }).replace("//", "/");
         const response = await fetch(`${baseUrl}${url}`, {
             method,
             headers,
-            body: body ? JSON.stringify(body) : undefined
+            body: body ? JSON.stringify(body) : undefined,
         });
         if (!response.ok) {
             throw new Error(`HTTP error! status: ${response.status}`);
@@ -31,17 +31,17 @@ class IdaeApiClientRequest {
             throw new Error(`Invalid returned type`);
         }
     }
-    buildUrl({ dbName, collectionName, slug, params, routeNamespace }) {
+    buildUrl({ dbName, collectionName, slug, params, routeNamespace, }) {
         const urls = [`/`];
         if (routeNamespace)
             urls.push(routeNamespace);
         if (dbName ?? collectionName)
-            urls.push([dbName, collectionName].filter((x) => x).join('.'));
+            urls.push([dbName, collectionName].filter((x) => x).join("."));
         if (slug)
             urls.push(slug);
         if (params)
             urls.push(`?${new URLSearchParams(params).toString()}`);
-        return urls.join('/').replace('//', '/');
+        return urls.join("/").replace("//", "/");
     }
 }
-export { IdaeApiClientRequest };
+export { IdaeApiClientRequest, };

package/dist/config/routeDefinitions.d.ts

@@ -1,4 +1,4 @@
-import { DBaseService } from '../server/services/DBaseService';
+import { DBaseService } from "../server/services/DBaseService.js";
 type RouteHandler = (service: DBaseService<any>, params: any, body?: any) => Promise<any>;
 export interface RouteDefinition {
     method: string | string[];

package/dist/config/routeDefinitions.js

@@ -1,48 +1,50 @@
 // packages\idae-api\src\lib\config\routeDefinitions.ts
-import { DBaseService } from '../server/services/DBaseService';
+import { DBaseService } from "../server/services/DBaseService.js";
 export const routes = [
     {
-        method: 'get',
-        path: '/:collectionName',
-        handler: async (service, params) => service.where(params)
+        method: "get",
+        path: "/:collectionName",
+        handler: async (service, params) => service.where(params),
     },
     {
-        method: 'get',
-        path: '/:collectionName/:id',
-        handler: async (service, params) => service.findById(params.id)
+        method: "get",
+        path: "/:collectionName/:id",
+        handler: async (service, params) => service.findById(params.id),
     },
     {
-        method: 'post',
-        path: '/:collectionName',
-        handler: async (service, params, body) => service.create(body)
+        method: "post",
+        path: "/:collectionName",
+        handler: async (service, params, body) => service.create(body),
     },
     {
-        method: 'put',
-        path: '/:collectionName/:id',
-        handler: async (service, params, body) => service.update(params.id, body)
+        method: "put",
+        path: "/:collectionName/:id",
+        handler: async (service, params, body) => service.update(params.id, body),
     },
     {
-        method: 'delete',
-        path: '/:collectionName/:id',
-        handler: async (service, params) => service.deleteById(params.id)
+        method: "delete",
+        path: "/:collectionName/:id",
+        handler: async (service, params) => service.deleteById(params.id),
     },
     {
-        method: 'delete',
-        path: '/:collectionName',
-        handler: async (service, params) => service.deleteManyByQuery(params)
+        method: "delete",
+        path: "/:collectionName",
+        handler: async (service, params) => service.deleteManyByQuery(params),
     },
     {
-        method: ['where', 'create', 'update', 'deleteById', 'deleteManyByQuery'], // default method is then GET or OPTIONS (set further)
-        path: '/query/:collectionName/:command/:parameters?',
+        method: ["where", "create", "update", "deleteById", "deleteManyByQuery"], // default method is then GET or OPTIONS (set further)
+        path: "/query/:collectionName/:command/:parameters?",
         handler: async (service, params, body) => {
-            const decodedParams = params.body ? service.decodeUrlParams(params.body) : {};
-            console.log(params.command, 'params --- ', { body });
+            const decodedParams = params.body
+                ? service.decodeUrlParams(params.body)
+                : {};
+            console.log(params.command, "params --- ", { body });
             return service?.[params.command]?.({ query: body });
-        }
+        },
     },
     {
-        method: ['dbs', 'collections'], // default method is then GET or OPTIONS (set further)
-        path: '/methods/:methodName/:params?',
-        handler: async (service, params) => { }
-    }
+        method: ["dbs", "collections"], // default method is then GET or OPTIONS (set further)
+        path: "/methods/:methodName/:params?",
+        handler: async (service, params) => { },
+    },
 ];

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-export * from './idae-api.d.js';
 export * from './server/IdaeApi.js';
 export * from './config/routeDefinitions.js';
 export * from './client/IdaeApiClientRequest.js';

package/dist/index.js

@@ -1,5 +1,4 @@
 // auto exports of entry components
-export * from './idae-api.d.js';
 export * from './server/IdaeApi.js';
 export * from './config/routeDefinitions.js';
 export * from './client/IdaeApiClientRequest.js';

package/dist/server/IdaeApi.d.ts

@@ -1,10 +1,10 @@
-import express from 'express';
-import { type RouteDefinition } from '../config/routeDefinitions';
-import { RouteManager } from './engine/routeManager';
+import express from "express";
+import { type RouteDefinition } from "../config/routeDefinitions.js";
+import { RouteManager } from "./engine/routeManager.js";
 interface IdaeApiOptions {
     port?: number;
     routes?: RouteDefinition[];
-    onInUse?: 'reboot' | 'fail' | 'replace';
+    onInUse?: "reboot" | "fail" | "replace";
     enableAuth?: boolean;
     jwtSecret?: string;
     tokenExpiration?: string;
@@ -19,7 +19,7 @@ declare class IdaeApi {
     private authMiddleware;
     private constructor();
     static getInstance(): IdaeApi;
-    get state(): 'stopped' | 'running';
+    get state(): "stopped" | "running";
     get app(): express.Express;
     setOptions(options: IdaeApiOptions): void;
     private initializeAuth;

package/dist/server/IdaeApi.js

@@ -1,14 +1,14 @@
 // packages\idae-api\src\lib\IdaeApi.ts
 // version feat
-import express, {} from 'express';
-import { databaseMiddleware } from './middleware/databaseMiddleware';
-import { DBaseService } from './services/DBaseService';
-import { routes as defaultRoutes } from '../config/routeDefinitions';
-import { AuthMiddleWare } from './middleware/authMiddleware';
-import { RouteManager } from './engine/routeManager';
+import express, {} from "express";
+import { databaseMiddleware } from "./middleware/databaseMiddleware.js";
+import { DBaseService } from "./services/DBaseService.js";
+import { routes as defaultRoutes, } from "../config/routeDefinitions.js";
+import { AuthMiddleWare } from "./middleware/authMiddleware.js";
+import { RouteManager } from "./engine/routeManager.js";
 class IdaeApi {
     constructor() {
-        this._state = 'stopped';
+        this._state = "stopped";
         this.authMiddleware = null;
         this._app = express();
         this.options = {};
@@ -32,7 +32,9 @@ class IdaeApi {
         this.options = { ...this.options, ...options };
     }
     initializeAuth() {
-        if (this.options.enableAuth && this.options.jwtSecret && this.options.tokenExpiration) {
+        if (this.options.enableAuth &&
+            this.options.jwtSecret &&
+            this.options.tokenExpiration) {
             this.authMiddleware = new AuthMiddleWare(this.options.jwtSecret, this.options.tokenExpiration);
         }
     }
@@ -42,7 +44,7 @@ class IdaeApi {
         this.configureErrorHandling();
     }
     configureMiddleware() {
-        this._app.use('/:collectionName', databaseMiddleware);
+        this._app.use("/:collectionName", databaseMiddleware);
         this._app.use(express.json());
         this._app.use(express.urlencoded({ extended: true }));
         if (this.authMiddleware) {
@@ -66,35 +68,35 @@ class IdaeApi {
         });
     }
     start() {
-        if (this._state === 'running') {
-            console.log('Server is already running.');
+        if (this._state === "running") {
+            console.log("Server is already running.");
             return;
         }
         const port = this.options.port || 3000;
         this.serverInstance = this._app.listen(port, () => {
             console.log(`Server is running on port: ${port}`);
-            this._state = 'running';
+            this._state = "running";
         });
-        this.serverInstance.on('error', this.handleServerError.bind(this));
+        this.serverInstance.on("error", this.handleServerError.bind(this));
     }
     handleServerError(error) {
-        if (error.code === 'EADDRINUSE') {
+        if (error.code === "EADDRINUSE") {
             console.error(`Port ${this.options.port} is already in use.`);
             switch (this.options.onInUse) {
-                case 'reboot':
-                    console.log('Rebooting server...');
+                case "reboot":
+                    console.log("Rebooting server...");
                     setTimeout(() => {
                         this.stop();
                         this.start();
                     }, 1000);
                     break;
-                case 'replace':
-                    console.log('Replacing existing server...');
+                case "replace":
+                    console.log("Replacing existing server...");
                     this.stop();
                     this.start();
                     break;
                 default:
-                    console.log('Failed to start the server.');
+                    console.log("Failed to start the server.");
                     process.exit(1);
             }
         }
@@ -106,11 +108,11 @@ class IdaeApi {
         if (this.serverInstance) {
             this.serverInstance.close((err) => {
                 if (err) {
-                    console.error('Error while stopping the server:', err);
+                    console.error("Error while stopping the server:", err);
                 }
                 else {
-                    console.log('Server stopped successfully.');
-                    this._state = 'stopped';
+                    console.log("Server stopped successfully.");
+                    this._state = "stopped";
                 }
             });
         }
@@ -137,12 +139,12 @@ class IdaeApi {
                 const { collectionName } = req.params;
                 const connection = req.dbConnection;
                 if (!connection) {
-                    throw new Error('Database connection not established');
+                    throw new Error("Database connection not established");
                 }
-                console.log('----------------------------------------------');
+                console.log("----------------------------------------------");
                 console.log(req.body);
                 console.log(req.params);
-                const databaseService = new DBaseService(collectionName, connection, 'mongodb');
+                const databaseService = new DBaseService(collectionName, connection, "mongodb");
                 const result = await action(databaseService, req.params, req.body);
                 res.json(result);
             }

package/dist/server/adapters/MongoDBAdapter.d.ts

@@ -1,6 +1,7 @@
-import type { ApiServerRequestParams } from '../engine/types';
-import type { Model, Document } from 'mongoose';
-import mongoose from 'mongoose';
+import type { ApiServerRequestParams } from "../engine/types.js";
+import type { Model, Document } from "mongoose";
+import mongoose from "mongoose";
+import type { DatabaseAdapter } from "./types.js";
 export declare class MongoDBAdapter<T extends Document> implements DatabaseAdapter<T> {
     private model;
     private connection;

package/dist/server/adapters/MongoDBAdapter.js

@@ -1,6 +1,6 @@
 // packages\idae-api\src\lib\adapters\MongoDBAdapter.ts
-import dotenv from 'dotenv';
-import mongoose, { Schema } from 'mongoose';
+import dotenv from "dotenv";
+import mongoose, { Schema } from "mongoose";
 // Load environment variables
 dotenv.config();
 // MongoDB Adapter
@@ -15,7 +15,7 @@ export class MongoDBAdapter {
             }
         };
         // just in case
-        collection = collection.split('.')[1] ?? collection.split('.')[0];
+        collection = collection.split(".")[1] ?? collection.split(".")[0];
         this.connection = connection;
         this.model = this.getModel(collection);
     }
@@ -39,7 +39,9 @@ export class MongoDBAdapter {
         return this.model.findOne(params.query);
     }
     async update(id, updateData) {
-        return this.model.findByIdAndUpdate(id, updateData, { new: true });
+        return this.model.findByIdAndUpdate(id, updateData, {
+            new: true,
+        });
     }
     async deleteById(id) {
         return this.model.findByIdAndDelete(id);
@@ -51,10 +53,10 @@ export class MongoDBAdapter {
     parseSortOptions(sortBy) {
         const sortOptions = {};
         if (sortBy) {
-            const sortFields = sortBy.split(',');
+            const sortFields = sortBy.split(",");
             sortFields.forEach((field) => {
-                const [key, order] = field.split(':');
-                sortOptions[key] = order === 'desc' ? -1 : 1;
+                const [key, order] = field.split(":");
+                sortOptions[key] = order === "desc" ? -1 : 1;
             });
         }
         return sortOptions;

package/dist/server/engine/DatabaseManager.d.ts

@@ -1,5 +1,5 @@
-import mongoose from 'mongoose';
-import type { Request } from 'express';
+import mongoose from "mongoose";
+import type { Request } from "express";
 export interface DatabaseConfig {
     port: number;
     host: string;

package/dist/server/engine/DatabaseManager.js

@@ -1,7 +1,7 @@
 // packages\idae-api\src\lib\engine\DatabaseManager.ts
-import mongoose from 'mongoose';
-import dotenv from 'dotenv';
-import { mongooseConnectionManager } from './mongooseConnectionManager';
+import mongoose from "mongoose";
+import dotenv from "dotenv";
+import { mongooseConnectionManager, } from "./mongooseConnectionManager.js";
 // Load environment variables
 dotenv.config();
 class DatabaseManager {
@@ -9,9 +9,9 @@ class DatabaseManager {
         this.mongooseConnectionManager = mongooseConnectionManager;
         this.config = {
             port: Number(process.env.MONGODB_DEFAULT_PORT) || 27017,
-            host: process.env.MONGODB_DEFAULT_HOST || 'localhost',
-            defaultDbName: process.env.MONGODB_DEFAULT_DB || 'idaenext_sitebase_app',
-            connectionPrefix: process.env.MONGODB_DEFAULT_CONNECTION_PREFIX || 'mongodb://'
+            host: process.env.MONGODB_DEFAULT_HOST || "localhost",
+            defaultDbName: process.env.MONGODB_DEFAULT_DB || "idaenext_sitebase_app",
+            connectionPrefix: process.env.MONGODB_DEFAULT_CONNECTION_PREFIX || "mongodb://",
         };
     }
     static getInstance() {
@@ -21,7 +21,9 @@ class DatabaseManager {
         return DatabaseManager.instance;
     }
     getDbNameFromCollectionName(collectionName) {
-        return collectionName.includes('.') ? collectionName.split('.')[0] : this.config.defaultDbName;
+        return collectionName.includes(".")
+            ? collectionName.split(".")[0]
+            : this.config.defaultDbName;
     }
     async initConnection(dbName) {
         const dbUri = `${this.config.connectionPrefix}${this.config.host}:${this.config.port}/${dbName}`;
@@ -32,20 +34,20 @@ class DatabaseManager {
             bufferCommands: false,
             serverSelectionTimeoutMS: 30000,
             socketTimeoutMS: 45000,
-            maxPoolSize: 20
+            maxPoolSize: 20,
         });
         return connection;
     }
     async connectToDatabase(req) {
-        const collectionName = req.params.collectionName || 'default';
+        const collectionName = req.params.collectionName || "default";
         const dbName = this.getDbNameFromCollectionName(collectionName);
-        const collectionNames = collectionName.split('.')?.[1] ?? collectionName.split('.')?.[0];
+        const collectionNames = collectionName.split(".")?.[1] ?? collectionName.split(".")?.[0];
         try {
             const connection = await this.initConnection(dbName);
             return {
                 connection,
                 dbName,
-                collectionName: collectionNames
+                collectionName: collectionNames,
             };
         }
         catch (error) {

package/dist/server/engine/routeManager.d.ts

@@ -1,4 +1,4 @@
-import type { RouteDefinition } from '../../config/routeDefinitions';
+import type { RouteDefinition } from "../../config/routeDefinitions.js";
 export declare class RouteManager {
     private static instance;
     private routes;

package/dist/server/engine/routeManager.js

@@ -16,21 +16,27 @@ export class RouteManager {
     }
     removeRoute(path, method) {
         this.routes = this.routes.filter((r) => !(r.path === path &&
-            (Array.isArray(r.method) ? r.method.includes(method) : r.method === method)));
+            (Array.isArray(r.method)
+                ? r.method.includes(method)
+                : r.method === method)));
     }
     getRoutes() {
         return this.routes.filter((route) => !route.disabled);
     }
     enableRoute(path, method) {
         const route = this.routes.find((r) => r.path === path &&
-            (Array.isArray(r.method) ? r.method.includes(method) : r.method === method));
+            (Array.isArray(r.method)
+                ? r.method.includes(method)
+                : r.method === method));
         if (route) {
             route.disabled = false;
         }
     }
     disableRoute(path, method) {
         const route = this.routes.find((r) => r.path === path &&
-            (Array.isArray(r.method) ? r.method.includes(method) : r.method === method));
+            (Array.isArray(r.method)
+                ? r.method.includes(method)
+                : r.method === method));
         if (route) {
             route.disabled = true;
         }

package/dist/server/middleware/databaseMiddleware.d.ts

@@ -1,2 +1,2 @@
-import type { Request, Response, NextFunction } from 'express';
+import type { Request, Response, NextFunction } from "express";
 export declare const databaseMiddleware: (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/dist/server/middleware/databaseMiddleware.js

@@ -1,5 +1,5 @@
 // packages\idae-api\src\lib\middleware\databaseMiddleware.ts
-import databaseManager from '../engine/DatabaseManager';
+import databaseManager from "../engine/DatabaseManager.js";
 export const databaseMiddleware = async (req, res, next) => {
     try {
         const { collectionName, dbName, connection } = await databaseManager.connectToDatabase(req);
@@ -9,7 +9,7 @@ export const databaseMiddleware = async (req, res, next) => {
         next();
     }
     catch (error) {
-        console.error('Error in database connection middleware:', error);
+        console.error("Error in database connection middleware:", error);
         next(error);
     }
 };

package/dist/server/services/DBaseService.d.ts

@@ -1,8 +1,8 @@
-import mongoose, { type Document } from 'mongoose';
-import { type ApiServerRequestParams } from '../engine/types';
+import mongoose, { type Document } from "mongoose";
+import { type ApiServerRequestParams } from "../engine/types.js";
 declare class DBaseService<T extends Document> {
     private adapter;
-    constructor(collection: string, connection: mongoose.Connection, dbType?: 'mongodb' | 'mysql' | 'mariadb' | 'postgres');
+    constructor(collection: string, connection: mongoose.Connection, dbType?: "mongodb" | "mysql" | "mariadb" | "postgres");
     create(document: Partial<T>): Promise<T>;
     where(params: ApiServerRequestParams): Promise<T[]>;
     findById(id: string): Promise<T | null>;

package/dist/server/services/DBaseService.js

@@ -1,22 +1,22 @@
 // packages\idae-api\src\lib\engine\DBaseService.ts
-import mongoose, {} from 'mongoose';
-import {} from '../engine/types';
-import { MongoDBAdapter } from '../adapters/MongoDBAdapter';
+import mongoose, {} from "mongoose";
+import {} from "../engine/types.js";
+import { MongoDBAdapter } from "../adapters/MongoDBAdapter.js";
 class DBaseService {
-    constructor(collection, connection, dbType = 'mongodb') {
+    constructor(collection, connection, dbType = "mongodb") {
         switch (dbType) {
-            case 'mongodb':
+            case "mongodb":
                 this.adapter = new MongoDBAdapter(collection, connection);
                 break;
-            case 'mysql':
-            case 'mariadb':
+            case "mysql":
+            case "mariadb":
                 // TODO: Implement MySQL adapter
-                throw new Error('MySQL adapter not implemented yet');
-            case 'postgres':
+                throw new Error("MySQL adapter not implemented yet");
+            case "postgres":
                 // TODO: Implement postgres adapter
-                throw new Error('Postgres adapter not implemented yet');
+                throw new Error("Postgres adapter not implemented yet");
             default:
-                console.log('dbType', dbType);
+                console.log("dbType", dbType);
                 throw new Error(`Unsupported database type: ${dbType}`);
         }
     }
@@ -24,7 +24,7 @@ class DBaseService {
         return this.adapter.create(document);
     }
     async where(params) {
-        console.log('where', params);
+        console.log("where", params);
         return this.adapter.where(params);
     }
     async findById(id) {
@@ -44,9 +44,9 @@ class DBaseService {
     }
     decodeUrlParams(urlParams) {
         const params = {};
-        const urlParamsArray = urlParams.split('&');
+        const urlParamsArray = urlParams.split("&");
         urlParamsArray.forEach((param) => {
-            const [key, value] = param.split('=');
+            const [key, value] = param.split("=");
             if (key && value) {
                 try {
                     params[key] = JSON.parse(decodeURIComponent(value));

package/package.json

@@ -1,7 +1,9 @@
 {
 	"name": "@medyll/idae-api",
 	"scope": "@medyll",
-	"version": "0.24.0",
+	"version": "0.26.0",
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run package",
@@ -19,7 +21,8 @@
 	"exports": {
 		".": {
 			"types": "./dist/index.d.ts",
-			"svelte": "./dist/index.js"
+			"svelte": "./dist/index.js",
+			"default": "./dist/index.js"
 		}
 	},
 	"files": [
@@ -27,6 +30,11 @@
 		"!dist/**/*.test.*",
 		"!dist/**/*.spec.*"
 	],
+	"tshy": {
+		"dialects": [
+			"esm"
+		]
+	},
 	"dependencies": {
 		"@typegoose/auto-increment": "^4.5.0",
 		"express": "^4.19.2",