@medyll/idae-api 0.138.0 → 0.139.0

package/dist/__tests__/fixtures/mockData.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Test Fixtures & Mock Data
+ * Centralized test data for consistent test scenarios
+ */
+export declare const mockUsers: {
+    id: string;
+    name: string;
+    email: string;
+    role: string;
+    age: number;
+    active: boolean;
+    createdAt: string;
+}[];
+export declare const mockPosts: {
+    id: string;
+    title: string;
+    content: string;
+    authorId: string;
+    published: boolean;
+    createdAt: string;
+}[];
+export declare const mockComments: {
+    id: string;
+    text: string;
+    postId: string;
+    authorId: string;
+    createdAt: string;
+}[];
+export declare const mockTokens: {
+    valid: {
+        admin: string;
+        user: string;
+        expired: string;
+    };
+    invalid: {
+        malformed: string;
+        tampered: string;
+        none: string;
+    };
+};
+export declare const mockSQLInjectionPayloads: string[];
+export declare const mockNoSQLInjectionPayloads: ({
+    $ne: null;
+    $where?: undefined;
+    $function?: undefined;
+    $regex?: undefined;
+    $gt?: undefined;
+} | {
+    $where: string;
+    $ne?: undefined;
+    $function?: undefined;
+    $regex?: undefined;
+    $gt?: undefined;
+} | {
+    $function: {
+        body: string;
+        args: string[];
+        lang: string;
+    };
+    $ne?: undefined;
+    $where?: undefined;
+    $regex?: undefined;
+    $gt?: undefined;
+} | {
+    $regex: string;
+    $ne?: undefined;
+    $where?: undefined;
+    $function?: undefined;
+    $gt?: undefined;
+} | {
+    $gt: string;
+    $ne?: undefined;
+    $where?: undefined;
+    $function?: undefined;
+    $regex?: undefined;
+})[];
+export declare const mockXSSPayloads: string[];
+export declare const mockCSRFPayloads: ({
+    csrfToken: string;
+    _token?: undefined;
+    'x-csrf-token'?: undefined;
+} | {
+    _token: string;
+    csrfToken?: undefined;
+    'x-csrf-token'?: undefined;
+} | {
+    'x-csrf-token': string;
+    csrfToken?: undefined;
+    _token?: undefined;
+})[];
+export declare const mockEdgeCasesData: {
+    veryLongString: string;
+    unicodeChars: string;
+    specialChars: string;
+    nullByte: string;
+    newlines: string;
+    tabs: string;
+};
+export declare const mockDatabaseConfigs: {
+    mongodb: {
+        host: string;
+        port: number;
+        dbName: string;
+        uri: string;
+    };
+    mysql: {
+        host: string;
+        port: number;
+        dbName: string;
+        uri: string;
+    };
+};
+export declare const mockErrorResponses: {
+    unauthorized: {
+        status: number;
+        body: {
+            error: string;
+            message: string;
+        };
+    };
+    forbidden: {
+        status: number;
+        body: {
+            error: string;
+            message: string;
+        };
+    };
+    notFound: {
+        status: number;
+        body: {
+            error: string;
+            message: string;
+        };
+    };
+    badRequest: {
+        status: number;
+        body: {
+            error: string;
+            message: string;
+        };
+    };
+    internalError: {
+        status: number;
+        body: {
+            error: string;
+            message: string;
+        };
+    };
+    serviceUnavailable: {
+        status: number;
+        body: {
+            error: string;
+            message: string;
+        };
+    };
+};
+export declare const mockMiddlewareContext: {
+    req: {
+        headers: {};
+        params: {};
+        query: {};
+        body: {};
+    };
+    res: {
+        statusCode: number;
+        headers: {};
+        body: null;
+    };
+    next: () => void;
+};
+/**
+ * Helper to create mock request with standard properties
+ */
+export declare function createMockRequest(overrides?: any): any;
+/**
+ * Helper to create mock response with standard methods
+ */
+export declare function createMockResponse(): {
+    status: (code: number) => {
+        json: (data: any) => {};
+    };
+    json: (data: any) => {};
+    send: (data: any) => {};
+    statusCode: number;
+    responseData: any;
+};
+/**
+ * Helper to create mock IdaeDb instance
+ */
+export declare function createMockIdaeDb(): {
+    init: (uri: string, options: any) => Promise<{
+        db: (dbName: string) => Promise<{
+            collection: (collectionName: string) => Promise<{
+                find: (filter?: any) => Promise<{
+                    id: string;
+                    name: string;
+                    email: string;
+                    role: string;
+                    age: number;
+                    active: boolean;
+                    createdAt: string;
+                }[]>;
+                findById: (id: string) => Promise<{
+                    id: string;
+                    name: string;
+                    email: string;
+                    role: string;
+                    age: number;
+                    active: boolean;
+                    createdAt: string;
+                } | null>;
+                create: (data: any) => Promise<any>;
+                update: (id: string, data: any) => Promise<any>;
+                deleteById: (id: string) => Promise<undefined>;
+                deleteWhere: (filter: any) => Promise<number>;
+            }>;
+        }>;
+    }>;
+};

package/dist/__tests__/fixtures/mockData.js

@@ -0,0 +1,243 @@
+/**
+ * Test Fixtures & Mock Data
+ * Centralized test data for consistent test scenarios
+ */
+export const mockUsers = [
+    {
+        id: '1',
+        name: 'Alice Johnson',
+        email: 'alice@example.com',
+        role: 'admin',
+        age: 28,
+        active: true,
+        createdAt: '2026-01-01T00:00:00Z'
+    },
+    {
+        id: '2',
+        name: 'Bob Smith',
+        email: 'bob@example.com',
+        role: 'user',
+        age: 25,
+        active: true,
+        createdAt: '2026-01-02T00:00:00Z'
+    },
+    {
+        id: '3',
+        name: 'Charlie Brown',
+        email: 'charlie@example.com',
+        role: 'user',
+        age: 32,
+        active: false,
+        createdAt: '2026-01-03T00:00:00Z'
+    }
+];
+export const mockPosts = [
+    {
+        id: '1',
+        title: 'First Post',
+        content: 'This is the first post',
+        authorId: '1',
+        published: true,
+        createdAt: '2026-01-10T00:00:00Z'
+    },
+    {
+        id: '2',
+        title: 'Second Post',
+        content: 'This is the second post',
+        authorId: '2',
+        published: false,
+        createdAt: '2026-01-11T00:00:00Z'
+    }
+];
+export const mockComments = [
+    {
+        id: '1',
+        text: 'Great post!',
+        postId: '1',
+        authorId: '2',
+        createdAt: '2026-01-10T12:00:00Z'
+    },
+    {
+        id: '2',
+        text: 'I agree',
+        postId: '1',
+        authorId: '3',
+        createdAt: '2026-01-10T13:00:00Z'
+    }
+];
+export const mockTokens = {
+    valid: {
+        admin: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImFkbWluIiwicm9sZSI6ImFkbWluIn0.mock',
+        user: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIiLCJyb2xlIjoidXNlciJ9.mock',
+        expired: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InVzZXIiLCJleHAiOjE2MDAwMDAwMDB9.mock'
+    },
+    invalid: {
+        malformed: 'not.a.token',
+        tampered: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6ImhhY2tlciIsInJvbGUiOiJhZG1pbiJ9.wrong',
+        none: 'eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJ1c2VybmFtZSI6ImhheGVyIn0.'
+    }
+};
+export const mockSQLInjectionPayloads = [
+    "'; DROP TABLE users; --",
+    "1' OR '1'='1",
+    "admin'--",
+    "1; DELETE FROM users; --",
+    "' OR 1=1 --"
+];
+export const mockNoSQLInjectionPayloads = [
+    { $ne: null },
+    { $where: 'function() { return true }' },
+    { $function: { body: 'function(x) { return true }', args: ['$field'], lang: 'js' } },
+    { $regex: '.*' },
+    { $gt: '' }
+];
+export const mockXSSPayloads = [
+    '<script>alert("XSS")</script>',
+    '<img src=x onerror="alert(\'XSS\')">',
+    '<svg onload="alert(\'XSS\')">',
+    'javascript:alert("XSS")',
+    '<iframe src="javascript:alert(\'XSS\')">',
+    '<body onload="alert(\'XSS\')">',
+    '<input onfocus="alert(\'XSS\')" autofocus>',
+    '<marquee onstart="alert(\'XSS\')">'
+];
+export const mockCSRFPayloads = [
+    { csrfToken: 'forged' },
+    { _token: 'invalid' },
+    { 'x-csrf-token': 'wrong' }
+];
+export const mockEdgeCasesData = {
+    veryLongString: 'a'.repeat(10000),
+    unicodeChars: '你好世界🚀',
+    specialChars: "!@#$%^&*()_+-=[]{}|;':\",./<>?",
+    nullByte: 'test\x00value',
+    newlines: 'line1\nline2\rline3\r\nline4',
+    tabs: 'col1\tcol2\tcol3'
+};
+export const mockDatabaseConfigs = {
+    mongodb: {
+        host: 'localhost',
+        port: 27017,
+        dbName: 'testdb',
+        uri: 'mongodb://localhost:27017/testdb'
+    },
+    mysql: {
+        host: 'localhost',
+        port: 3306,
+        dbName: 'testdb',
+        uri: 'mysql://localhost:3306/testdb'
+    }
+};
+export const mockErrorResponses = {
+    unauthorized: {
+        status: 401,
+        body: { error: 'Unauthorized', message: 'No Authorization header provided' }
+    },
+    forbidden: {
+        status: 403,
+        body: { error: 'Forbidden', message: 'Insufficient permissions' }
+    },
+    notFound: {
+        status: 404,
+        body: { error: 'Not Found', message: 'Resource not found' }
+    },
+    badRequest: {
+        status: 400,
+        body: { error: 'Bad Request', message: 'Invalid request parameters' }
+    },
+    internalError: {
+        status: 500,
+        body: { error: 'Internal Server Error', message: 'An unexpected error occurred' }
+    },
+    serviceUnavailable: {
+        status: 503,
+        body: { error: 'Service Unavailable', message: 'Database connection failed' }
+    }
+};
+export const mockMiddlewareContext = {
+    req: {
+        headers: {},
+        params: {},
+        query: {},
+        body: {}
+    },
+    res: {
+        statusCode: 200,
+        headers: {},
+        body: null
+    },
+    next: () => { }
+};
+/**
+ * Helper to create mock request with standard properties
+ */
+export function createMockRequest(overrides = {}) {
+    return {
+        headers: {},
+        params: {},
+        query: {},
+        body: {},
+        user: { username: 'testuser' },
+        idaeDb: undefined,
+        dbName: undefined,
+        collectionName: undefined,
+        connectedCollection: undefined,
+        ...overrides
+    };
+}
+/**
+ * Helper to create mock response with standard methods
+ */
+export function createMockResponse() {
+    let statusCode = 200;
+    let responseData;
+    return {
+        status: (code) => {
+            statusCode = code;
+            return {
+                json: (data) => {
+                    responseData = data;
+                    return {};
+                }
+            };
+        },
+        json: (data) => {
+            responseData = data;
+            return {};
+        },
+        send: (data) => {
+            responseData = data;
+            return {};
+        },
+        statusCode,
+        responseData
+    };
+}
+/**
+ * Helper to create mock IdaeDb instance
+ */
+export function createMockIdaeDb() {
+    return {
+        init: async (uri, options) => {
+            return {
+                db: async (dbName) => {
+                    return {
+                        collection: async (collectionName) => {
+                            return {
+                                find: async (filter) => mockUsers.filter(u => u.role === filter?.role || true),
+                                findById: async (id) => mockUsers.find(u => u.id === id) || null,
+                                create: async (data) => ({ id: '4', ...data }),
+                                update: async (id, data) => ({
+                                    ...mockUsers.find(u => u.id === id),
+                                    ...data
+                                }),
+                                deleteById: async (id) => undefined,
+                                deleteWhere: async (filter) => 1
+                            };
+                        }
+                    };
+                }
+            };
+        }
+    };
+}

package/dist/__tests__/helpers/testUtils.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Test Utilities & Helpers
+ * Common patterns and utilities for consistent testing
+ */
+/**
+ * Generate a mock JWT token for testing
+ */
+export declare function generateMockToken(payload?: any, secret?: string, expiresIn?: string): never;
+/**
+ * Create a mock Express Request object
+ */
+export declare function createMockRequest(overrides?: any): any;
+/**
+ * Create a mock Express Response object
+ */
+export declare function createMockResponse(): {
+    status: (code: number) => {
+        json: (data: any) => {};
+        send: (data: any) => {};
+    };
+    json: (data: any) => {};
+    send: (data: any) => {};
+    setHeader: (key: string, value: string) => {};
+    getHeader: (key: string) => string | undefined;
+    getStatusCode: () => number;
+    getResponseData: () => any;
+    statusCode: number;
+    responseData: any;
+    headers: Map<string, string>;
+};
+/**
+ * Create a mock NextFunction
+ */
+export declare function createMockNextFunction(): import("vitest").Mock<(err?: any) => void>;
+/**
+ * Create a complete mock middleware context
+ */
+export declare function createMockMiddlewareContext(overrides?: any): {
+    req: any;
+    res: {
+        status: (code: number) => {
+            json: (data: any) => {};
+            send: (data: any) => {};
+        };
+        json: (data: any) => {};
+        send: (data: any) => {};
+        setHeader: (key: string, value: string) => {};
+        getHeader: (key: string) => string | undefined;
+        getStatusCode: () => number;
+        getResponseData: () => any;
+        statusCode: number;
+        responseData: any;
+        headers: Map<string, string>;
+    };
+    next: import("vitest").Mock<(err?: any) => void>;
+};
+/**
+ * Wait for async operations to complete
+ */
+export declare function waitFor(condition: () => boolean, timeout?: number): Promise<void>;
+/**
+ * Create a mock IdaeDb collection adapter
+ */
+export declare function createMockCollection(defaultData?: any[]): {
+    find: import("vitest").Mock<(filter?: any) => Promise<any[]>>;
+    findById: import("vitest").Mock<(id: string) => Promise<any>>;
+    findAll: import("vitest").Mock<() => Promise<any[]>>;
+    create: import("vitest").Mock<(data: any) => Promise<any>>;
+    update: import("vitest").Mock<(id: string, data: any) => Promise<any>>;
+    deleteById: import("vitest").Mock<(id: string) => Promise<void>>;
+    deleteWhere: import("vitest").Mock<(filter: any) => Promise<number>>;
+};
+/**
+ * Create a mock IdaeDb database adapter
+ */
+export declare function createMockIdaeDb(collections?: Record<string, any>): {
+    init: import("vitest").Mock<(uri: string, options: any) => Promise<{
+        db: import("vitest").Mock<(dbName: string) => Promise<{
+            collection: import("vitest").Mock<(collectionName: string) => any>;
+        }>>;
+    }>>;
+    collection: import("vitest").Mock<(collectionName: string) => any>;
+};
+/**
+ * Create a mock HTTP fetch response
+ */
+export declare function createMockFetchResponse(data?: any, options?: any): Promise<{
+    ok: boolean;
+    status: any;
+    headers: Map<unknown, unknown>;
+    json: () => Promise<any>;
+    text: () => Promise<string>;
+    blob: () => Promise<Blob>;
+    clone: () => Promise</*elided*/ any>;
+}>;
+/**
+ * Assert that a middleware was called with specific arguments
+ */
+export declare function assertMiddlewareCalled(middleware: any, argIndex: number, expected: any): void;
+/**
+ * Mock an external module
+ */
+export declare function mockModule(moduleName: string, implementation: any): void;
+/**
+ * Restore all mocks
+ */
+export declare function resetAllMocks(): void;
+/**
+ * Create a test database URI
+ */
+export declare function createTestDatabaseUri(dbType?: string, dbName?: string): string;
+/**
+ * Extract bearer token from Authorization header
+ */
+export declare function extractBearerToken(authHeader?: string): string | null;
+/**
+ * Validate token format
+ */
+export declare function isValidTokenFormat(token: string): boolean;
+/**
+ * Create assertion helpers for common patterns
+ */
+export declare const testAssertions: {
+    /**
+     * Assert middleware sets status code
+     */
+    statusCode: (res: any, expectedCode: number) => void;
+    /**
+     * Assert middleware sets Authorization header
+     */
+    hasAuthHeader: (req: any) => void;
+    /**
+     * Assert response has error
+     */
+    hasError: (res: any) => void;
+    /**
+     * Assert response has success data
+     */
+    hasData: (res: any) => void;
+};
+/**
+ * Performance testing helper
+ */
+export declare function measurePerformance(fn: () => Promise<any>, iterations?: number): Promise<{
+    average: number;
+    min: number;
+    max: number;
+    times: number[];
+}>;
+/**
+ * Test data sanitizer - remove sensitive info before assertions
+ */
+export declare function sanitizeForAssertion(data: any, keysToRemove?: string[]): any;