@inlang/sdk 0.34.3 → 0.34.4

package/dist/createMessagesQuery.test.js

@@ -2,20 +2,72 @@
 import { describe, it, expect } from "vitest";
 import { createMessagesQuery } from "./createMessagesQuery.js";
 import { createEffect, createRoot, createSignal } from "./reactivity/solid.js";
+import { Message } from "@inlang/message";
 import { createMessage } from "./test-utilities/createMessage.js";
+import { createNodeishMemoryFs } from "@lix-js/fs";
 const createChangeListener = async (cb) => 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) => {
+    const fs = createNodeishMemoryFs();
+    const settings = {
+        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 = _messages();
+    const resolvedModules = {
+        meta: [],
+        plugins: [],
+        messageLintRules: [],
+        resolvedPluginApi: {
+            loadMessages: (() => {
+                return messages;
+            }),
+            saveMessages: ((newMessages) => {
+                messages = newMessages;
+            }),
+            customApi: {},
+        },
+        errors: [],
+    };
+    return new Promise((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" });
         const created = query.create({ data: mockMessage });
         expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
         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" });
         mockMessage.alias = { default: "first-message-alias" };
@@ -24,8 +76,10 @@ describe("create", () => {
         expect(query.getByDefaultAlias("first-message-alias")).toEqual(mockMessage);
         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" });
         query.create({ data: mockMessage });
@@ -33,21 +87,30 @@ describe("create", () => {
         expect(created).toBe(false);
     });
 });
-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].value =
             "Hello World 2";
@@ -56,14 +119,14 @@ describe("get", () => {
         expect(message2.variants.find((v) => v.languageTag === "en").pattern[0].value).toBe("Hello World");
     });
 });
-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 });
@@ -72,8 +135,10 @@ describe("getAll", () => {
         expect(Object.values(messages)).toEqual([mockMessage1, mockMessage2]);
     });
     // 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")
             .pattern[0].value = "Hello World 2";
@@ -81,34 +146,41 @@ describe("getAll", () => {
             .pattern[0].value).toBe("Hello World");
     });
 });
-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" });
         const updated = query.update({ where: { id: "first-message" }, data: mockMessage });
         expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
         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" });
         const updated = query.update({ where: { id: "first-message" }, data: mockMessage });
         expect(updated).toBe(false);
     });
 });
-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" });
         const upserted = query.upsert({ where: { id: "first-message" }, data: mockMessage });
         expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage);
         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" });
         const upserted = query.upsert({ where: { id: "first-message" }, data: mockMessage });
@@ -116,26 +188,28 @@ describe("upsert", () => {
         expect(upserted).toBe(true);
     });
 });
-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" } });
         expect(query.get({ where: { id: "first-message" } })).toBeUndefined();
         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" } });
         expect(deleted).toBe(false);
     });
 });
-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 = null;
                 await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
@@ -149,7 +223,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;
                 await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
                 expect(message).toBeDefined();
@@ -162,7 +238,7 @@ describe("reactivity", () => {
         });
         it("should react to `upsert`", async () => {
             await createRoot(async () => {
-                const query = createMessagesQuery(() => []);
+                const query = await awaitableCreateMessageQuery(() => []);
                 let message;
                 await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
                 expect(message).toBeUndefined();
@@ -177,7 +253,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;
                 await createChangeListener(() => (message = query.get({ where: { id: "1" } })));
                 expect(message).toBeDefined();
@@ -185,28 +261,12 @@ describe("reactivity", () => {
                 expect(message).toBeUndefined();
             });
         });
-        it("should react to changes to the input `messages`", async () => {
-            const [messages, setMessages] = createSignal([]);
-            const query = createMessagesQuery(messages);
-            // eslint-disable-next-line unicorn/no-null
-            let message = 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])
-                .value).toBe("before");
-            setMessages([createMessage("1", { en: "after" })]);
-            expect(message).toBeDefined();
-            expect((message.variants.find((variant) => variant.languageTag === "en")?.pattern[0])
-                .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 = null;
                     query.get.subscribe({ where: { id: "1" } }, (v) => {
@@ -219,10 +279,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 = null;
                     query.getByDefaultAlias.subscribe("message-alias", (v) => {
@@ -238,10 +298,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 = undefined;
                 await createChangeListener(() => (messages = query.getAll()));
                 expect(Object.values(messages)).toHaveLength(0);
@@ -255,7 +315,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 = undefined;
                 await createChangeListener(() => (messages = query.getAll()));
                 expect(Object.values(messages)).toHaveLength(1);
@@ -269,7 +331,7 @@ describe("reactivity", () => {
         });
         it("should react to `upsert`", async () => {
             await createRoot(async () => {
-                const query = createMessagesQuery(() => []);
+                const query = await awaitableCreateMessageQuery(() => []);
                 let messages = undefined;
                 await createChangeListener(() => (messages = query.getAll()));
                 expect(Object.values(messages)).toHaveLength(0);
@@ -284,7 +346,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: "" }),
@@ -303,26 +365,9 @@ describe("reactivity", () => {
                 expect(Object.values(messages)).toHaveLength(0);
             });
         });
-        it("should react to changes to the input `messages`", async () => {
-            const [inputMessages, setMessages] = createSignal([
-                createMessage("1", { en: "before" }),
-            ]);
-            const query = createMessagesQuery(inputMessages);
-            let messages = 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].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].value).toBe("after");
-        });
         it("should not mutate messages signal outside the query when using the query", async () => {
             const [inputMessages] = createSignal([createMessage("1", { en: "before" })]);
-            const query = createMessagesQuery(inputMessages);
+            const query = await awaitableCreateMessageQuery(inputMessages);
             let messages = undefined;
             await createChangeListener(() => (messages = query.getAll()));
             expect(Object.values(messages)).toHaveLength(1);
@@ -333,8 +378,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 = null;
         await createChangeListener(() => (message1 = query1.get({ where: { id: "1" } })));

package/dist/createNodeishFsWithWatcher.d.ts

@@ -8,5 +8,6 @@ import type { NodeishFilesystem } from "@lix-js/fs";
 export declare const createNodeishFsWithWatcher: (args: {
     nodeishFs: NodeishFilesystem;
     updateMessages: () => void;
+    abortController: AbortController;
 }) => NodeishFilesystem;
 //# sourceMappingURL=createNodeishFsWithWatcher.d.ts.map

package/dist/createNodeishFsWithWatcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNodeishFsWithWatcher.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithWatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,SAAU;IAChD,SAAS,EAAE,iBAAiB,CAAA;IAC5B,cAAc,EAAE,MAAM,IAAI,CAAA;CAC1B,KAAG,iBAiDH,CAAA"}
+{"version":3,"file":"createNodeishFsWithWatcher.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithWatcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,SAAU;IAChD,SAAS,EAAE,iBAAiB,CAAA;IAC5B,cAAc,EAAE,MAAM,IAAI,CAAA;IAC1B,eAAe,EAAE,eAAe,CAAA;CAChC,KAAG,iBAgDH,CAAA"}

package/dist/createNodeishFsWithWatcher.js

@@ -7,11 +7,11 @@
 export const createNodeishFsWithWatcher = (args) => {
     const pathList = [];
     const makeWatcher = (path) => {
-        const abortController = new AbortController();
+        ;
         (async () => {
             try {
                 const watcher = args.nodeishFs.watch(path, {
-                    signal: abortController.signal,
+                    signal: args.abortController.signal,
                     persistent: false,
                 });
                 if (watcher) {

package/dist/createNodeishFsWithWatcher.test.js

@@ -4,11 +4,13 @@ import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js";
 describe("watcher", () => {
     it("should trigger the update function when file changes", async () => {
         let counter = 0;
+        const abortController = new AbortController();
         const fs = createNodeishFsWithWatcher({
             nodeishFs: createNodeishMemoryFs(),
             updateMessages: () => {
                 counter++;
             },
+            abortController,
         });
         // establish watcher
         await fs.writeFile("file.txt", "a");
@@ -28,5 +30,11 @@ describe("watcher", () => {
         await new Promise((resolve) => setTimeout(resolve, 0));
         //check if update function was called
         expect(counter).toBe(2);
+        abortController.abort();
+        // change file
+        await fs.writeFile("file.txt", "b");
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        //check if update function was called - should not since signalled
+        expect(counter).toBe(2);
     });
 });

package/dist/loadProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAwBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAmChD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAuXzB;AAsHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}
+{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAkBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAahD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAiOzB;AA+GD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}