@medyll/idae-api 0.137.0 → 0.139.0

package/dist/__tests__/helpers/testUtils.js

@@ -0,0 +1,328 @@
+/**
+ * Test Utilities & Helpers
+ * Common patterns and utilities for consistent testing
+ */
+import { vi } from 'vitest';
+import jwt from 'jsonwebtoken';
+/**
+ * Generate a mock JWT token for testing
+ */
+export function generateMockToken(payload = {}, secret = 'test-secret', expiresIn = '1h') {
+    return jwt.sign({
+        username: 'testuser',
+        role: 'user',
+        ...payload
+    }, secret, { expiresIn });
+}
+/**
+ * Create a mock Express Request object
+ */
+export function createMockRequest(overrides = {}) {
+    return {
+        headers: {},
+        params: {},
+        query: {},
+        body: {},
+        user: { username: 'testuser', role: 'user' },
+        idaeDb: undefined,
+        dbName: 'testdb',
+        collectionName: 'users',
+        connectedCollection: undefined,
+        ...overrides
+    };
+}
+/**
+ * Create a mock Express Response object
+ */
+export function createMockResponse() {
+    let statusCode = 200;
+    let responseData;
+    const headers = new Map();
+    return {
+        status: (code) => {
+            statusCode = code;
+            return {
+                json: (data) => {
+                    responseData = data;
+                    return {};
+                },
+                send: (data) => {
+                    responseData = data;
+                    return {};
+                }
+            };
+        },
+        json: (data) => {
+            responseData = data;
+            return {};
+        },
+        send: (data) => {
+            responseData = data;
+            return {};
+        },
+        setHeader: (key, value) => {
+            headers.set(key, value);
+            return {};
+        },
+        getHeader: (key) => headers.get(key),
+        getStatusCode: () => statusCode,
+        getResponseData: () => responseData,
+        statusCode,
+        responseData,
+        headers
+    };
+}
+/**
+ * Create a mock NextFunction
+ */
+export function createMockNextFunction() {
+    return vi.fn((err) => {
+        if (err)
+            throw err;
+    });
+}
+/**
+ * Create a complete mock middleware context
+ */
+export function createMockMiddlewareContext(overrides = {}) {
+    return {
+        req: createMockRequest(overrides.req),
+        res: createMockResponse(),
+        next: createMockNextFunction()
+    };
+}
+/**
+ * Wait for async operations to complete
+ */
+export async function waitFor(condition, timeout = 1000) {
+    const start = Date.now();
+    while (!condition()) {
+        if (Date.now() - start > timeout) {
+            throw new Error('Timeout waiting for condition');
+        }
+        await new Promise(resolve => setTimeout(resolve, 10));
+    }
+}
+/**
+ * Create a mock IdaeDb collection adapter
+ */
+export function createMockCollection(defaultData = []) {
+    return {
+        find: vi.fn(async (filter) => {
+            return defaultData.filter(item => {
+                if (!filter)
+                    return true;
+                for (const key in filter) {
+                    if (item[key] !== filter[key])
+                        return false;
+                }
+                return true;
+            });
+        }),
+        findById: vi.fn(async (id) => {
+            return defaultData.find((item) => item.id === id) || null;
+        }),
+        findAll: vi.fn(async () => defaultData),
+        create: vi.fn(async (data) => {
+            const newItem = { id: String(defaultData.length + 1), ...data };
+            defaultData.push(newItem);
+            return newItem;
+        }),
+        update: vi.fn(async (id, data) => {
+            const item = defaultData.find((item) => item.id === id);
+            if (item) {
+                Object.assign(item, data);
+                return item;
+            }
+            return null;
+        }),
+        deleteById: vi.fn(async (id) => {
+            const index = defaultData.findIndex((item) => item.id === id);
+            if (index > -1) {
+                defaultData.splice(index, 1);
+            }
+        }),
+        deleteWhere: vi.fn(async (filter) => {
+            const before = defaultData.length;
+            // Simple filter implementation
+            for (const key in filter) {
+                const newData = defaultData.filter((item) => item[key] !== filter[key]);
+                defaultData.length = 0;
+                defaultData.push(...newData);
+            }
+            return before - defaultData.length;
+        })
+    };
+}
+/**
+ * Create a mock IdaeDb database adapter
+ */
+export function createMockIdaeDb(collections = {}) {
+    return {
+        init: vi.fn(async (uri, options) => {
+            return {
+                db: vi.fn(async (dbName) => {
+                    return {
+                        collection: vi.fn((collectionName) => {
+                            return collections[collectionName] || createMockCollection();
+                        })
+                    };
+                })
+            };
+        }),
+        collection: vi.fn((collectionName) => {
+            return collections[collectionName] || createMockCollection();
+        })
+    };
+}
+/**
+ * Create a mock HTTP fetch response
+ */
+export function createMockFetchResponse(data = {}, options = {}) {
+    return Promise.resolve({
+        ok: options.ok !== false,
+        status: options.status || 200,
+        headers: new Map(options.headers || []),
+        json: async () => data,
+        text: async () => JSON.stringify(data),
+        blob: async () => new Blob([JSON.stringify(data)]),
+        clone: () => createMockFetchResponse(data, options)
+    });
+}
+/**
+ * Assert that a middleware was called with specific arguments
+ */
+export function assertMiddlewareCalled(middleware, argIndex, expected) {
+    const call = middleware.mock.calls[0];
+    if (!call) {
+        throw new Error('Middleware was not called');
+    }
+    const actual = call[argIndex];
+    if (typeof expected === 'object') {
+        if (!Object.keys(expected).every(key => actual[key] === expected[key])) {
+            throw new Error(`Middleware argument ${argIndex} does not match expected`);
+        }
+    }
+    else if (actual !== expected) {
+        throw new Error(`Middleware argument ${argIndex} does not match expected`);
+    }
+}
+/**
+ * Mock an external module
+ */
+export function mockModule(moduleName, implementation) {
+    return vi.mock(moduleName, () => implementation);
+}
+/**
+ * Restore all mocks
+ */
+export function resetAllMocks() {
+    vi.clearAllMocks();
+    vi.resetAllMocks();
+    vi.restoreAllMocks();
+}
+/**
+ * Create a test database URI
+ */
+export function createTestDatabaseUri(dbType = 'mongodb', dbName = 'testdb') {
+    if (dbType === 'mongodb') {
+        return `mongodb://localhost:27017/${dbName}`;
+    }
+    else if (dbType === 'mysql') {
+        return `mysql://localhost:3306/${dbName}`;
+    }
+    return `${dbType}://localhost/${dbName}`;
+}
+/**
+ * Extract bearer token from Authorization header
+ */
+export function extractBearerToken(authHeader) {
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return null;
+    }
+    return authHeader.substring(7);
+}
+/**
+ * Validate token format
+ */
+export function isValidTokenFormat(token) {
+    const parts = token.split('.');
+    return parts.length === 3;
+}
+/**
+ * Create assertion helpers for common patterns
+ */
+export const testAssertions = {
+    /**
+     * Assert middleware sets status code
+     */
+    statusCode: (res, expectedCode) => {
+        if (res.statusCode !== expectedCode && res.status) {
+            // Response might be from mock with chained methods
+            throw new Error(`Expected status ${expectedCode}, got ${res.statusCode}`);
+        }
+    },
+    /**
+     * Assert middleware sets Authorization header
+     */
+    hasAuthHeader: (req) => {
+        if (!req.headers?.authorization) {
+            throw new Error('Authorization header not set');
+        }
+    },
+    /**
+     * Assert response has error
+     */
+    hasError: (res) => {
+        if (!res.responseData?.error) {
+            throw new Error('Response does not contain error');
+        }
+    },
+    /**
+     * Assert response has success data
+     */
+    hasData: (res) => {
+        if (!res.responseData) {
+            throw new Error('Response does not contain data');
+        }
+    }
+};
+/**
+ * Performance testing helper
+ */
+export async function measurePerformance(fn, iterations = 100) {
+    const times = [];
+    for (let i = 0; i < iterations; i++) {
+        const start = performance.now();
+        await fn();
+        const end = performance.now();
+        times.push(end - start);
+    }
+    return {
+        average: times.reduce((a, b) => a + b) / times.length,
+        min: Math.min(...times),
+        max: Math.max(...times),
+        times
+    };
+}
+/**
+ * Test data sanitizer - remove sensitive info before assertions
+ */
+export function sanitizeForAssertion(data, keysToRemove = ['password', 'token', 'secret']) {
+    if (typeof data !== 'object' || data === null) {
+        return data;
+    }
+    const sanitized = Array.isArray(data) ? [...data] : { ...data };
+    const remove = (obj) => {
+        for (const key in obj) {
+            if (keysToRemove.includes(key)) {
+                delete obj[key];
+            }
+            else if (typeof obj[key] === 'object') {
+                remove(obj[key]);
+            }
+        }
+    };
+    remove(sanitized);
+    return sanitized;
+}

package/dist/client/IdaeApiClient.d.ts

@@ -3,12 +3,19 @@ import { IdaeApiClientCollection } from "./IdaeApiClientCollection.js";
 import { IdaeApiClientRequest } from "./IdaeApiClientRequest.js";
 type IdaeApiClientRequestParams<T = any> = Record<string, T>;
 declare class IdaeApiClient {
+    private static instance;
     private clientConfig;
     private _request;
     constructor(clientConfig?: IdaeApiClientConfigCoreOptions & {
         baseUrl?: string;
     });
+    static getInstance(clientConfig?: IdaeApiClientConfigCoreOptions & {
+        baseUrl?: string;
+    }): IdaeApiClient;
     get request(): IdaeApiClientRequest;
+    setOptions(options?: IdaeApiClientConfigCoreOptions & {
+        baseUrl?: string;
+    }): void;
     getDbList(): Promise<Response>;
     getCollections(dbName: string): Promise<Response>;
     db(dbName: string): {

package/dist/client/IdaeApiClient.js

@@ -8,9 +8,21 @@ class IdaeApiClient {
         this.clientConfig.setOptions(clientConfig);
         this._request = new IdaeApiClientRequest(this.clientConfig);
     }
+    static getInstance(clientConfig) {
+        if (!IdaeApiClient.instance) {
+            IdaeApiClient.instance = new IdaeApiClient(clientConfig);
+        }
+        else if (clientConfig) {
+            IdaeApiClientConfig.setOptions(clientConfig);
+        }
+        return IdaeApiClient.instance;
+    }
     get request() {
         return this._request;
     }
+    setOptions(options) {
+        this.clientConfig.setOptions(options);
+    }
     async getDbList() {
         return this._request.doRequest({ routeNamespace: "methods/dbs" });
     }
@@ -22,15 +34,16 @@ class IdaeApiClient {
     }
     db(dbName) {
         return {
-            collection: (collectionName) => new IdaeApiClientCollection(this.clientConfig, dbName, collectionName),
+            collection: (collectionName) => new IdaeApiClientCollection(this.clientConfig, dbName, collectionName, this._request),
             getCollections: () => this.getCollections(dbName),
         };
     }
     collection(collectionName, dbName) {
         dbName = dbName || this.clientConfig.defaultDb;
-        return new IdaeApiClientCollection(this.clientConfig, dbName, collectionName);
+        return new IdaeApiClientCollection(this.clientConfig, dbName, collectionName, this._request);
     }
 }
+IdaeApiClient.instance = null;
 // fonctionne
 export { IdaeApiClient };
 // ne fonctionne pas quand multiligne

package/dist/client/IdaeApiClientCollection.d.ts

@@ -1,15 +1,23 @@
-import { IdaeApiClient } from "./IdaeApiClient.js";
 import type { IdaeApiClientRequestParams } from "./IdaeApiClient.js";
-import type { IdaeApiClientConfigCoreOptions } from "./IdaeApiClientConfig.js";
+import type { IdaeApiClientConfigCore } from "./IdaeApiClientConfig.js";
+import { IdaeApiClientRequest } from "./IdaeApiClientRequest.js";
 import type { IdaeDbApiMethods } from "@medyll/idae-db";
-declare class IdaeApiClientCollection extends IdaeApiClient implements IdaeDbApiMethods<object> {
+declare class IdaeApiClientCollection implements IdaeDbApiMethods<object> {
     private meta;
-    constructor(clientConfig: IdaeApiClientConfigCoreOptions, dbName: string, collectionName: string);
+    private requestClient;
+    constructor(clientConfig: IdaeApiClientConfigCore, dbName: string, collectionName: string, requestClient?: IdaeApiClientRequest);
     find<T extends object>(params?: IdaeApiClientRequestParams): Promise<T[]>;
-    findById<T>(id: string): Promise<Response>;
-    create<T>(body: T): Promise<Response>;
-    update<T>(id: string, body: T): Promise<Response>;
-    deleteById<T>(id: string): Promise<Response>;
-    deleteManyByQuery<T>(params: IdaeApiClientRequestParams): Promise<Response>;
+    findById<T>(id: string): Promise<T[]>;
+    create<T>(body: T): Promise<T>;
+    update<T>(id: string, body: T): Promise<T>;
+    deleteById<T>(id: string): Promise<T>;
+    deleteManyByQuery<T>(params: IdaeApiClientRequestParams): Promise<T[]>;
+    createIndex(fieldOrSpec: unknown, options?: unknown): Promise<string>;
+    findOne<T>(params?: any): Promise<T | null>;
+    updateWhere(params?: any, update?: any): Promise<void>;
+    deleteWhere(params: any): Promise<{
+        deletedCount?: number;
+    }>;
+    transaction<TResult>(callback: (session: unknown) => Promise<TResult>): Promise<TResult>;
 }
 export { IdaeApiClientCollection };

package/dist/client/IdaeApiClientCollection.js

@@ -1,53 +1,74 @@
-// packages\idae-api\src\lib\client\IdaeApiClientCollection.ts
-import { IdaeApiClient } from "./IdaeApiClient.js";
-class IdaeApiClientCollection extends IdaeApiClient {
-    constructor(clientConfig, dbName, collectionName) {
-        super(clientConfig);
+import { IdaeApiClientRequest } from "./IdaeApiClientRequest.js";
+class IdaeApiClientCollection {
+    constructor(clientConfig, dbName, collectionName, requestClient) {
+        this.requestClient = requestClient ?? new IdaeApiClientRequest(clientConfig);
         this.meta = {
             dbName,
             collectionName,
         };
     }
     async find(params) {
-        return this.request.doRequest({
+        const response = await this.requestClient.doRequest({
             ...this.meta,
             params,
         });
+        return await response.json();
     }
     async findById(id) {
-        return this.request.doRequest({
+        const response = await this.requestClient.doRequest({
             ...this.meta,
             slug: id,
         });
+        return await response.json();
     }
     async create(body) {
-        return this.request.doRequest({
+        const response = await this.requestClient.doRequest({
             method: "POST",
             ...this.meta,
             body,
         });
+        return await response.json();
     }
     async update(id, body) {
-        return this.request.doRequest({
+        const response = await this.requestClient.doRequest({
             method: "PUT",
             ...this.meta,
             body,
             slug: id,
         });
+        return await response.json();
     }
     async deleteById(id) {
-        return this.request.doRequest({
+        const response = await this.requestClient.doRequest({
             method: "DELETE",
             ...this.meta,
             slug: id,
         });
+        return await response.json();
     }
     async deleteManyByQuery(params) {
-        return this.request.doRequest({
+        const response = await this.requestClient.doRequest({
             method: "DELETE",
             ...this.meta,
             params,
         });
+        return await response.json();
+    }
+    // Stubs for missing interface methods
+    async createIndex(fieldOrSpec, options) {
+        throw new Error("Not implemented");
+    }
+    async findOne(params) {
+        throw new Error("Not implemented");
+    }
+    async updateWhere(params, update) {
+        throw new Error("Not implemented");
+    }
+    async deleteWhere(params) {
+        throw new Error("Not implemented");
+    }
+    async transaction(callback) {
+        throw new Error("Not implemented");
     }
 }
 export { IdaeApiClientCollection };

package/dist/client/IdaeApiClientConfig.d.ts

@@ -4,6 +4,7 @@ export interface IdaeApiClientConfigCoreOptions {
     method: 'http' | 'https';
     defaultDb: string;
     separator: string;
+    token?: string;
 }
 export declare class IdaeApiClientConfigCore {
     private static instance;
@@ -18,6 +19,7 @@ export declare class IdaeApiClientConfigCore {
     get port(): number;
     get method(): 'http' | 'https';
     get separator(): string;
+    get token(): string | undefined;
     get defaultDb(): string;
 }
 export declare const IdaeApiClientConfig: IdaeApiClientConfigCore;

package/dist/client/IdaeApiClientConfig.js

@@ -5,7 +5,8 @@ export class IdaeApiClientConfigCore {
             port: 3000,
             method: 'https',
             defaultDb: 'idaenext_sitebase_app',
-            separator: '//'
+            separator: '//',
+            token: undefined,
         };
     }
     static getInstance() {
@@ -15,7 +16,11 @@ export class IdaeApiClientConfigCore {
         return IdaeApiClientConfigCore.instance;
     }
     setOptions(options = {}) {
-        this.options = { ...this.options, ...options };
+        const normalized = { ...options };
+        if (options?.protocol) {
+            normalized.method = options.protocol;
+        }
+        this.options = { ...this.options, ...normalized };
         this._baseUrl = this.forgeBaseUrl();
     }
     get baseUrl() {
@@ -36,6 +41,9 @@ export class IdaeApiClientConfigCore {
     get separator() {
         return this.options.separator;
     }
+    get token() {
+        return this.options.token;
+    }
     get defaultDb() {
         return this.options.defaultDb;
     }

package/dist/client/IdaeApiClientRequest.js

@@ -1,12 +1,14 @@
 // packages\idae-api\src\lib\client\IdaeApiClientRequest.ts
 import { IdaeApiClientConfigCore } from "./IdaeApiClientConfig.js";
-import { encode } from "querystring";
 class IdaeApiClientRequest {
     constructor(clientConfig) {
         this.clientConfig = clientConfig;
-        this.baseUrl = `${this.clientConfig.method}:${this.clientConfig.separator}${this.clientConfig.host}:${this.clientConfig.port}`;
+        this.baseUrl =
+            this.clientConfig.baseUrl ||
+                `${this.clientConfig.method}:${this.clientConfig.separator}${this.clientConfig.host}:${this.clientConfig.port}`;
     }
-    async doRequest({ baseUrl = this.baseUrl, method = "GET", body, headers = {
+    async doRequest({ baseUrl = this.clientConfig.baseUrl ||
+        `${this.clientConfig.method}:${this.clientConfig.separator}${this.clientConfig.host}:${this.clientConfig.port}`, method = "GET", body, headers = {
         "Content-Type": "application/json",
     }, dbName = this.clientConfig.defaultDb, collectionName, slug, params, routeNamespace, }) {
         const url = this.buildUrl({
@@ -15,16 +17,25 @@ class IdaeApiClientRequest {
             collectionName,
             slug,
             params,
-        }).replace("//", "/");
-        const response = await fetch(`${baseUrl}${url}`, {
+        });
+        const authHeader = this.clientConfig.token
+            ? { Authorization: `Bearer ${this.clientConfig.token}` }
+            : {};
+        const response = (await fetch(`${baseUrl}${url}`, {
             method,
-            headers,
+            headers: Object.assign({}, headers, authHeader),
             body: body ? JSON.stringify(body) : undefined,
-        });
+        })) || {
+            ok: true,
+            json: async () => ({}),
+        };
         if (!response.ok) {
             throw new Error(`HTTP error! status: ${response.status}`);
         }
         try {
+            if (typeof response.json !== "function") {
+                return {};
+            }
             return response.json();
         }
         catch (e) {
@@ -33,16 +44,20 @@ class IdaeApiClientRequest {
         }
     }
     buildUrl({ dbName, collectionName, slug, params, routeNamespace, }) {
-        const urls = [`/`];
+        const parts = [];
         if (routeNamespace)
-            urls.push(routeNamespace);
-        if (dbName ?? collectionName)
-            urls.push([dbName, collectionName].filter((x) => x).join("."));
+            parts.push(routeNamespace);
+        if (dbName)
+            parts.push(dbName);
+        if (collectionName)
+            parts.push(collectionName);
         if (slug)
-            urls.push(slug);
-        if (params)
-            urls.push(`?params=${encodeURIComponent(JSON.stringify(params))}`);
-        return urls.join("/").replace("//", "/");
+            parts.push(slug);
+        const path = `/${parts.join("/")}`.replace(/\/\/+/, "/");
+        const query = params
+            ? `?encoded=true&params=${encodeURIComponent(JSON.stringify(params))}`
+            : "";
+        return `${path}${query}`;
     }
 }
 export { IdaeApiClientRequest, };

package/dist/config/routeDefinitions.d.ts

@@ -1,11 +1,19 @@
 import type { IdaeDbAdapter } from "@medyll/idae-db";
+import { z } from "zod";
 type RouteHandler = (service: IdaeDbAdapter<object>, params: any, body?: any, query?: any) => Promise<any>;
+import type { AuthorizationOptions } from "../server/middleware/authorizationMiddleware.js";
 export interface RouteDefinition {
     method: string | string[];
     path: string;
     handler: RouteHandler;
     disabled?: boolean;
     requiresAuth?: boolean;
+    authorization?: AuthorizationOptions;
+    validation?: {
+        bodySchema?: z.ZodSchema<any>;
+        querySchema?: z.ZodSchema<any>;
+        paramsSchema?: z.ZodSchema<any>;
+    };
 }
 export declare const routes: RouteDefinition[];
 export {};