90dc-core 1.19.4 → 1.19.6

package/dist/lib/scripts/verify-indexes.js

@@ -0,0 +1,94 @@
+/**
+ * Verification Script: Check if exerciseModelUuid indexes exist
+ *
+ * Purpose: Verify that the indexes from migrations 20260312000001 and 20260312000002 have been applied
+ *
+ * Expected Indexes:
+ * 1. exercises_exercise_model_uuid_idx on Exercises(exerciseModelUuid)
+ * 2. progress_entries_exercise_model_uuid_recorded_at_idx on ProgressEntries(exerciseModelUuid, recordedAt)
+ *
+ * Run: npx tsx src/lib/scripts/verify-indexes.ts
+ */ import { Sequelize } from "sequelize";
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+// ES module __dirname workaround
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Load environment variables
+dotenv.config({
+    path: path.resolve(__dirname, '../../../.env')
+});
+const sequelize = new Sequelize({
+    username: process.env.DB_USER || 'postgres',
+    password: process.env.DB_PASSWORD || 'password',
+    database: process.env.DB_NAME || '90dc',
+    host: process.env.DB_HOST || 'localhost',
+    port: Number(process.env.DB_PORT) || 5432,
+    dialect: 'postgres',
+    logging: false
+});
+async function verifyIndexes() {
+    try {
+        console.log('🔍 Checking exerciseModelUuid indexes...\n');
+        // Query to get all indexes on Exercises and ProgressEntries tables
+        const query = `
+      SELECT
+        tablename,
+        indexname,
+        indexdef
+      FROM pg_indexes
+      WHERE tablename IN ('Exercises', 'ProgressEntries')
+        AND indexname LIKE '%exercise_model_uuid%'
+      ORDER BY tablename, indexname;
+    `;
+        const indexes = await sequelize.query(query, {
+            type: 'SELECT'
+        });
+        if (indexes.length === 0) {
+            console.log('❌ NO exerciseModelUuid INDEXES FOUND');
+            console.log('\nRequired migrations have NOT been applied.');
+            console.log('Run: npm run db:migrate\n');
+            process.exit(1);
+        }
+        console.log(`✅ Found ${indexes.length} exerciseModelUuid index(es):\n`);
+        const expectedIndexes = {
+            exercises_exercise_model_uuid_idx: false,
+            progress_entries_exercise_model_uuid_recorded_at_idx: false
+        };
+        for (const index of indexes){
+            console.log(`  📊 ${index.tablename}:`);
+            console.log(`     Index: ${index.indexname}`);
+            console.log(`     Definition: ${index.indexdef}`);
+            console.log('');
+            // Mark expected indexes as found
+            if (index.indexname in expectedIndexes) {
+                expectedIndexes[index.indexname] = true;
+            }
+        }
+        // Check if all expected indexes exist
+        const missingIndexes = Object.entries(expectedIndexes).filter(([_, exists])=>!exists).map(([name])=>name);
+        if (missingIndexes.length > 0) {
+            console.log('⚠️  MISSING INDEXES:');
+            missingIndexes.forEach((name)=>{
+                console.log(`   - ${name}`);
+            });
+            console.log('\nRun: npm run db:migrate\n');
+            process.exit(1);
+        }
+        console.log('✅ ALL REQUIRED INDEXES EXIST');
+        console.log('\nPerformance optimization: COMPLETE');
+        console.log('Expected query performance:');
+        console.log('  - Progress by exerciseModelUuid: ~5ms (was ~5000ms)');
+        console.log('  - Exercise lookups: ~2ms (was ~200ms)');
+        await sequelize.close();
+        process.exit(0);
+    } catch (error) {
+        console.error('❌ Error checking indexes:', error);
+        await sequelize.close();
+        process.exit(1);
+    }
+}
+verifyIndexes();
+
+//# sourceMappingURL=verify-indexes.js.map

package/dist/lib/scripts/verify-indexes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/scripts/verify-indexes.ts"],"sourcesContent":["/**\n * Verification Script: Check if exerciseModelUuid indexes exist\n *\n * Purpose: Verify that the indexes from migrations 20260312000001 and 20260312000002 have been applied\n *\n * Expected Indexes:\n * 1. exercises_exercise_model_uuid_idx on Exercises(exerciseModelUuid)\n * 2. progress_entries_exercise_model_uuid_recorded_at_idx on ProgressEntries(exerciseModelUuid, recordedAt)\n *\n * Run: npx tsx src/lib/scripts/verify-indexes.ts\n */\n\nimport { Sequelize } from 'sequelize';\nimport dotenv from 'dotenv';\nimport path from 'path';\nimport { fileURLToPath } from 'url';\n\n// ES module __dirname workaround\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = path.dirname(__filename);\n\n// Load environment variables\ndotenv.config({ path: path.resolve(__dirname, '../../../.env') });\n\nconst sequelize = new Sequelize({\n  username: process.env.DB_USER || 'postgres',\n  password: process.env.DB_PASSWORD || 'password',\n  database: process.env.DB_NAME || '90dc',\n  host: process.env.DB_HOST || 'localhost',\n  port: Number(process.env.DB_PORT) || 5432,\n  dialect: 'postgres',\n  logging: false,\n});\n\ninterface IndexInfo {\n  tablename: string;\n  indexname: string;\n  indexdef: string;\n}\n\nasync function verifyIndexes() {\n  try {\n    console.log('🔍 Checking exerciseModelUuid indexes...\\n');\n\n    // Query to get all indexes on Exercises and ProgressEntries tables\n    const query = `\n      SELECT\n        tablename,\n        indexname,\n        indexdef\n      FROM pg_indexes\n      WHERE tablename IN ('Exercises', 'ProgressEntries')\n        AND indexname LIKE '%exercise_model_uuid%'\n      ORDER BY tablename, indexname;\n    `;\n\n    const indexes = await sequelize.query(query, {\n      type: 'SELECT',\n    }) as IndexInfo[];\n\n    if (indexes.length === 0) {\n      console.log('❌ NO exerciseModelUuid INDEXES FOUND');\n      console.log('\\nRequired migrations have NOT been applied.');\n      console.log('Run: npm run db:migrate\\n');\n      process.exit(1);\n    }\n\n    console.log(`✅ Found ${indexes.length} exerciseModelUuid index(es):\\n`);\n\n    const expectedIndexes = {\n      exercises_exercise_model_uuid_idx: false,\n      progress_entries_exercise_model_uuid_recorded_at_idx: false,\n    };\n\n    for (const index of indexes) {\n      console.log(`  📊 ${index.tablename}:`);\n      console.log(`     Index: ${index.indexname}`);\n      console.log(`     Definition: ${index.indexdef}`);\n      console.log('');\n\n      // Mark expected indexes as found\n      if (index.indexname in expectedIndexes) {\n        expectedIndexes[index.indexname as keyof typeof expectedIndexes] = true;\n      }\n    }\n\n    // Check if all expected indexes exist\n    const missingIndexes = Object.entries(expectedIndexes)\n      .filter(([_, exists]) => !exists)\n      .map(([name]) => name);\n\n    if (missingIndexes.length > 0) {\n      console.log('⚠️  MISSING INDEXES:');\n      missingIndexes.forEach((name) => {\n        console.log(`   - ${name}`);\n      });\n      console.log('\\nRun: npm run db:migrate\\n');\n      process.exit(1);\n    }\n\n    console.log('✅ ALL REQUIRED INDEXES EXIST');\n    console.log('\\nPerformance optimization: COMPLETE');\n    console.log('Expected query performance:');\n    console.log('  - Progress by exerciseModelUuid: ~5ms (was ~5000ms)');\n    console.log('  - Exercise lookups: ~2ms (was ~200ms)');\n\n    await sequelize.close();\n    process.exit(0);\n  } catch (error) {\n    console.error('❌ Error checking indexes:', error);\n    await sequelize.close();\n    process.exit(1);\n  }\n}\n\nverifyIndexes();\n"],"names":["Sequelize","dotenv","path","fileURLToPath","__filename","url","__dirname","dirname","config","resolve","sequelize","username","process","env","DB_USER","password","DB_PASSWORD","database","DB_NAME","host","DB_HOST","port","Number","DB_PORT","dialect","logging","verifyIndexes","console","log","query","indexes","type","length","exit","expectedIndexes","exercises_exercise_model_uuid_idx","progress_entries_exercise_model_uuid_recorded_at_idx","index","tablename","indexname","indexdef","missingIndexes","Object","entries","filter","_","exists","map","name","forEach","close","error"],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,SAASA,SAAS,QAAQ,YAAY;AACtC,OAAOC,YAAY,SAAS;AAC5B,OAAOC,UAAU,OAAO;AACxB,SAASC,aAAa,QAAQ,MAAM;AAEpC,iCAAiC;AACjC,MAAMC,aAAaD,cAAc,YAAYE,GAAG;AAChD,MAAMC,YAAYJ,KAAKK,OAAO,CAACH;AAE/B,6BAA6B;AAC7BH,OAAOO,MAAM,CAAC;IAAEN,MAAMA,KAAKO,OAAO,CAACH,WAAW;AAAiB;AAE/D,MAAMI,YAAY,IAAIV,UAAU;IAC9BW,UAAUC,QAAQC,GAAG,CAACC,OAAO,IAAI;IACjCC,UAAUH,QAAQC,GAAG,CAACG,WAAW,IAAI;IACrCC,UAAUL,QAAQC,GAAG,CAACK,OAAO,IAAI;IACjCC,MAAMP,QAAQC,GAAG,CAACO,OAAO,IAAI;IAC7BC,MAAMC,OAAOV,QAAQC,GAAG,CAACU,OAAO,KAAK;IACrCC,SAAS;IACTC,SAAS;AACX;AAQA,eAAeC;IACb,IAAI;QACFC,QAAQC,GAAG,CAAC;QAEZ,mEAAmE;QACnE,MAAMC,QAAQ,CAAC;;;;;;;;;IASf,CAAC;QAED,MAAMC,UAAU,MAAMpB,UAAUmB,KAAK,CAACA,OAAO;YAC3CE,MAAM;QACR;QAEA,IAAID,QAAQE,MAAM,KAAK,GAAG;YACxBL,QAAQC,GAAG,CAAC;YACZD,QAAQC,GAAG,CAAC;YACZD,QAAQC,GAAG,CAAC;YACZhB,QAAQqB,IAAI,CAAC;QACf;QAEAN,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEE,QAAQE,MAAM,CAAC,+BAA+B,CAAC;QAEtE,MAAME,kBAAkB;YACtBC,mCAAmC;YACnCC,sDAAsD;QACxD;QAEA,KAAK,MAAMC,SAASP,QAAS;YAC3BH,QAAQC,GAAG,CAAC,CAAC,KAAK,EAAES,MAAMC,SAAS,CAAC,CAAC,CAAC;YACtCX,QAAQC,GAAG,CAAC,CAAC,YAAY,EAAES,MAAME,SAAS,EAAE;YAC5CZ,QAAQC,GAAG,CAAC,CAAC,iBAAiB,EAAES,MAAMG,QAAQ,EAAE;YAChDb,QAAQC,GAAG,CAAC;YAEZ,iCAAiC;YACjC,IAAIS,MAAME,SAAS,IAAIL,iBAAiB;gBACtCA,eAAe,CAACG,MAAME,SAAS,CAAiC,GAAG;YACrE;QACF;QAEA,sCAAsC;QACtC,MAAME,iBAAiBC,OAAOC,OAAO,CAACT,iBACnCU,MAAM,CAAC,CAAC,CAACC,GAAGC,OAAO,GAAK,CAACA,QACzBC,GAAG,CAAC,CAAC,CAACC,KAAK,GAAKA;QAEnB,IAAIP,eAAeT,MAAM,GAAG,GAAG;YAC7BL,QAAQC,GAAG,CAAC;YACZa,eAAeQ,OAAO,CAAC,CAACD;gBACtBrB,QAAQC,GAAG,CAAC,CAAC,KAAK,EAAEoB,MAAM;YAC5B;YACArB,QAAQC,GAAG,CAAC;YACZhB,QAAQqB,IAAI,CAAC;QACf;QAEAN,QAAQC,GAAG,CAAC;QACZD,QAAQC,GAAG,CAAC;QACZD,QAAQC,GAAG,CAAC;QACZD,QAAQC,GAAG,CAAC;QACZD,QAAQC,GAAG,CAAC;QAEZ,MAAMlB,UAAUwC,KAAK;QACrBtC,QAAQqB,IAAI,CAAC;IACf,EAAE,OAAOkB,OAAO;QACdxB,QAAQwB,KAAK,CAAC,6BAA6BA;QAC3C,MAAMzC,UAAUwC,KAAK;QACrBtC,QAAQqB,IAAI,CAAC;IACf;AACF;AAEAP"}

package/dist/lib/testing/testFixtures.js

@@ -0,0 +1,520 @@
+/**
+ * Test Fixtures and Utilities
+ *
+ * Centralized test data generators and helpers for consistent, type-safe testing
+ * across all 90dc projects.
+ *
+ * @module testFixtures
+ *
+ * Key Principles:
+ * - Industry-standard UUID v4 format (RFC 4122)
+ * - Complete, realistic mock data with proper TypeScript types
+ * - Reusable and composable fixtures
+ * - Deterministic test data for reproducible tests
+ * - No magic strings or fake IDs
+ *
+ * @example
+ * ```typescript
+ * import { TEST_UUIDS, createTestUser, freezeTime } from '90dc-core';
+ *
+ * const user = createTestUser({
+ *   userUuid: TEST_UUIDS.USER_1,
+ *   role: 'coach'
+ * });
+ * ```
+ */ /**
+ * Pre-generated valid UUID v4 identifiers for deterministic testing.
+ *
+ * These UUIDs follow RFC 4122 format and are safe to use across all tests.
+ * Using predefined UUIDs ensures test reproducibility and makes debugging easier.
+ *
+ * @example
+ * ```typescript
+ * const coachUuid = TEST_UUIDS.COACH_1;
+ * const clientUuid = TEST_UUIDS.CLIENT_1;
+ * ```
+ */ export const TEST_UUIDS = {
+    /** Generic user UUID #1 */ USER_1: '11111111-1111-4111-8111-111111111111',
+    /** Generic user UUID #2 */ USER_2: '22222222-2222-4222-8222-222222222222',
+    /** Generic user UUID #3 */ USER_3: '33333333-3333-4333-8333-333333333333',
+    /** Generic user UUID #4 */ USER_4: '44444444-4444-4444-8444-444444444444',
+    /** Generic user UUID #5 */ USER_5: '55555555-5555-4555-8555-555555555555',
+    /** Generic user UUID #6 */ USER_6: '66666666-6666-4666-8666-666666666666',
+    /** Generic user UUID #7 */ USER_7: '77777777-7777-4777-8777-777777777777',
+    /** Generic user UUID #8 */ USER_8: '88888888-8888-4888-8888-888888888888',
+    /** Generic user UUID #9 */ USER_9: '99999999-9999-4999-8999-999999999999',
+    /** Generic user UUID #10 */ USER_10: 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa',
+    /** Coach user UUID #1 */ COACH_1: 'c1111111-c111-4c11-8c11-c11111111111',
+    /** Coach user UUID #2 */ COACH_2: 'c2222222-c222-4c22-8c22-c22222222222',
+    /** Coach user UUID #3 */ COACH_3: 'c3333333-c333-4c33-8c33-c33333333333',
+    /** Head coach UUID */ HEAD_COACH: 'c0111111-1111-4111-8111-111111111111',
+    /** Client user UUID #1 */ CLIENT_1: 'cccccccc-cccc-4ccc-8ccc-cccccccccccc',
+    /** Client user UUID #2 */ CLIENT_2: 'dddddddd-dddd-4ddd-8ddd-dddddddddddd',
+    /** Client user UUID #3 */ CLIENT_3: 'eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee',
+    /** Finance role user UUID */ FINANCE: 'ffffffff-ffff-4fff-8fff-ffffffffffff',
+    /** Admin user UUID */ ADMIN: 'adadadad-adad-4dad-8dad-adadadadadad',
+    /** Super admin user UUID */ SUPER_ADMIN: 'aaaaaaaa-0000-4000-8000-000000000000'
+};
+/**
+ * UUID validation regex (RFC 4122 v4)
+ * @internal
+ */ const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+/**
+ * Validates if a string is a valid UUID v4
+ *
+ * @param value - String to validate
+ * @returns True if valid UUID v4, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidUUID('11111111-1111-4111-8111-111111111111'); // true
+ * isValidUUID('invalid-uuid'); // false
+ * ```
+ */ export function isValidUUID(value) {
+    return UUID_V4_REGEX.test(value);
+}
+/**
+ * Generates a unique email address for testing to avoid collisions.
+ *
+ * Format: `{prefix}-{timestamp}-{random}@{domain}`
+ *
+ * @param prefix - Email prefix (default: 'test')
+ * @param domain - Email domain (default: 'test.com')
+ * @returns Unique email address
+ *
+ * @example
+ * ```typescript
+ * generateTestEmail('coach'); // 'coach-1234567890-abc12@test.com'
+ * generateTestEmail('user', 'example.com'); // 'user-1234567890-xyz98@example.com'
+ * ```
+ */ export function generateTestEmail(prefix = 'test', domain = 'test.com') {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).slice(2, 7);
+    return `${prefix}-${timestamp}-${random}@${domain}`;
+}
+/**
+ * Creates a complete mock user with sensible defaults and type safety.
+ *
+ * All fields are properly typed and provide realistic test data.
+ *
+ * @param overrides - Partial user properties to override defaults
+ * @returns Complete UserTypes object
+ *
+ * @example
+ * ```typescript
+ * const user = createTestUser({
+ *   userUuid: TEST_UUIDS.USER_1,
+ *   role: 'coach',
+ *   email: 'coach@test.com'
+ * });
+ * ```
+ */ export function createTestUser(overrides) {
+    return {
+        userUuid: TEST_UUIDS.USER_1,
+        email: generateTestEmail('user'),
+        firstName: 'Test',
+        lastName: 'User',
+        role: 'user',
+        avatar: '1',
+        isSubscriptionActive: true,
+        ...overrides
+    };
+}
+/**
+ * Creates a mock coach user with coach-specific defaults.
+ *
+ * @param overrides - Partial user properties to override defaults
+ * @returns Complete coach UserTypes object
+ *
+ * @example
+ * ```typescript
+ * const coach = createTestCoach({
+ *   userUuid: TEST_UUIDS.COACH_1,
+ *   firstName: 'John',
+ *   lastName: 'Coach'
+ * });
+ * ```
+ */ export function createTestCoach(overrides) {
+    return createTestUser({
+        userUuid: TEST_UUIDS.COACH_1,
+        role: 'coach',
+        email: generateTestEmail('coach'),
+        firstName: 'Coach',
+        lastName: 'Test',
+        ...overrides
+    });
+}
+/**
+ * Creates a mock head coach user.
+ *
+ * @param overrides - Partial user properties to override defaults
+ * @returns Complete head coach UserTypes object
+ */ export function createTestHeadCoach(overrides) {
+    return createTestUser({
+        userUuid: TEST_UUIDS.HEAD_COACH,
+        role: 'head-coach',
+        email: generateTestEmail('head-coach'),
+        firstName: 'Head',
+        lastName: 'Coach',
+        ...overrides
+    });
+}
+/**
+ * Creates a mock finance user.
+ *
+ * Typically used for Richard (finance role) in financial tracking tests.
+ *
+ * @param overrides - Partial user properties to override defaults
+ * @returns Complete finance UserTypes object
+ */ export function createTestFinanceUser(overrides) {
+    return createTestUser({
+        userUuid: TEST_UUIDS.FINANCE,
+        role: 'finance',
+        email: generateTestEmail('finance'),
+        firstName: 'Richard',
+        lastName: 'Finance',
+        ...overrides
+    });
+}
+/**
+ * Creates a mock admin user.
+ *
+ * @param overrides - Partial user properties to override defaults
+ * @returns Complete admin UserTypes object
+ */ export function createTestAdmin(overrides) {
+    return createTestUser({
+        userUuid: TEST_UUIDS.ADMIN,
+        role: 'admin',
+        email: generateTestEmail('admin'),
+        firstName: 'Admin',
+        lastName: 'User',
+        ...overrides
+    });
+}
+/**
+ * Creates a mock client user (regular user role).
+ *
+ * @param overrides - Partial user properties to override defaults
+ * @returns Complete client UserTypes object
+ */ export function createTestClient(overrides) {
+    return createTestUser({
+        userUuid: TEST_UUIDS.CLIENT_1,
+        role: 'user',
+        email: generateTestEmail('client'),
+        firstName: 'Client',
+        lastName: 'User',
+        ...overrides
+    });
+}
+/**
+ * Fixed date constants for deterministic testing.
+ *
+ * Using consistent dates across tests ensures reproducible behavior
+ * and easier debugging of time-dependent logic.
+ */ export const TEST_DATES = {
+    /** Fixed date for deterministic tests: 2026-03-01 10:00:00 UTC */ FIXED_DATE: new Date('2026-03-01T10:00:00.000Z'),
+    /** Start of month: 2026-03-01 00:00:00 UTC */ MONTH_START: new Date('2026-03-01T00:00:00.000Z'),
+    /** End of month: 2026-03-31 23:59:59 UTC */ MONTH_END: new Date('2026-03-31T23:59:59.999Z'),
+    /** Yesterday relative to FIXED_DATE */ YESTERDAY: new Date('2026-02-28T10:00:00.000Z'),
+    /** Tomorrow relative to FIXED_DATE */ TOMORROW: new Date('2026-03-02T10:00:00.000Z'),
+    /** One week ago relative to FIXED_DATE */ WEEK_AGO: new Date('2026-02-22T10:00:00.000Z'),
+    /** One week from now relative to FIXED_DATE */ WEEK_AHEAD: new Date('2026-03-08T10:00:00.000Z')
+};
+/**
+ * Common test data patterns and constants.
+ */ export const TEST_DATA = {
+    /**
+   * Valid month format strings (YYYY-MM) for financial tracking
+   */ MONTHS: {
+        CURRENT: '2026-03',
+        PREVIOUS: '2026-02',
+        NEXT: '2026-04',
+        JANUARY: '2026-01',
+        DECEMBER: '2025-12'
+    },
+    /**
+   * Common test email domains
+   */ EMAIL_DOMAINS: [
+        'test.com',
+        'example.com',
+        'test.org',
+        'example.org'
+    ],
+    /**
+   * Sample notes for testing note-taking features
+   */ SAMPLE_NOTES: [
+        'Client is making great progress with consistency',
+        'Needs additional support with nutrition planning',
+        'Struggling with morning routine, discussed strategies',
+        'Excellent workout form, ready to increase weight',
+        'Discussed goal adjustments for next quarter'
+    ],
+    /**
+   * Common HTTP status codes for testing
+   */ HTTP_STATUS: {
+        OK: 200,
+        CREATED: 201,
+        NO_CONTENT: 204,
+        BAD_REQUEST: 400,
+        UNAUTHORIZED: 401,
+        FORBIDDEN: 403,
+        NOT_FOUND: 404,
+        CONFLICT: 409,
+        INTERNAL_SERVER_ERROR: 500
+    }
+};
+/**
+ * Waits for all pending promises to resolve.
+ *
+ * Useful for testing async operations that may have multiple
+ * promise chains.
+ *
+ * @returns Promise that resolves when all pending promises complete
+ *
+ * @example
+ * ```typescript
+ * await flushPromises();
+ * expect(mockCallback).toHaveBeenCalled();
+ * ```
+ */ export async function flushPromises() {
+    return new Promise((resolve)=>setImmediate(resolve));
+}
+/**
+ * Waits for a specific amount of time.
+ *
+ * @param ms - Milliseconds to wait
+ * @returns Promise that resolves after the specified time
+ *
+ * @example
+ * ```typescript
+ * await wait(1000); // Wait 1 second
+ * ```
+ */ export async function wait(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+/**
+ * Original Date class reference for restoring after time mocking
+ * @internal
+ */ let originalDate;
+/**
+ * Freezes time to a specific date for deterministic testing.
+ *
+ * This function mocks the global Date object to always return
+ * the specified date. Useful for testing time-dependent logic.
+ *
+ * **Important:** Call the returned cleanup function to restore
+ * normal Date behavior after your test.
+ *
+ * @param date - Date to freeze time to (default: TEST_DATES.FIXED_DATE)
+ * @returns Cleanup function to restore original Date behavior
+ *
+ * @example
+ * ```typescript
+ * const cleanup = freezeTime(new Date('2026-03-01'));
+ * const now = new Date(); // Always returns 2026-03-01
+ * cleanup(); // Restore normal behavior
+ * ```
+ */ export function freezeTime(date = TEST_DATES.FIXED_DATE) {
+    originalDate = Date;
+    const frozenTime = new Date(date).getTime();
+    // Intentionally mocking global Date for testing purposes
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    global.Date = class MockDate extends originalDate {
+        constructor(...args){
+            if (args.length === 0) {
+                super(frozenTime);
+            } else {
+                super(...args);
+            }
+        }
+        static now() {
+            return frozenTime;
+        }
+    };
+    // Preserve static methods
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    global.Date.UTC = originalDate.UTC;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+    global.Date.parse = originalDate.parse;
+    return ()=>{
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-explicit-any
+        global.Date = originalDate;
+    };
+}
+/**
+ * Custom assertion helpers for common test scenarios.
+ *
+ * These assertions provide better error messages and type safety
+ * compared to basic Jest assertions.
+ */ export const testAssertions = {
+    /**
+   * Asserts that a value is a valid UUID v4 (RFC 4122).
+   *
+   * @param value - String to validate
+   * @param message - Optional custom error message
+   * @throws Error if value is not a valid UUID v4
+   *
+   * @example
+   * ```typescript
+   * testAssertions.assertValidUUID('11111111-1111-4111-8111-111111111111');
+   * ```
+   */ assertValidUUID (value, message) {
+        if (!isValidUUID(value)) {
+            throw new Error(message || `Expected valid UUID v4, got: ${value}`);
+        }
+    },
+    /**
+   * Asserts that a date is within a specified range (inclusive).
+   *
+   * @param date - Date to check
+   * @param start - Start of valid range
+   * @param end - End of valid range
+   * @param message - Optional custom error message
+   * @throws Error if date is outside range
+   */ assertDateInRange (date, start, end, message) {
+        if (date < start || date > end) {
+            throw new Error(message || `Date ${date.toISOString()} not in range ${start.toISOString()} to ${end.toISOString()}`);
+        }
+    },
+    /**
+   * Asserts that an array has a specific length.
+   *
+   * @param array - Array to check
+   * @param expectedLength - Expected length
+   * @param message - Optional custom error message
+   * @throws Error if array length doesn't match
+   */ assertLength (array, expectedLength, message) {
+        if (array.length !== expectedLength) {
+            throw new Error(message || `Expected array length ${expectedLength}, got ${array.length}`);
+        }
+    },
+    /**
+   * Asserts that a value is truthy.
+   *
+   * @param value - Value to check
+   * @param message - Optional custom error message
+   * @throws Error if value is falsy
+   */ assertTruthy (value, message) {
+        if (!value) {
+            throw new Error(message || `Expected truthy value, got: ${value}`);
+        }
+    },
+    /**
+   * Asserts that a value is falsy.
+   *
+   * @param value - Value to check
+   * @param message - Optional custom error message
+   * @throws Error if value is truthy
+   */ assertFalsy (value, message) {
+        if (value) {
+            throw new Error(message || `Expected falsy value, got: ${value}`);
+        }
+    },
+    /**
+   * Asserts that two dates are equal (within 1 second tolerance).
+   *
+   * @param actual - Actual date
+   * @param expected - Expected date
+   * @param message - Optional custom error message
+   * @throws Error if dates are not equal within tolerance
+   */ assertDateEquals (actual, expected, message) {
+        const tolerance = 1000; // 1 second
+        const diff = Math.abs(actual.getTime() - expected.getTime());
+        if (diff > tolerance) {
+            throw new Error(message || `Dates are not equal. Expected: ${expected.toISOString()}, Got: ${actual.toISOString()}`);
+        }
+    }
+};
+/**
+ * Standard response builders for common API response patterns.
+ *
+ * These helpers ensure consistent response shapes across tests.
+ */ export const mockResponses = {
+    /**
+   * Creates a success response object.
+   *
+   * @param data - Response data
+   * @returns Success response object
+   *
+   * @example
+   * ```typescript
+   * const response = mockResponses.success({ id: 1, name: 'Test' });
+   * // { success: true, data: { id: 1, name: 'Test' } }
+   * ```
+   */ success (data) {
+        return {
+            success: true,
+            data
+        };
+    },
+    /**
+   * Creates an error response object.
+   *
+   * @param message - Error message
+   * @param code - Optional error code
+   * @returns Error response object
+   *
+   * @example
+   * ```typescript
+   * const response = mockResponses.error('Not found', 'NOT_FOUND');
+   * // { success: false, error: 'Not found', code: 'NOT_FOUND' }
+   * ```
+   */ error (message, code) {
+        return code ? {
+            success: false,
+            error: message,
+            code
+        } : {
+            success: false,
+            error: message
+        };
+    },
+    /**
+   * Creates a paginated response object.
+   *
+   * @param items - Array of items for current page
+   * @param total - Total number of items across all pages
+   * @param page - Current page number (1-indexed)
+   * @param limit - Items per page
+   * @returns Paginated response object
+   *
+   * @example
+   * ```typescript
+   * const response = mockResponses.paginated([item1, item2], 100, 1, 10);
+   * // {
+   * //   items: [item1, item2],
+   * //   total: 100,
+   * //   page: 1,
+   * //   limit: 10,
+   * //   hasMore: true
+   * // }
+   * ```
+   */ paginated (items, total, page = 1, limit = 10) {
+        return {
+            items,
+            total,
+            page,
+            limit,
+            hasMore: page * limit < total,
+            totalPages: Math.ceil(total / limit)
+        };
+    }
+};
+/**
+ * Type guard to check if a value is a non-null object.
+ *
+ * @param value - Value to check
+ * @returns True if value is a non-null object
+ */ export function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Type guard to check if a value is an array.
+ *
+ * @param value - Value to check
+ * @returns True if value is an array
+ */ export function isArray(value) {
+    return Array.isArray(value);
+}
+
+//# sourceMappingURL=testFixtures.js.map