packages/database/src/plugins/populate.ts (1)

196-202: Consider adding a typed interface for the extended document.

The as any cast is functional but violates the coding guideline to avoid any. While RxDB plugin patterns often require dynamic property access, you could improve type safety with an interface.

♻️ Suggested type-safe approach

+// At the top of the file or in a types file
+interface PopulatedRxDocument extends RxDocument {
+	[key: `${string}Resource`]: ObservableResource<RxDocument[]>;
+	populate$: (key: string) => Observable<RxDocument[]>;
+}
+
 /** */
 proto.populateResource = function (this: RxDocument, key: string) {
-	const self = this as any;
+	const self = this as PopulatedRxDocument;
 	if (!self[key + 'Resource']) {
-		self[key + 'Resource'] = new ObservableResource(self.populate$(key));
+		(self as any)[key + 'Resource'] = new ObservableResource(self.populate$(key));
 	}
 	return self[key + 'Resource'];
 };

Note: The assignment still requires as any due to TypeScript's limitations with template literal index signatures during assignment, but reading is type-safe.

packages/database/src/tests/helpers/nested-collection.ts (2)

42-47: Inconsistent database naming strategy with products-collection.ts.

This file uses Date.now() for unique names while products-collection.ts uses randomToken(10). For consistency and to avoid potential collisions in parallel test runs on the same millisecond, consider using the same approach.

♻️ Align with products-collection.ts approach

-/**
- * Generate a unique database name
- */
-function generateUniqueDbName(baseName: string): string {
-	return `${baseName}_${Date.now()}`;
-}
-
 export async function create(
 	size: number = 20,
 	collectionName: string = 'nested',
 	storage: RxStorage<any, object, object> = getRxStorageMemory()
 ): Promise<RxCollection<any, object, object>> {
 	const db = await createRxDatabase({
-		name: generateUniqueDbName('nesteddb'),
+		name: randomToken(10),
 		storage,
 		allowSlowCount: true,
 	});

Also applies to: 55-55

---

53-53: Return type uses any, losing type safety.

The return type RxCollection<any, object, object> is less strict than products-collection.ts which uses RxCollection<typeof productDefaultSchema, object, object>. Per coding guidelines, avoid any types.

♻️ Use schema type for better type safety

 export async function create(
 	size: number = 20,
 	collectionName: string = 'nested',
 	storage: RxStorage<any, any> = getRxStorageMemory()
-): Promise<RxCollection<any, object, object>> {
+): Promise<RxCollection<typeof nestedDefaultSchema, object, object>> {

packages/database/src/plugins/populate.test.ts (2)

7-18: Type definitions use any and are incomplete.

The NestedDoc interface is missing properties from the schema (uuid, name) and uses any in multiple places, which violates coding guidelines. A more complete interface would reduce the need for as unknown as casts throughout the tests.

♻️ Improve type definitions

 // Type for collection with plugin methods
 type NestedCollection = Awaited<ReturnType<typeof create>> & {
-	upsertRefs: (data: any) => Promise<void>;
-	removeRefs: (data: any) => Promise<void>;
+	upsertRefs: (data: NestedData) => Promise<void>;
+	removeRefs: (data: NestedData) => Promise<void>;
 };

+// Base nested data shape
+interface NestedData {
+	uuid: string;
+	name: string;
+	child?: (NestedData | string)[];
+}
+
 // Type for document with plugin methods
-interface NestedDoc {
-	child: string[];
-	populate: (key: string) => Promise<NestedDoc[]>;
-	toPopulatedJSON: () => Promise<any>;
-}
+interface NestedDoc extends NestedData {
+	child: string[];
+	populate: (key: string) => Promise<NestedDoc[]>;
+	toPopulatedJSON: () => Promise<NestedData>;
+}

---

40-40: Multiple as unknown as casts indicate type definition gaps.

The repeated use of as unknown as NestedDoc is a code smell suggesting the types don't align well with RxDB's actual return types. Consider extending RxDB's document type properly or creating a utility type.

♻️ Create a typed query helper

// Helper to reduce casting boilerplate
async function findNestedDoc(
	collection: NestedCollection,
	id?: string
): Promise<NestedDoc | null> {
	const query = id ? collection.findOne(id) : collection.findOne();
	return query.exec() as Promise<NestedDoc | null>;
}

Also applies to: 51-51, 66-66, 81-81

packages/core/src/screens/main/pos/hooks/use-update-line-item.test.ts (1)

76-95: Consider documenting the mock tax calculation.

The mock uses a hardcoded 10% tax rate. A brief comment explaining this is intentional for predictable test assertions would help future maintainers.

Optional: Add clarifying comment

 // Mock useCalculateLineItemTaxAndTotals
 jest.mock('./use-calculate-line-item-tax-and-totals', () => ({
 	useCalculateLineItemTaxAndTotals: () => ({
+		// Mock uses fixed 10% tax rate for predictable test assertions
 		calculateLineItemTaxesAndTotals: jest.fn().mockImplementation((lineItem) => {
 			const quantity = lineItem.quantity ?? 1;
 			const price = lineItem.price ?? 10;