packages/utils/src/logger/index.ts (2)

36-39: Unused type export.

LazyContext is defined and exported but never used anywhere in the codebase or in the LoggerOptions interface. Consider removing it to avoid dead code, or integrate it into LoggerOptions.context if lazy context evaluation is intended.

---

448-451: Inconsistent lazy evaluation optimization.

The debug() method (lines 436-443) correctly skips lazy message resolution when the log level is disabled and no toast/db output is requested. However, info(), warn(), error(), and success() always resolve the lazy message eagerly, negating the lazy evaluation benefit for these levels.

For consistency, consider applying the same optimization pattern to higher-severity methods, or document that lazy evaluation is only beneficial for debug().

♻️ Example fix for info() — apply similar pattern to warn/error/success

 	info(message: LazyMessage, options?: LoggerOptions): void {
+		if (!shouldLog('info') && !options?.showToast && !options?.saveToDb) {
+			return;
+		}
 		const resolvedMessage = resolveLazy(message);
 		log.info(resolvedMessage, this.buildOptions(options));
 	}

packages/core/src/screens/main/pos/cart/buttons/pay.tsx (3)

35-38: Inconsistent logger creation pattern.

The orderLogger is created inside the callback, which differs from the pattern used in use-add-fee.ts, use-add-shipping.ts, and use-add-customer.ts where orderLogger is memoized with React.useMemo outside the callback.

While both approaches work, consider using React.useMemo for consistency across the codebase and to avoid recreating the logger on every button press.

♻️ Suggested refactor for consistency

+	const orderLogger = React.useMemo(
+		() =>
+			checkoutLogger.with({
+				orderId: currentOrder.uuid,
+				orderNumber: currentOrder.number,
+			}),
+		[currentOrder.uuid, currentOrder.number]
+	);
+
 	const handlePay = React.useCallback(async () => {
 		setLoading(true);
-		const orderLogger = checkoutLogger.with({
-			orderId: currentOrder.uuid,
-			orderNumber: currentOrder.number,
-		});
-
 		try {

Then update the dependency array:

-	}, [pushDocument, currentOrder, router, t, total]);
+	}, [pushDocument, currentOrder, router, t, total, orderLogger]);

---

58-65: Unusual translation pattern for error messages.

Using t('{message}', { message: error.message }) passes the raw error message through the translation system, which won't provide any localization benefit since error messages are typically not in the translation catalog. Consider using a fixed translated string instead.

♻️ Suggested fix

-			orderLogger.error(t('{message}', { _tags: 'core', message: error.message || 'Error' }), {
+			orderLogger.error(t('Checkout failed', { _tags: 'core' }), {
 				showToast: true,
 				saveToDb: true,
 				context: {
 					errorCode: ERROR_CODES.TRANSACTION_FAILED,
 					error: error instanceof Error ? error.message : String(error),
 				},
 			});

---

43-55: Consider logging before navigation.

The "Checkout started" log is recorded after pushDocument succeeds but the router.push happens immediately after. If navigation fails or the user quickly navigates away, the log timing may be confusing. Consider moving the log before router.push or adding a separate "Checkout navigation" log.

packages/database/src/plugins/audit-log.ts (2)

110-114: Replace console.error with the logger library.

Per coding guidelines, use the logger library exclusively for logging instead of console.log/console.error. While this is a catch block for audit log failures, it should still use the project's logging infrastructure.

♻️ Suggested fix

+import log from '@wcpos/utils/logger';
+
 // ... in logAuditEvent function
 	} catch (e) {
 		// Don't let audit logging errors break the main operation
-		console.error('[AuditLog] Failed to write audit log:', e);
+		log.warn('[AuditLog] Failed to write audit log', { error: e });
 	}

Based on coding guidelines: "Use the logger library exclusively for logging; DO NOT use console.log."

---

42-46: Consider defensive handling for JSON.stringify.

JSON.stringify can throw on circular references (though unlikely in RxDB documents). Consider wrapping in try/catch for robustness, or document the assumption that documents are always JSON-safe.

♻️ Optional defensive fix

-		// Use JSON comparison for deep equality
-		if (JSON.stringify(beforeVal) !== JSON.stringify(afterVal)) {
-			changes[key] = { old: beforeVal, new: afterVal };
-		}
+		// Use JSON comparison for deep equality
+		try {
+			if (JSON.stringify(beforeVal) !== JSON.stringify(afterVal)) {
+				changes[key] = { old: beforeVal, new: afterVal };
+			}
+		} catch {
+			// Fallback to reference comparison if JSON.stringify fails
+			if (beforeVal !== afterVal) {
+				changes[key] = { old: beforeVal, new: afterVal };
+			}
+		}

packages/database/src/plugins/audit-log.test.ts (1)

49-50: Consider using deterministic waiting patterns instead of fixed timeouts.

The waitFor helper with hardcoded milliseconds (100ms, 200ms used throughout) can lead to flaky tests on slower CI runners or under load. Consider polling the logs collection until the expected audit entry appears, with a timeout for failure cases.

♻️ Suggested deterministic wait helper

-// Helper to wait for async operations
-const waitFor = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+// Helper to wait for a condition with timeout
+const waitForCondition = async (
+	condition: () => Promise<boolean>,
+	timeoutMs = 1000,
+	intervalMs = 10
+): Promise<void> => {
+	const start = Date.now();
+	while (Date.now() - start < timeoutMs) {
+		if (await condition()) return;
+		await new Promise((resolve) => setTimeout(resolve, intervalMs));
+	}
+	throw new Error('Condition not met within timeout');
+};

packages/database/src/plugins/audit-log.ts (8)

38-39: Module-level state is acceptable but consider cleanup on database destruction.

The collectionSubscriptions Map correctly tracks subscriptions per collection. However, there's no cleanup when a database is destroyed (only when collections are re-created). This could lead to stale entries in long-running processes with database recreation.

---

44-48: Replace any with stricter types.

Per coding guidelines, avoid using any. Consider using unknown or a more specific record type.

♻️ Suggested type improvement

 function calculateChanges(
-	before: Record<string, any>,
-	after: Record<string, any>,
+	before: Record<string, unknown>,
+	after: Record<string, unknown>,
 	excludeFields: string[]
-): Record<string, { old: any; new: any }> | null {
+): Record<string, { old: unknown; new: unknown }> | null {

Based on coding guidelines, do not use 'any' type.

---

72-89: Replace any in parameter type.

♻️ Suggested fix

-function getDocumentIdentifier(collectionName: string, data: Record<string, any>): string {
+function getDocumentIdentifier(collectionName: string, data: Record<string, unknown>): string {

Based on coding guidelines, do not use 'any' type.

---

94-102: Replace any types in interface.

♻️ Suggested fix

 async function logAuditEvent(
 	collection: RxCollection,
 	operation: 'insert' | 'update' | 'delete',
 	data: {
 		documentId: string;
-		before?: Record<string, any>;
-		after?: Record<string, any>;
-		changes?: Record<string, { old: any; new: any }> | null;
+		before?: Record<string, unknown>;
+		after?: Record<string, unknown>;
+		changes?: Record<string, { old: unknown; new: unknown }> | null;
 	}
 ): Promise<void> {

Based on coding guidelines, do not use 'any' type.

---

150-159: Replace any in generic type parameter.

♻️ Suggested fix

-	const insertSub = collection.insert$.subscribe((changeEvent: RxChangeEvent<any>) => {
+	const insertSub = collection.insert$.subscribe((changeEvent: RxChangeEvent<unknown>) => {

Based on coding guidelines, do not use 'any' type.

---

155-158: Fire-and-forget async call is intentional but could silently fail.

The logAuditEvent call is intentionally not awaited to avoid blocking the Observable stream. The function has internal error handling, so this is acceptable. However, consider adding a comment clarifying this is intentional.

♻️ Optional: Add clarifying comment

+		// Fire-and-forget: errors are caught internally in logAuditEvent
 		logAuditEvent(collection, 'insert', {
 			documentId,
 			after: documentData,
 		});

---

162-180: Replace any in generic type parameter.

♻️ Suggested fix

-	const updateSub = collection.update$.subscribe((changeEvent: RxChangeEvent<any>) => {
+	const updateSub = collection.update$.subscribe((changeEvent: RxChangeEvent<unknown>) => {

Based on coding guidelines, do not use 'any' type.

---

183-193: Replace any in generic type parameter.

♻️ Suggested fix

-	const removeSub = collection.remove$.subscribe((changeEvent: RxChangeEvent<any>) => {
+	const removeSub = collection.remove$.subscribe((changeEvent: RxChangeEvent<unknown>) => {

Based on coding guidelines, do not use 'any' type.

packages/core/src/screens/main/pos/products/use-barcode.ts (2)

3-9: Move the logger declaration after all imports.

The barcodeLogger declaration on line 8 is placed between import statements. All imports should be grouped at the top of the file, followed by module-level declarations.

Proposed fix

 import { useObservableEagerState, useSubscription } from 'observable-hooks';

 import { getLogger } from '@wcpos/utils/logger';
 import { ERROR_CODES } from '@wcpos/utils/logger/error-codes';

 import { useT } from '../../../../contexts/translations';
-
-const barcodeLogger = getLogger(['wcpos', 'barcode', 'pos']);
 import { useUISettings } from '../../contexts/ui-settings';
 import { useBarcodeDetection, useBarcodeSearch } from '../../hooks/barcodes';
 import { useCollection } from '../../hooks/use-collection';
 import { useAddProduct } from '../hooks/use-add-product';
 import { useAddVariation } from '../hooks/use-add-variation';

 import type { QuerySearchInput } from '../../components/query-search-input';
+
+const barcodeLogger = getLogger(['wcpos', 'pos', 'barcode']);

---

8-8: Logger namespace order appears inconsistent with PR convention.

Based on the PR's documented pattern (e.g., getLogger(['wcpos', 'pos', 'cart'])), the hierarchy should be wcpos → domain (pos) → sub-domain (barcode). The current order ['wcpos', 'barcode', 'pos'] has barcode and pos swapped.

Proposed fix

-const barcodeLogger = getLogger(['wcpos', 'barcode', 'pos']);
+const barcodeLogger = getLogger(['wcpos', 'pos', 'barcode']);

packages/core/src/screens/main/hooks/use-rest-http-client/auth-error-handler.ts (1)

111-135: Add explicit “why” comments for both useEffect hooks.

Section headers describe behavior but not why the effects must run (vs. direct event handling or render). Please add a short rationale above each effect. As per coding guidelines, ...

✍️ Example comment additions

-// EFFECT: Trigger OAuth when flag is set
+// EFFECT: Trigger OAuth when flag is set
+// WHY: promptAsync must run as a side-effect after state flips, not during error handling.
 React.useEffect(() => {
   if (shouldTriggerAuth) {
     authLogger.debug('[AUTH_HANDLER] shouldTriggerAuth is true, calling promptAsync', {
       context: { siteName: site.name },
     });
@@
-// EFFECT: Process OAuth response
+// EFFECT: Process OAuth response
+// WHY: response arrives asynchronously; side-effects (token save/toast) must run on change.
 React.useEffect(() => {
   if (!response) return;

Also applies to: 141-251

packages/core/src/hooks/use-wcpos-auth/index.web.ts (1)

114-183: Add explicit “why” notes for the two useEffect blocks. The current comments say what they do, but the guideline requires a brief rationale for using useEffect here.

✍️ Suggested comment updates

- // Handle expo-auth-session response
+ // Handle expo-auth-session response.
+ // WHY: response is produced asynchronously by expo-auth-session and must be reconciled when it changes.
  React.useEffect(() => {
    ...
  }, [response]);

- // Check URL on mount for auth tokens (handles redirect return)
+ // Check URL on mount for auth tokens (handles redirect return).
+ // WHY: redirect modifies the URL outside React; a one-time mount check is required.
  React.useEffect(() => {
    ...
  }, []);

As per coding guidelines, please add a short “why” note for each useEffect.

packages/core/src/screens/auth/components/add-user-button.tsx (1)

1-1: Use namespace import for React.

Per coding guidelines, always use namespace imports for React (e.g., import * as React from 'react') instead of default imports.

Suggested fix

-import React from 'react';
+import * as React from 'react';

packages/core/src/screens/main/logs/filter-bar.tsx (1)

7-8: Type import interleaved with component imports.

The Query type import is placed between component imports. While not a syntax error, grouping type imports separately or with related module imports improves readability.

💡 Suggested organization

 import { HStack } from '@wcpos/components/hstack';
-import type { Query } from '@wcpos/query';
 import { ButtonPill, ButtonText } from '@wcpos/components/button';
 import {
 	DropdownMenu,
 	DropdownMenuTrigger,
 	DropdownMenuContent,
 	DropdownMenuCheckboxItem,
 } from '@wcpos/components/dropdown-menu';
 import { Text } from '@wcpos/components/text';
+import type { Query } from '@wcpos/query';

packages/core/src/screens/main/logs/cells/level.tsx (1)

24-24: Avoid using any type.

Per coding guidelines, use strict types instead of any. Consider using a more specific type or a generic constraint.

Suggested fix

-	const query = table.options.meta?.query as Query<any> | undefined;
+	const query = table.options.meta?.query as Query<import('@wcpos/database').LogCollection> | undefined;

Alternatively, if the collection type varies, you could use Query<RxCollection> with the appropriate import.

packages/core/src/screens/main/hooks/barcodes/use-barcode-detection.ts-12-14 (1)

12-14: Import statement must precede non-import statements.

The import { useT } on line 14 appears after the const barcodeLogger declaration on line 13. ES modules require all imports to be at the top of the file before any other statements. Move the logger initialization after all imports.

Proposed fix

 import { getLogger } from '@wcpos/utils/logger';
 import { ERROR_CODES } from '@wcpos/utils/logger/error-codes';
 
 import { useAppState } from '../../../../contexts/app-state';
-
-const barcodeLogger = getLogger(['wcpos', 'barcode', 'detection']);
 import { useT } from '../../../../contexts/translations';
+
+const barcodeLogger = getLogger(['wcpos', 'barcode', 'detection']);

packages/core/src/contexts/app-state/index.tsx-8-10 (1)

8-10: Import ordering issue and unused logger.

Two issues with this change:

1. The appLogger declaration (line 9) is placed between import statements. All imports should be grouped at the top of the file before any executable code.

2. appLogger is created but never used anywhere in this file. Either add logging calls where appropriate (e.g., in login, logout, switchStore) or remove the unused variable.

🔧 Proposed fix

Move the logger declaration after all imports:

 import * as React from 'react';
 
 import type { StoreDocument } from '@wcpos/database';
 import Platform from '@wcpos/utils/platform';
 import { getLogger } from '@wcpos/utils/logger';
 
-
-const appLogger = getLogger(['wcpos', 'app', 'state']);
 import { hydrateUserSession } from './use-hydration-suspense';
+import { hydrateUserSession } from './hydration-steps';
 
 import type { HydrationContext } from './hydration-steps';
+
+const appLogger = getLogger(['wcpos', 'app', 'state']);

Then use appLogger for state transitions, e.g.:

const login = React.useCallback(async (...) => {
  appLogger.info('User login', { siteID, storeID });
  // ... existing code
}, [...]);

packages/core/src/screens/main/hooks/use-print/use-print.web.ts-33-36 (1)

33-36: Typo in JSDoc comment.

The documentation string contains a typo: "diaprintLogger" should be "dialog".

📝 Proposed fix

 /**
  * Web implementation of usePrint hook using react-to-print.
- * Prints DOM content via browser print diaprintLogger.
+ * Prints DOM content via browser print dialog.
  */

packages/core/src/screens/main/contexts/use-delete-document.tsx-4-10 (1)

4-10: Import statement placement issue.

The useRestHttpClient import on line 10 is placed after the module-scoped logger initialization on line 9. All imports should be grouped together before any module-level code.

🔧 Suggested fix

 import { getLogger } from '@wcpos/utils/logger';
 import { ERROR_CODES } from '@wcpos/utils/logger/error-codes';

 import { useT } from '../../../contexts/translations';
-
-const syncLogger = getLogger(['wcpos', 'sync', 'delete']);
 import { useRestHttpClient } from '../hooks/use-rest-http-client';
+
+const syncLogger = getLogger(['wcpos', 'sync', 'delete']);

packages/core/src/screens/main/hooks/mutations/use-local-mutation.ts-13-19 (1)

13-19: Import statement placement issue.

The convertLocalDateToUTCString import on line 19 is placed after the module-scoped logger initialization on line 18. All imports should be grouped together at the top of the file before any module-level code execution.

🔧 Suggested fix

 import { getLogger } from '@wcpos/utils/logger';
 import { ERROR_CODES } from '@wcpos/utils/logger/error-codes';

 import { useT } from '../../../../contexts/translations';
-
-const mutationLogger = getLogger(['wcpos', 'mutations', 'local']);
 import { convertLocalDateToUTCString } from '../../../../hooks/use-local-date';
+
+const mutationLogger = getLogger(['wcpos', 'mutations', 'local']);

packages/core/src/screens/main/components/order/filter-bar/cashier-pill.tsx-15-20 (1)

15-20: Import statement placement issue.

The useCustomerNameFormat import on line 20 is placed after the module-scoped logger initialization on line 19. All imports should be grouped together before any module-level code.

🔧 Suggested fix

 import { getLogger } from '@wcpos/utils/logger';

 import { useT } from '../../../../../contexts/translations';
-
-const uiLogger = getLogger(['wcpos', 'ui', 'filter']);
 import useCustomerNameFormat from '../../../hooks/use-customer-name-format';
 import { CustomerList } from '../../customer-select';
+
+const uiLogger = getLogger(['wcpos', 'ui', 'filter']);

packages/core/src/screens/main/settings/tax.tsx-23-28 (1)

23-28: Import statement placement issue.

The useT import on line 28 is placed after the module-scoped logger initialization on line 27. All imports should be grouped together before any module-level code.

🔧 Suggested fix

 import { getLogger } from '@wcpos/utils/logger';

 import { useAppState } from '../../../contexts/app-state';
-
-const uiLogger = getLogger(['wcpos', 'ui', 'settings']);
 import { useT } from '../../../contexts/translations';
+
+const uiLogger = getLogger(['wcpos', 'ui', 'settings']);
 import { FormErrors } from '../components/form-errors';

packages/core/src/screens/main/components/header/user-menu.tsx-92-94 (1)

92-94: Incorrect error logging pattern.

The err is passed as a second argument, but the CategoryLogger.error() method expects an options object with a context property. The error won't be properly captured in the log.

🔧 Proposed fix

 		} catch (err) {
-			uiLogger.error('Failed to clear database:', err);
+			uiLogger.error('Failed to clear database', {
+				context: {
+					error: err instanceof Error ? err.message : String(err),
+				},
+			});
 		}

packages/hooks/src/use-why-did-you-update.tsx (1)

7-29: Replace any with strict props typing (avoid @ts-ignore).

This violates the “no any” rule and forces repeated ignores. Prefer a typed record/generic to keep type safety. As per coding guidelines, ...

♻️ Suggested typing cleanup

-function useWhyDidYouUpdate(name: string, props: any) {
+function useWhyDidYouUpdate<T extends Record<string, unknown>>(name: string, props: T) {
 	// Get a mutable ref object where we can store props ...
 	// ... for comparison next time this hook runs.
-	const previousProps = React.useRef();
+	const previousProps = React.useRef<T>();
 	React.useEffect(() => {
 		if (previousProps.current) {
 			// Get all keys from previous and current props
-			// `@ts-ignore`
-			const allKeys = Object.keys({ ...previousProps.current, ...props });
+			const allKeys = Object.keys({ ...previousProps.current, ...props });
 			// Use this object to keep track of changed props
-			const changesObj = {};
+			const changesObj: Record<string, { from: unknown; to: unknown }> = {};
 			// Iterate through keys
 			allKeys.forEach((key) => {
 				// If previous is different from current
-				// `@ts-ignore`
 				if (previousProps.current[key] !== props[key]) {
 					// Add to changesObj
-					// `@ts-ignore`
 					changesObj[key] = {
-						// `@ts-ignore`
 						from: previousProps.current[key],
 						to: props[key],
 					};
 				}
 			});

packages/core/src/contexts/translations/index.tsx (1)

10-12: Move logger instantiation after all imports.

The const appLogger declaration is placed between import statements, which breaks standard import grouping conventions. Move it after all imports for consistent code organization.

Suggested reordering

 import { getLogger } from '@wcpos/utils/logger';
 import { ERROR_CODES } from '@wcpos/utils/logger/error-codes';

 import CustomCache from './cache';
-
-const appLogger = getLogger(['wcpos', 'app', 'translations']);
 import { useLocale } from '../../hooks/use-locale';
 import { useAppState } from '../app-state';
+
+const appLogger = getLogger(['wcpos', 'app', 'translations']);

 export const TranslationContext = React.createContext<TxNative['translate']>(null);

packages/core/src/screens/main/contexts/use-push-document.ts (1)

54-54: Avoid using any type.

The json: any parameter type violates the coding guideline requiring strict types. Consider using a generic or a more specific type for the document data being sent to the server.

As per coding guidelines: "Do not use 'any' type; use strict types and generics instead."

packages/core/src/screens/main/components/product/variable-price.tsx (2)

12-14: Move the type import above the logger initialization.

The type import on line 14 should be grouped with other imports at the top of the file, before any module-level code executes.

Suggested reordering

 import { getLogger } from '@wcpos/utils/logger';
 import { ERROR_CODES } from '@wcpos/utils/logger/error-codes';
+
+import type { CellContext } from '@tanstack/react-table';

 import { PriceWithTax } from './price-with-tax';

 const uiLogger = getLogger(['wcpos', 'ui', 'product']);
-
-import type { CellContext } from '@tanstack/react-table';

---

21-21: Add type annotation to metaData parameter.

The metaData parameter is implicitly typed as any. Per coding guidelines, use strict types instead.

Suggested fix

-function getVariablePrices(metaData) {
+function getVariablePrices(metaData: ProductDocument['meta_data'] | undefined) {

packages/core/src/screens/main/receipt/email.tsx (1)

44-73: Inconsistent indentation in try-catch-finally block.

The indentation is inconsistent: line 45 uses 4 tabs while lines 46-59 use 3 tabs. Consider normalizing for readability.

packages/core/src/hooks/use-novu-notifications.ts (1)

270-277: Add an explicit “why useEffect” comment for compliance.

The effect sets up external subscriptions and async side effects; per guidelines, add a brief comment stating why this must live in useEffect and can’t be done during render or an event handler.

As per coding guidelines, add a one‑line justification.

✍️ Suggested comment

-	React.useEffect(() => {
+	// useEffect is required here to manage external subscriptions and async side effects.
+	React.useEffect(() => {

packages/core/src/screens/main/settings/tax.tsx (1)

137-141: Consider adding user feedback for restore failure.

The error is logged but the user receives no visual feedback when the restore operation fails. Consider adding showToast: true and an appropriate error code for better user experience.

♻️ Suggested improvement

 		} catch (error) {
 			uiLogger.error('Failed to restore server settings', {
+				showToast: true,
 				context: { error: error instanceof Error ? error.message : String(error) },
 			});
 		} finally {

packages/core/src/screens/main/contexts/use-delete-document.tsx (1)

43-53: Consider dynamic error code mapping.

The error code is hardcoded to CONNECTION_REFUSED, but deletion can fail for various reasons (permissions, not found, validation errors, etc.). Consider using the error mapping utilities mentioned in the README (mapToInternalCode) to derive a more accurate error code from the server response.

packages/hooks/src/use-http-client/use-http-error-handler.tsx (1)

110-110: Consider adding a proper type for the Axios config.

Using any for the config type bypasses type checking.

♻️ Suggested improvement

-			const config = get(error, 'config') as any;
+			const config = get(error, 'config') as import('axios').InternalAxiosRequestConfig | undefined;

packages/database/src/plugins/audit-log.ts (1)

151-160: Fire-and-forget logging may cause unhandled promise rejections.

The logAuditEvent call in subscriptions is not awaited. While errors are caught inside the function, if the promise is rejected before entering the try block (unlikely but possible), it would be unhandled.

♻️ Consider adding .catch() for safety

 	const insertSub = collection.insert$.subscribe((changeEvent: RxChangeEvent<any>) => {
 		const documentData = changeEvent.documentData;
 		const documentId = changeEvent.documentId;

-		logAuditEvent(collection, 'insert', {
+		logAuditEvent(collection, 'insert', {
 			documentId,
 			after: documentData,
-		});
+		}).catch(() => {
+			// Error already handled inside logAuditEvent
+		});
 	});

packages/database/src/plugins/audit-log.test.ts (1)

49-50: Consider using a more robust async wait pattern.

The simple setTimeout-based waitFor can be flaky in CI environments. Consider using RxDB's built-in utilities or polling until the expected condition is met.

♻️ Alternative approach using polling

// Helper to wait for a condition with timeout
const waitForCondition = async (
	condition: () => Promise<boolean>,
	timeout = 1000,
	interval = 50
): Promise<void> => {
	const start = Date.now();
	while (Date.now() - start < timeout) {
		if (await condition()) return;
		await new Promise((resolve) => setTimeout(resolve, interval));
	}
	throw new Error('Condition not met within timeout');
};

// Usage example:
await waitForCondition(async () => {
	const logs = await logsCollection.find().exec();
	return logs.some((log) => log.code === 'AUDIT_INSERT');
});