@inlang/sdk 0.34.2 → 0.34.4

package/dist/persistence/filelock/acquireFileLock.js

@@ -0,0 +1,109 @@
+import {} from "@lix-js/fs";
+import _debug from "debug";
+const debug = _debug("sdk:acquireFileLock");
+const maxRetries = 10;
+const nProbes = 50;
+const probeInterval = 100;
+export async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
+    if (tryCount > maxRetries) {
+        throw new Error(lockOrigin + " exceeded maximum Retries (5) to acquire lockfile " + tryCount);
+    }
+    try {
+        debug(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount);
+        await fs.mkdir(lockDirPath);
+        const stats = await fs.stat(lockDirPath);
+        debug(lockOrigin + " acquired a lockfile Retry Nr.: " + tryCount);
+        return stats.mtimeMs;
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            // we only expect the error that the file exists already (locked by other process)
+            throw error;
+        }
+    }
+    let currentLockTime;
+    try {
+        const stats = await fs.stat(lockDirPath);
+        currentLockTime = stats.mtimeMs;
+    }
+    catch (fstatError) {
+        if (fstatError.code === "ENOENT") {
+            // lock file seems to be gone :) - lets try again
+            debug(lockOrigin + " tryCount++ lock file seems to be gone :) - lets try again " + tryCount);
+            return acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
+        }
+        throw fstatError;
+    }
+    debug(lockOrigin +
+        " tries to acquire a lockfile  - lock currently in use... starting probe phase " +
+        tryCount);
+    return new Promise((resolve, reject) => {
+        let probeCounts = 0;
+        const scheduleProbationTimeout = () => {
+            setTimeout(async () => {
+                probeCounts += 1;
+                let lockFileStats = undefined;
+                try {
+                    debug(lockOrigin + " tries to acquire a lockfile - check if the lock is free now " + tryCount);
+                    // alright lets give it another try
+                    lockFileStats = await fs.stat(lockDirPath);
+                }
+                catch (fstatError) {
+                    if (fstatError.code === "ENOENT") {
+                        debug(lockOrigin +
+                            " tryCount++ in Promise - tries to acquire a lockfile - lock file seems to be free now - try to acquire " +
+                            tryCount);
+                        const lock = acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
+                        return resolve(lock);
+                    }
+                    return reject(fstatError);
+                }
+                // still the same locker! -
+                if (lockFileStats.mtimeMs === currentLockTime) {
+                    if (probeCounts >= nProbes) {
+                        // ok maximum lock time ran up (we waitetd nProbes * probeInterval) - we consider the lock to be stale
+                        debug(lockOrigin +
+                            " tries to acquire a lockfile  - lock not free - but stale lets drop it" +
+                            tryCount);
+                        try {
+                            await fs.rmdir(lockDirPath);
+                        }
+                        catch (rmLockError) {
+                            if (rmLockError.code === "ENOENT") {
+                                // lock already gone?
+                                // Option 1: The "stale process" decided to get rid of it
+                                // Option 2: Another process acquiring the lock and detected a stale one as well
+                            }
+                            return reject(rmLockError);
+                        }
+                        try {
+                            debug(lockOrigin +
+                                " tryCount++ same locker - try to acquire again after removing stale lock " +
+                                tryCount);
+                            const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
+                            return resolve(lock);
+                        }
+                        catch (lockAquireException) {
+                            return reject(lockAquireException);
+                        }
+                    }
+                    else {
+                        // lets schedule a new probation
+                        return scheduleProbationTimeout();
+                    }
+                }
+                else {
+                    try {
+                        debug(lockOrigin + " tryCount++ different locker - try to acquire again " + tryCount);
+                        const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
+                        return resolve(lock);
+                    }
+                    catch (error) {
+                        return reject(error);
+                    }
+                }
+            }, probeInterval);
+        };
+        scheduleProbationTimeout();
+    });
+}

package/dist/persistence/filelock/releaseLock.d.ts

@@ -0,0 +1,3 @@
+import { type NodeishFilesystem } from "@lix-js/fs";
+export declare function releaseLock(fs: NodeishFilesystem, lockDirPath: string, lockOrigin: string, lockTime: number): Promise<void>;
+//# sourceMappingURL=releaseLock.d.ts.map

package/dist/persistence/filelock/releaseLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"releaseLock.d.ts","sourceRoot":"","sources":["../../../src/persistence/filelock/releaseLock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAInD,wBAAsB,WAAW,CAChC,EAAE,EAAE,iBAAiB,EACrB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,iBAmBhB"}

package/dist/persistence/filelock/releaseLock.js

@@ -0,0 +1,23 @@
+import {} from "@lix-js/fs";
+import _debug from "debug";
+const debug = _debug("sdk:releaseLock");
+export async function releaseLock(fs, lockDirPath, lockOrigin, lockTime) {
+    debug(lockOrigin + " releasing the lock ");
+    try {
+        const stats = await fs.stat(lockDirPath);
+        if (stats.mtimeMs === lockTime) {
+            // this can be corrupt as welll since the last getStat and the current a modification could have occured :-/
+            await fs.rmdir(lockDirPath);
+        }
+    }
+    catch (statError) {
+        debug(lockOrigin + " couldn't release the lock");
+        if (statError.code === "ENOENT") {
+            // ok seeks like the log was released by someone else
+            debug(lockOrigin + " WARNING - the lock was released by a different process");
+            return;
+        }
+        debug(statError);
+        throw statError;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.34.2",
+  "version": "0.34.4",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -33,16 +33,16 @@
     "solid-js": "1.6.12",
     "throttle-debounce": "^5.0.0",
     "@inlang/language-tag": "1.5.1",
+    "@inlang/json-types": "1.1.0",
+    "@inlang/message-lint-rule": "1.4.7",
+    "@inlang/project-settings": "2.4.2",
+    "@inlang/plugin": "2.4.11",
     "@inlang/message": "2.1.0",
-    "@inlang/message-lint-rule": "1.4.6",
-    "@inlang/module": "1.2.10",
-    "@inlang/plugin": "2.4.10",
     "@inlang/result": "1.1.0",
-    "@inlang/project-settings": "2.4.1",
+    "@inlang/module": "1.2.11",
     "@inlang/translatable": "1.3.1",
-    "@inlang/json-types": "1.1.0",
-    "@lix-js/fs": "1.0.0",
-    "@lix-js/client": "1.4.0"
+    "@lix-js/client": "1.4.0",
+    "@lix-js/fs": "1.0.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",

package/src/adapter/solidAdapter.test.ts

@@ -232,7 +232,7 @@ describe("messages", () => {
 		// TODO: how can we await `setConfig` correctly
 		await new Promise((resolve) => setTimeout(resolve, 510))
 
-		expect(effectOnMessagesCounter).toBe(1) // 2 times because effect creation + set
+		expect(effectOnMessagesCounter).toBe(7) // 7 = initial effect, setSetting, loadMessage (2x - one per message), setResolvedPlugins, loadMessages (2x - one per message)
 		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
 	})
 

package/src/createMessagesQuery.test.ts

@@ -2,15 +2,72 @@
 import { describe, it, expect } from "vitest"
 import { createMessagesQuery } from "./createMessagesQuery.js"
 import { createEffect, createRoot, createSignal } from "./reactivity/solid.js"
-import type { Message, Text } from "@inlang/message"
+import { Message, type Text } from "@inlang/message"
 import { createMessage } from "./test-utilities/createMessage.js"
+import { createNodeishMemoryFs } from "@lix-js/fs"
+import type { resolveModules } from "./resolve-modules/resolveModules.js"
+import type { ProjectSettings } from "./versionedInterfaces.js"
+import type { InlangProject } from "./api.js"
 
 const createChangeListener = async (cb: () => void) => createEffect(cb)
 const nextTick = () => new Promise((resolve) => setTimeout(resolve, 0))
 
-describe("create", () => {
-	it("should create a message", () => {
-		const query = createMessagesQuery(() => [])
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const awaitableCreateMessageQuery = async (_messages: () => Message[]) => {
+	const fs = createNodeishMemoryFs()
+	const settings: ProjectSettings = {
+		sourceLanguageTag: "en",
+		languageTags: ["en"],
+		modules: ["plugin.js", "lintRule.js"],
+		messageLintRuleLevels: {
+			"messageLintRule.project.missingTranslation": "error",
+		},
+		"plugin.project.i18next": {
+			pathPattern: "./examples/example01/{languageTag}.json",
+			variableReferencePattern: ["{", "}"],
+		},
+	}
+
+	let messages: any = _messages()
+
+	const resolvedModules: Awaited<ReturnType<typeof resolveModules>> = {
+		meta: [],
+		plugins: [],
+		messageLintRules: [],
+		resolvedPluginApi: {
+			loadMessages: (() => {
+				return messages
+			}) as any,
+			saveMessages: ((newMessages: any) => {
+				messages = newMessages
+			}) as any,
+			customApi: {},
+		},
+		errors: [],
+	}
+
+	return new Promise<InlangProject["query"]["messages"]>((res, rej) => {
+		const query = createMessagesQuery({
+			projectPath: "",
+			nodeishFs: fs,
+			settings: () => settings,
+			resolvedModules: () => resolvedModules,
+			onInitialMessageLoadResult: (error) => {
+				if (error) {
+					rej(error)
+				} else {
+					res(query)
+				}
+			},
+			onLoadMessageResult: () => {},
+			onSaveMessageResult: () => {},
+		})
+	})
+}
+
+describe("create", async () => {
+	it("should create a message", async () => {
+		const query = await awaitableCreateMessageQuery(() => [])
 		expect(query.get({ where: { id: "first-message" } })).toBeUndefined()
 
 		const mockMessage = createMessage("first-message", { en: "Hello World" })
@@ -20,8 +77,8 @@ describe("create", () => {
 		expect(created).toBe(true)
 	})
 
-	it("query.getByDefaultAlias should return a message with a default alias", () => {
-		const query = createMessagesQuery(() => [])
+	it("query.getByDefaultAlias should return a message with a default alias", async () => {
+		const query = await awaitableCreateMessageQuery(() => [])
 		expect(query.get({ where: { id: "first-message" } })).toBeUndefined()
 
 		const mockMessage = createMessage("first-message", { en: "Hello World" })
@@ -33,8 +90,10 @@ describe("create", () => {
 		expect(created).toBe(true)
 	})
 
-	it("should return false if message with id already exists", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+	it("should return false if message with id already exists", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
 		expect(query.get({ where: { id: "first-message" } })).toBeDefined()
 
 		const mockMessage = createMessage("first-message", { en: "Some Text" })
@@ -45,23 +104,35 @@ describe("create", () => {
 	})
 })
 
-describe("get", () => {
-	it("should return undefined if a message does not exist", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+describe("get", async () => {
+	it("should return undefined if a message does not exist", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
+
 		const message = query.get({ where: { id: "none-existent-message" } })
 		expect(message).toBeUndefined()
 	})
 
-	it("should return an object, not an array", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+	it("should return an object, not an array", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
+		expect(query.get({ where: { id: "first-message" } })).toBeDefined()
+
+		const mockMessageInit = createMessage("first-message", { en: "Hello World" })
+		query.create({ data: mockMessageInit })
+
 		const message = query.get({ where: { id: "first-message" } })
 		expect(message).toBeDefined()
 		expect(Array.isArray(message)).toBe(false)
 	})
 
 	// todo: improve the readonly type
-	it.skip("mutating the returned value should not affect subsequent return values", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+	it.skip("mutating the returned value should not affect subsequent return values", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
 		const message1 = query.get({ where: { id: "first-message" } })!
 		;(message1.variants.find((v) => v.languageTag === "en")!.pattern![0]! as Text).value =
 			"Hello World 2"
@@ -76,16 +147,16 @@ describe("get", () => {
 	})
 })
 
-describe("getAll", () => {
-	it("should return an empty array if no messages exist", () => {
-		const query = createMessagesQuery(() => [])
+describe("getAll", async () => {
+	it("should return an empty array if no messages exist", async () => {
+		const query = await awaitableCreateMessageQuery(() => [])
 		const messages = query.getAll()
 
 		expect(Object.values(messages!)).toEqual([])
 	})
 
-	it("should return all message objects", () => {
-		const query = createMessagesQuery(() => [])
+	it("should return all message objects", async () => {
+		const query = await awaitableCreateMessageQuery(() => [])
 		const mockMessage1 = createMessage("first-message", { en: "Hello World" })
 		const mockMessage2 = createMessage("second-message", { en: "Hello World 2" })
 		query.create({ data: mockMessage1 })
@@ -96,8 +167,11 @@ describe("getAll", () => {
 	})
 
 	// todo: improve the readonly type
-	it.skip("mutating the returned value should not affect subsequent return values", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+	it.skip("mutating the returned value should not affect subsequent return values", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
+
 		const messages1 = query.getAll()
 		;(
 			Object.values(messages1!)[0]!.variants.find((v) => v.languageTag === "en")!
@@ -113,9 +187,12 @@ describe("getAll", () => {
 	})
 })
 
-describe("update", () => {
-	it("should update a message", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+describe("update", async () => {
+	it("should update a message", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
+
 		expect(query.get({ where: { id: "first-message" } })).toBeDefined()
 
 		const mockMessage = createMessage("first-message", { en: "Hello World 2" })
@@ -125,8 +202,8 @@ describe("update", () => {
 		expect(updated).toBe(true)
 	})
 
-	it("should return false if message with id does not exist exists", () => {
-		const query = createMessagesQuery(() => [])
+	it("should return false if message with id does not exist exists", async () => {
+		const query = await awaitableCreateMessageQuery(() => [])
 		expect(query.get({ where: { id: "first-message" } })).toBeUndefined()
 
 		const mockMessage = createMessage("first-message", { en: "Hello World" })
@@ -135,9 +212,9 @@ describe("update", () => {
 	})
 })
 
-describe("upsert", () => {
-	it("should create a message if not present yet", () => {
-		const query = createMessagesQuery(() => [])
+describe("upsert", async () => {
+	it("should create a message if not present yet", async () => {
+		const query = await awaitableCreateMessageQuery(() => [])
 		expect(query.get({ where: { id: "first-message" } })).toBeUndefined()
 
 		const mockMessage = createMessage("first-message", { en: "Hello World" })
@@ -147,8 +224,15 @@ describe("upsert", () => {
 		expect(upserted).toBe(true)
 	})
 
-	it("should update message if id already exists", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+	it("should update message if id already exists", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
+		expect(query.get({ where: { id: "first-message" } })).toBeDefined()
+
+		const mockMessageInit = createMessage("first-message", { en: "Hello World" })
+		query.create({ data: mockMessageInit })
+
 		expect(query.get({ where: { id: "first-message" } })).toBeDefined()
 
 		const mockMessage = createMessage("first-message", { en: "Hello World 2" })
@@ -159,9 +243,12 @@ describe("upsert", () => {
 	})
 })
 
-describe("delete", () => {
-	it("should delete a message", () => {
-		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
+describe("delete", async () => {
+	it("should delete a message", async () => {
+		const query = await awaitableCreateMessageQuery(() => [
+			createMessage("first-message", { en: "Hello World" }),
+		])
+
 		expect(query.get({ where: { id: "first-message" } })).toBeDefined()
 
 		const deleted = query.delete({ where: { id: "first-message" } })
@@ -170,8 +257,8 @@ describe("delete", () => {
 		expect(deleted).toBe(true)
 	})
 
-	it("should return false if message with id does not exist", () => {
-		const query = createMessagesQuery(() => [])
+	it("should return false if message with id does not exist", async () => {
+		const query = await awaitableCreateMessageQuery(() => [])
 		expect(query.get({ where: { id: "first-message" } })).toBeUndefined()
 
 		const deleted = query.delete({ where: { id: "first-message" } })
@@ -179,11 +266,11 @@ describe("delete", () => {
 	})
 })
 
-describe("reactivity", () => {
-	describe("get", () => {
+describe("reactivity", async () => {
+	describe("get", async () => {
 		it("should react to `create`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [])
+				const query = await awaitableCreateMessageQuery(() => [])
 
 				// eslint-disable-next-line unicorn/no-null
 				let message: Message | undefined | null = null
@@ -201,7 +288,9 @@ describe("reactivity", () => {
 
 		it("should react to `update`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [createMessage("1", { en: "before" })])
+				const query = await awaitableCreateMessageQuery(() => [
+					createMessage("1", { en: "before" }),
+				])
 
 				let message: Message | undefined
 				await createChangeListener(() => (message = query.get({ where: { id: "1" } })))
@@ -221,7 +310,7 @@ describe("reactivity", () => {
 
 		it("should react to `upsert`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [])
+				const query = await awaitableCreateMessageQuery(() => [])
 
 				let message: Message | undefined
 				await createChangeListener(() => (message = query.get({ where: { id: "1" } })))
@@ -244,7 +333,7 @@ describe("reactivity", () => {
 
 		it("should react to `delete`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [createMessage("1", { en: "" })])
+				const query = await awaitableCreateMessageQuery(() => [createMessage("1", { en: "" })])
 
 				let message: Message | undefined
 				await createChangeListener(() => (message = query.get({ where: { id: "1" } })))
@@ -254,37 +343,13 @@ describe("reactivity", () => {
 				expect(message).toBeUndefined()
 			})
 		})
-
-		it("should react to changes to the input `messages`", async () => {
-			const [messages, setMessages] = createSignal<Message[]>([])
-			const query = createMessagesQuery(messages)
-
-			// eslint-disable-next-line unicorn/no-null
-			let message: Message | undefined | null = null
-			await createChangeListener(() => (message = query.get({ where: { id: "1" } })))
-			expect(message).toBeUndefined()
-
-			query.create({ data: createMessage("1", { en: "before" }) })
-			expect(message).toBeDefined()
-			expect(
-				(message!.variants.find((variant) => variant.languageTag === "en")?.pattern[0] as Text)
-					.value
-			).toBe("before")
-
-			setMessages([createMessage("1", { en: "after" })])
-			expect(message).toBeDefined()
-			expect(
-				(message!.variants.find((variant) => variant.languageTag === "en")?.pattern[0] as Text)
-					.value
-			).toBe("after")
-		})
 	})
 
-	describe("subscribe", () => {
-		describe("get", () => {
+	describe("subscribe", async () => {
+		describe("get", async () => {
 			it("should subscribe to `create`", async () => {
 				await createRoot(async () => {
-					const query = createMessagesQuery(() => [])
+					const query = await awaitableCreateMessageQuery(() => [])
 
 					// eslint-disable-next-line unicorn/no-null
 					let message: Message | undefined | null = null
@@ -299,10 +364,10 @@ describe("reactivity", () => {
 				})
 			})
 		})
-		describe("getByDefaultAlias", () => {
+		describe("getByDefaultAlias", async () => {
 			it("should subscribe to `create`", async () => {
 				await createRoot(async () => {
-					const query = createMessagesQuery(() => [])
+					const query = await awaitableCreateMessageQuery(() => [])
 
 					// eslint-disable-next-line unicorn/no-null
 					let message: Message | undefined | null = null
@@ -322,10 +387,10 @@ describe("reactivity", () => {
 		})
 	})
 
-	describe("getAll", () => {
+	describe("getAll", async () => {
 		it("should react to `create`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [])
+				const query = await awaitableCreateMessageQuery(() => [])
 
 				let messages: Readonly<Message[]> | undefined = undefined
 				await createChangeListener(() => (messages = query.getAll()))
@@ -344,7 +409,9 @@ describe("reactivity", () => {
 
 		it("should react to `update`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [createMessage("1", { en: "before" })])
+				const query = await awaitableCreateMessageQuery(() => [
+					createMessage("1", { en: "before" }),
+				])
 
 				let messages: Readonly<Message[]> | undefined = undefined
 				await createChangeListener(() => (messages = query.getAll()))
@@ -369,7 +436,7 @@ describe("reactivity", () => {
 
 		it("should react to `upsert`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [])
+				const query = await awaitableCreateMessageQuery(() => [])
 
 				let messages: Readonly<Message[]> | undefined = undefined
 				await createChangeListener(() => (messages = query.getAll()))
@@ -396,7 +463,7 @@ describe("reactivity", () => {
 
 		it("should react to `delete`", async () => {
 			await createRoot(async () => {
-				const query = createMessagesQuery(() => [
+				const query = await awaitableCreateMessageQuery(() => [
 					createMessage("1", { en: "" }),
 					createMessage("2", { en: "" }),
 					createMessage("3", { en: "" }),
@@ -421,38 +488,9 @@ describe("reactivity", () => {
 			})
 		})
 
-		it("should react to changes to the input `messages`", async () => {
-			const [inputMessages, setMessages] = createSignal<Message[]>([
-				createMessage("1", { en: "before" }),
-			])
-			const query = createMessagesQuery(inputMessages)
-
-			let messages: Readonly<Message[]> | undefined = undefined
-			await createChangeListener(() => (messages = query.getAll()))
-			expect(Object.values(messages!)).toHaveLength(1)
-
-			query.create({ data: createMessage("2", { en: "" }) })
-			expect(Object.values(messages!)).toHaveLength(2)
-			expect(
-				(
-					Object.values(messages!)![0]!.variants.find((variant) => variant.languageTag === "en")!
-						.pattern[0]! as Text
-				).value
-			).toBe("before")
-
-			setMessages([createMessage("1", { en: "after" })])
-			expect(Object.values(messages!)).toHaveLength(1)
-			expect(
-				(
-					Object.values(messages!)![0]!.variants.find((variant) => variant.languageTag === "en")!
-						.pattern[0]! as Text
-				).value
-			).toBe("after")
-		})
-
 		it("should not mutate messages signal outside the query when using the query", async () => {
 			const [inputMessages] = createSignal<Message[]>([createMessage("1", { en: "before" })])
-			const query = createMessagesQuery(inputMessages)
+			const query = await awaitableCreateMessageQuery(inputMessages)
 
 			let messages: Readonly<Message[]> | undefined = undefined
 			await createChangeListener(() => (messages = query.getAll()))
@@ -467,8 +505,8 @@ describe("reactivity", () => {
 
 it("instances should not share state", async () => {
 	await createRoot(async () => {
-		const query1 = createMessagesQuery(() => [createMessage("1", { en: "before" })])
-		const query2 = createMessagesQuery(() => [])
+		const query1 = await awaitableCreateMessageQuery(() => [createMessage("1", { en: "before" })])
+		const query2 = await awaitableCreateMessageQuery(() => [])
 
 		// eslint-disable-next-line unicorn/no-null
 		let message1: Message | undefined | null = null