packages/query/tests/manager.test.ts (1)

39-43: Consider asserting logger output instead of skipping.
Since Manager.error$ isn’t implemented, you can keep coverage by asserting the mocked logger calls (or add error$).

packages/query/src/search-adapter.ts (1)

32-56: Replace Promise<any> with a typed search instance.
searchInstancePromise loses type safety; prefer the inferred initSearch return type or a dedicated interface. As per coding guidelines, avoid any.

♻️ Proposed typing upgrade

 type DocumentType<C> = C extends RxCollection<infer D> ? D : never;
+type SearchInstance<C extends RxCollection> = Awaited<ReturnType<C['initSearch']>>;
 ...
-	private readonly searchInstancePromise: Promise<any>;
+	private readonly searchInstancePromise: Promise<SearchInstance<T>>;

packages/query/src/relational-query-state.ts (1)

55-67: Avoid Query<any> for the child query.
Prefer a child-collection generic so the parent_id shape is typed and any is eliminated. As per coding guidelines, avoid any.

♻️ Possible direction

-export class RelationalQuery<T extends RxCollection> extends Query<T> {
+export class RelationalQuery<TParent extends RxCollection, TChild extends RxCollection> extends Query<TParent> {
 ...
-	private readonly childQuery: Query<any>;
+	private readonly childQuery: Query<TChild>;
-	private readonly parentLookupQuery: Query<T>;
+	private readonly parentLookupQuery: Query<TParent>;

packages/query/src/collection-swap.ts (1)

14-25: Type Manager generically instead of any.
This keeps swap config type-safe and aligns with the no-any guideline. As per coding guidelines, avoid any.

♻️ Proposed typing tweak

-export interface CollectionSwapConfig {
-	manager: Manager<any>;
+export interface CollectionSwapConfig<TDatabase extends RxDatabase = RxDatabase> {
+	manager: Manager<TDatabase>;
 	collectionName: string;
-	storeDB: RxDatabase;
-	fastStoreDB: RxDatabase;
+	storeDB: TDatabase;
+	fastStoreDB: TDatabase;
 	timeout?: number;
 }

packages/query/tests/__mocks__/logger.ts (1)

1-6: Consider adding success method to the mock logger.

Per the coding guidelines, the logger library includes a log.success() method. If production code uses this method, tests may fail or behave unexpectedly without it mocked.

♻️ Suggested addition

 const mockLogger = {
 	error: jest.fn(),
 	warn: jest.fn(),
 	info: jest.fn(),
 	debug: jest.fn(),
+	success: jest.fn(),
 };

packages/query/src/sync-state.ts (1)

4-9: Minor: Import ordering could be improved.

The RxDocument type import on line 9 is placed after the logger imports and the yieldToEventLoop import. Consider grouping type imports together for consistency.

♻️ Suggested reordering

 import { getLogger } from '@wcpos/utils/logger';
 import { ERROR_CODES } from '@wcpos/utils/logger/error-codes';
 
 import { yieldToEventLoop } from './yield';
 
-import type { StoreCollection, SyncCollection } from '@wcpos/database';
-
-const syncLogger = getLogger(['wcpos', 'sync', 'state']);
 import type { RxDocument } from 'rxdb';
+import type { StoreCollection, SyncCollection } from '@wcpos/database';
+
+const syncLogger = getLogger(['wcpos', 'sync', 'state']);

packages/query/tests/provider.test.tsx (1)

83-101: Avoid dangling subscriptions in this async test.

Line 88 subscribes to rxQuery$ without unsubscribe, and Line 100 calls done() from result$ only. This can leave an open handle or run assertions after the test finishes. Consider taking one emission from each stream and awaiting both before calling done().

♻️ Suggested change

-import { render, cleanup } from '@testing-library/react';
+import { render, cleanup } from '@testing-library/react';
+import { firstValueFrom, take } from 'rxjs';

-			query.rxQuery$.subscribe((rxQuery) => {
-				expect(rxQuery).toBeDefined();
-			});
-
-			query.result$.subscribe((result) => {
-				expect(result).toEqual(
-					expect.objectContaining({
-						searchActive: false,
-						hits: [],
-						count: 0,
-					})
-				);
-				done();
-			});
+			const rxQueryPromise = firstValueFrom(query.rxQuery$.pipe(take(1)));
+			const resultPromise = firstValueFrom(query.result$.pipe(take(1)));
+
+			Promise.all([rxQueryPromise, resultPromise])
+				.then(([rxQuery, result]) => {
+					expect(rxQuery).toBeDefined();
+					expect(result).toEqual(
+						expect.objectContaining({
+							searchActive: false,
+							hits: [],
+							count: 0,
+						})
+					);
+					done();
+				})
+				.catch(done);

packages/query/tests/search-adapter.test.ts (1)

23-48: Consider asserting search$ payloads, not just existence.

Right now the tests only validate that search$ exists (Line 37). A focused test that triggers search() and verifies the emitted payload would catch regressions in emitted shape and IDs list.

packages/query/tests/collection-replication-state.test.ts (1)

62-65: Track the skipped tests so coverage doesn’t regress.

These TODO skips reduce coverage for error handling and sync flows. If helpful, I can propose adjustments to the http mock (partial params) and logger mock (log persistence) to re-enable them.

Also applies to: 110-113, 151-152

packages/query/tests/helpers/db.ts (1)

121-121: Consider removing unused collections variable here as well.

Same pattern as line 102 - the return value is assigned but not used.

Proposed fix

-	const collections = await db.addCollections({ products: sync, variations: sync });
+	await db.addCollections({ products: sync, variations: sync });

packages/query/src/collection-replication-state.ts (1)

20-27: Consider using a type guard instead of any for auth cancel detection.

The isAuthCancelError function uses any for the error parameter. While this is pre-existing code, consider typing it more strictly if refactoring in the future.

Proposed improvement

-function isAuthCancelError(error: any): boolean {
+function isAuthCancelError(error: unknown): boolean {
+	if (typeof error !== 'object' || error === null) return false;
+	const err = error as Record<string, unknown>;
 	return (
-		isCancel(error) ||
-		error?.name === 'CanceledError' ||
-		error?.code === 'ERR_CANCELED' ||
-		error?.message?.includes('attempting re-authentication')
+		isCancel(err) ||
+		err.name === 'CanceledError' ||
+		err.code === 'ERR_CANCELED' ||
+		(typeof err.message === 'string' && err.message.includes('attempting re-authentication'))
 	);
 }

Based on coding guidelines, any types should be avoided in favor of strict types.

packages/query/tests/__mocks__/http.ts (1)

136-136: Replace console.error with the logger library.

As per coding guidelines, use the logger library exclusively for logging instead of console.log/console.error. However, since this is a test mock file where the actual logger is being mocked, using console.error here may be intentional to avoid circular dependencies.

packages/query/tests/__mocks__/logger.ts (1)

1-6: Consider adding success method to match the logger API.

Per coding guidelines, the logger supports log.success(). If the real logger has this method, the mock should include it to avoid test failures when code uses logger.success().

Proposed fix

 const mockLogger = {
 	error: jest.fn(),
 	warn: jest.fn(),
 	info: jest.fn(),
 	debug: jest.fn(),
+	success: jest.fn(),
 };

packages/query/src/data-fetcher.ts (1)

47-57: Consider adding early abort check for efficiency.

While the HTTP client will handle the aborted signal, you could short-circuit early if the signal is already aborted to avoid unnecessary setup work.

Optional enhancement

 remotePatch(doc: any, data: any, signal?: AbortSignal) {
+	if (signal?.aborted) {
+		return Promise.reject(new DOMException('Aborted', 'AbortError'));
+	}
 	let endpoint = `${this.endpoint}/${doc.id}`;
 	if (this.endpoint === 'variations') {
 		endpoint = `products/${doc.parent_id}/variations/${doc.id}`;
 	}
 	return this.httpClient.patch(endpoint, data, { signal });
 }

This is optional since the HTTP client should handle aborted signals, but it avoids the endpoint construction work when already canceled.

packages/query/src/relational-query-state.ts (1)

60-66: Avoid any type for child and parent lookup queries.

The coding guidelines specify not to use any type. Consider using a generic type parameter or a more specific collection type for childQuery and parentLookupQuery to maintain type safety.

♻️ Suggested improvement

-export class RelationalQuery<T extends RxCollection> extends Query<T> {
+export class RelationalQuery<T extends RxCollection, C extends RxCollection = RxCollection> extends Query<T> {
 	/**
 	 * Query for child collection (e.g., variations)
 	 * Must have documents with `parent_id` field
 	 */
-	private readonly childQuery: Query<any>;
+	private readonly childQuery: Query<C>;

 	/**
 	 * Query for looking up parent UUIDs by ID
 	 * Used to convert parent_ids from children to UUIDs
 	 */
 	private readonly parentLookupQuery: Query<T>;

As per coding guidelines, strict types and generics should be used instead of any.

packages/query/src/collection-swap.ts (1)

14-25: Avoid any type for Manager generic.

The Manager<any> type loses type safety. Consider using a more specific database type or generic constraint.

♻️ Suggested improvement

+import type { RxDatabase } from 'rxdb';
+
 export interface CollectionSwapConfig {
 	/** The Manager instance to coordinate with */
-	manager: Manager<any>;
+	manager: Manager<RxDatabase>;
 	/** Name of the collection to swap */
 	collectionName: string;

As per coding guidelines, strict types should be used instead of any.

packages/query/tests/performance.test.ts (1)

67-110: Consider CI‑friendly performance budgets.
Strict time caps can be flaky across CI runners. A small refactor to make budgets environment‑aware would reduce false failures.

🧭 Example: parameterize a budget

-			expect(duration).toBeLessThan(10000);
+			const budget = process.env.CI ? 20000 : 10000;
+			expect(duration).toBeLessThan(budget);

Also applies to: 142-179, 182-204, 245-273

packages/database/src/index.ts (1)

3-4: Consider renaming types file to avoid .d.ts import ambiguity.

Importing ./types.d directly works but is unconventional. TypeScript .d.ts files are typically auto-included via tsconfig.json references rather than explicit imports. Consider renaming to ./types.ts (with only type declarations) or using a triple-slash reference directive, which is the standard pattern for module augmentation side-effects.

That said, this approach does work and ensures the augmentations are loaded when the package is imported.

packages/database/src/plugins/reset-collection.test.ts (1)

52-92: Clarify the comment on line 59.

The comment "fast_store doesn't start with just 'store'" is slightly misleading. The actual reason 'fast_store_abc123'.startsWith('store') returns false is that the string starts with 'f', not 's'. Consider rewording to: "fast_store starts with 'f', not 's', so it doesn't match 'store' prefix".

packages/database/src/plugins/search.test.ts (3)

103-112: The eviction condition has a subtle edge case.

The condition lru.length > MAX_CACHED_LOCALES && instances.size > MAX_CACHED_LOCALES requires both conditions. If lru and instances get out of sync (e.g., due to a bug elsewhere), eviction might not happen when expected. This mirrors the actual implementation, which is good for testing accuracy, but consider adding a test case that verifies behavior when lru.length !== instances.size.

---

372-388: Potential issue: Modifying Map during iteration.

The test modifies instances inside the for...of loop with instances.delete(locale). While this works in JavaScript (the iteration completes correctly), it's generally considered a code smell. The actual implementation in search.ts does the same pattern in cleanup, so this test accurately reflects production behavior.

♻️ Safer iteration pattern (optional)

 it('should destroy all search instances on cleanup', async () => {
   const instances = new Map([
     ['en', { collection: { destroy: jest.fn().mockResolvedValue(undefined) } }],
     ['de', { collection: { destroy: jest.fn().mockResolvedValue(undefined) } }],
   ]);

   // Cleanup logic
-  for (const [locale, instance] of instances.entries()) {
+  const entries = Array.from(instances.entries());
+  for (const [locale, instance] of entries) {
     if (instance.collection?.destroy) {
       await instance.collection.destroy();
     }
     instances.delete(locale);
   }

   expect(instances.size).toBe(0);
 });

---

213-218: The test correctly reflects the implementation, which does not trim trailing spaces.

The docToString implementation on line 105 of search.ts joins mapped fields with spaces without trimming the result. For missing fields that become empty strings, this produces trailing spaces—for example, ['Test Product', '', ''].join(' ') yields 'Test Product '. While the test expectation is accurate for the current behavior, consider whether trimming the final result would better serve search indexing (e.g., .join(' ').trim()) to avoid unnecessary whitespace in the search index.

packages/database/src/plugins/search.ts (2)

47-81: Consider collecting entries before iteration when deleting from Map.

The while loop modifies _localeLRU and _searchInstances during iteration. While the current implementation works because the while condition is re-evaluated each iteration, this pattern can be error-prone. Consider collecting items to evict first, then processing them.

♻️ Suggested safer pattern (optional)

 async function evictLRUIfNeeded(collection: RxCollection): Promise<void> {
   if (!collection._localeLRU || !collection._searchInstances) {
     return;
   }

+  const toEvict: string[] = [];
   while (
     collection._localeLRU.length > MAX_CACHED_LOCALES &&
     collection._searchInstances.size > MAX_CACHED_LOCALES
   ) {
     const oldestLocale = collection._localeLRU.shift();
-    if (oldestLocale && collection._searchInstances.has(oldestLocale)) {
+    if (oldestLocale) {
+      toEvict.push(oldestLocale);
+    }
+  }
+
+  for (const oldestLocale of toEvict) {
+    if (collection._searchInstances.has(oldestLocale)) {
       searchLogger.debug('Evicting LRU search instance', {
         context: { collection: collection.name, locale: oldestLocale },
       });
       // ... rest of eviction logic
     }
   }
 }

---

217-279: Complex error recovery flow with potential for infinite retry.

The recovery logic attempts to destroy the corrupted collection and retry once. However, if destroySearchCollection returns true but createSearchInstance throws again, the original error is re-thrown (line 277). This is correct behavior.

One edge case: if the destroy succeeds but the retry fails, the caller receives the original error message, not the retry error. Consider whether the retry error would be more useful for debugging.

packages/database/src/types.d.ts (1)

49-62: Consider using a private symbol or WeakMap for internal state.

Exposing internal properties like _searchInstances, _searchPromises, etc. on the public RxCollection interface (even with _ prefix) makes them accessible to all consumers. While documenting them as "Internal" is good, TypeScript doesn't enforce this boundary.

For stricter encapsulation, you could use a WeakMap keyed by collection instance to store internal state, though the current approach is pragmatic and common in plugin architectures.

packages/query/src/relational-query-state.ts (1)

64-71: Replace Query<any> with generics for child/parent queries.
Using any weakens type safety; consider adding a child-collection generic to RelationalQuery.

♻️ Suggested typing update

-export class RelationalQuery<T extends RxCollection> extends Query<T> {
+export class RelationalQuery<
+  TParent extends RxCollection,
+  TChild extends RxCollection
+> extends Query<TParent> {
-  private readonly childQuery: Query<any>;
-  private readonly parentLookupQuery: Query<T>;
+  private readonly childQuery: Query<TChild>;
+  private readonly parentLookupQuery: Query<TParent>;
 
-  constructor(config: QueryConfig<T>, childQuery: Query<any>, parentLookupQuery: Query<T>) {
+  constructor(
+    config: QueryConfig<TParent>,
+    childQuery: Query<TChild>,
+    parentLookupQuery: Query<TParent>
+  ) {
     super(config);
     this.childQuery = childQuery;
     this.parentLookupQuery = parentLookupQuery;
   }

As per coding guidelines, avoid 'any' types.

packages/query/src/collection-swap.ts (1)

14-25: Avoid any in CollectionSwapConfig manager type.
Prefer propagating the database generic to keep type safety.

♻️ Suggested typing update

-export interface CollectionSwapConfig {
-  manager: Manager<any>;
-  storeDB: RxDatabase;
-  fastStoreDB: RxDatabase;
-}
+export interface CollectionSwapConfig<TDatabase extends RxDatabase = RxDatabase> {
+  manager: Manager<TDatabase>;
+  storeDB: TDatabase;
+  fastStoreDB: TDatabase;
+}

-async function cancelCollectionOperations(
-  manager: Manager<any>,
+async function cancelCollectionOperations(
+  manager: Manager<RxDatabase>,

As per coding guidelines, avoid 'any' types.