@inlang/sdk 0.10.0 → 0.12.0

package/dist/adapter/solidAdapter.test.js

@@ -72,9 +72,10 @@ const $import = async (name) => ({
 describe("config", () => {
     it("should react to changes in config", async () => {
         const fs = createNodeishMemoryFs();
-        await fs.writeFile("./project.inlang.json", JSON.stringify(config));
+        await fs.mkdir("/user/project", { recursive: true });
+        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "./project.inlang.json",
+            settingsFilePath: "/user/project/project.inlang.json",
             nodeishFs: fs,
             _import: $import,
         }), { from });
@@ -95,9 +96,10 @@ describe("config", () => {
 describe("installed", () => {
     it("react to changes that are unrelated to installed items", async () => {
         const fs = createNodeishMemoryFs();
-        await fs.writeFile("./project.inlang.json", JSON.stringify(config));
+        await fs.mkdir("/user/project", { recursive: true });
+        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "./project.inlang.json",
+            settingsFilePath: "/user/project/project.inlang.json",
             nodeishFs: fs,
             _import: $import,
         }), { from });
@@ -147,9 +149,10 @@ describe("messages", () => {
             saveMessages: () => undefined,
         };
         const mockImport = async () => ({ default: mockPlugin });
-        await fs.writeFile("./project.inlang.json", JSON.stringify(mockConfig));
+        await fs.mkdir("/user/project", { recursive: true });
+        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(mockConfig));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "./project.inlang.json",
+            settingsFilePath: "/user/project/project.inlang.json",
             nodeishFs: fs,
             _import: mockImport,
         }), { from });
@@ -167,9 +170,10 @@ describe("messages", () => {
     });
     it("should react to changes in messages", async () => {
         const fs = createNodeishMemoryFs();
-        await fs.writeFile("./project.inlang.json", JSON.stringify(config));
+        await fs.mkdir("/user/project", { recursive: true });
+        await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config));
         const project = solidAdapter(await loadProject({
-            settingsFilePath: "./project.inlang.json",
+            settingsFilePath: "/user/project/project.inlang.json",
             nodeishFs: fs,
             _import: $import,
         }), { from });

package/dist/createNodeishFsWithAbsolutePaths.d.ts

@@ -0,0 +1,13 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin";
+export declare const isAbsolutePath: (path: string) => boolean;
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `settingsFilePath` argument.
+ */
+export declare const createNodeishFsWithAbsolutePaths: (args: {
+    settingsFilePath: string;
+    nodeishFs: NodeishFilesystemSubset;
+}) => NodeishFilesystemSubset;
+//# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D,eAAO,MAAM,cAAc,SAAU,MAAM,YAAwB,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,SAAU;IACtD,gBAAgB,EAAE,MAAM,CAAA;IACxB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAyBH,CAAA"}

package/dist/createNodeishFsWithAbsolutePaths.js

@@ -0,0 +1,29 @@
+import { normalizePath } from "@lix-js/fs";
+export const isAbsolutePath = (path) => /^[/\\]/.test(path);
+/**
+ * Wraps the nodeish filesystem subset with a function that intercepts paths
+ * and prepends the base path.
+ *
+ * The paths are resolved from the `settingsFilePath` argument.
+ */
+export const createNodeishFsWithAbsolutePaths = (args) => {
+    if (!isAbsolutePath(args.settingsFilePath)) {
+        throw new Error("The argument `settingsFilePath` must be an absolute path.");
+    }
+    // get the base path of the settings file by
+    // removing the file name from the path
+    const bathPath = args.settingsFilePath.split("/").slice(0, -1).join("/");
+    const makeAbsolute = (path) => {
+        if (isAbsolutePath(path)) {
+            return path;
+        }
+        return normalizePath(bathPath + "/" + path);
+    };
+    return {
+        // @ts-expect-error
+        readFile: (path, options) => args.nodeishFs.readFile(makeAbsolute(path), options),
+        readdir: (path) => args.nodeishFs.readdir(makeAbsolute(path)),
+        mkdir: (path) => args.nodeishFs.mkdir(makeAbsolute(path)),
+        writeFile: (path, data) => args.nodeishFs.writeFile(makeAbsolute(path), data),
+    };
+};

package/dist/createNodeishFsWithAbsolutePaths.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createNodeishFsWithAbsolutePaths.test.d.ts.map

package/dist/createNodeishFsWithAbsolutePaths.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNodeishFsWithAbsolutePaths.test.d.ts","sourceRoot":"","sources":["../src/createNodeishFsWithAbsolutePaths.test.ts"],"names":[],"mappings":""}

package/dist/createNodeishFsWithAbsolutePaths.test.js

@@ -0,0 +1,37 @@
+import { it, expect, vi } from "vitest";
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
+it("throws an error if settingsFilePath is not an absolute path", () => {
+    const relativePath = "relative/path";
+    expect(() => createNodeishFsWithAbsolutePaths({ settingsFilePath: relativePath, nodeishFs: {} })).toThrow();
+});
+it("intercepts paths correctly for readFile", async () => {
+    const settingsFilePath = `/Users/samuel/Documents/paraglide/example/project.inlang.json`;
+    const filePaths = [
+        ["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+        ["./file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
+        ["./folder/file.txt", `/Users/samuel/Documents/paraglide/example/folder/file.txt`],
+        ["../file.txt", `/Users/samuel/Documents/paraglide/file.txt`],
+        ["../folder/file.txt", `/Users/samuel/Documents/paraglide/folder/file.txt`],
+        ["../../file.txt", `/Users/samuel/Documents/file.txt`],
+        ["../../../file.txt", `/Users/samuel/file.txt`],
+    ];
+    const mockNodeishFs = {
+        readFile: vi.fn(),
+        readdir: vi.fn(),
+        mkdir: vi.fn(),
+        writeFile: vi.fn(),
+    };
+    const interceptedFs = createNodeishFsWithAbsolutePaths({
+        settingsFilePath,
+        nodeishFs: mockNodeishFs,
+    });
+    for (const [path, expectedPath] of filePaths) {
+        for (const fn of Object.keys(mockNodeishFs)) {
+            // @ts-expect-error
+            await interceptedFs[fn](path);
+            // @ts-expect-error
+            // expect the first argument to be the expectedPath
+            expect(mockNodeishFs[fn].mock.lastCall[0]).toBe(expectedPath);
+        }
+    }
+});

package/dist/errors.d.ts

@@ -1,4 +1,9 @@
 import type { ValueError } from "@sinclair/typebox/errors";
+export declare class LoadProjectInvalidArgument extends Error {
+    constructor(message: string, options: {
+        argument: string;
+    });
+}
 export declare class ProjectSettingsInvalidError extends Error {
     constructor(options: {
         errors: ValueError[];

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ7C;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBAChD,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAOnE;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAIpE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAE1D,qBAAa,0BAA2B,SAAQ,KAAK;gBACxC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE;CAI1D;AAED,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE;QAAE,MAAM,EAAE,UAAU,EAAE,CAAA;KAAE;CAQ7C;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBAChD,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAOnE;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE;CAIpE;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE;QAAE,KAAK,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;KAAE;CAIrD"}

package/dist/errors.js

@@ -1,3 +1,9 @@
+export class LoadProjectInvalidArgument extends Error {
+    constructor(message, options) {
+        super(`The argument "${options.argument}" of loadProject() is invalid: ${message}`);
+        this.name = "LoadProjectInvalidArgument";
+    }
+}
 export class ProjectSettingsInvalidError extends Error {
     constructor(options) {
         super(`The project settings are invalid:\n\n${options.errors

package/dist/loadProject.d.ts

@@ -4,8 +4,11 @@ import { type NodeishFilesystemSubset } from "./versionedInterfaces.js";
 /**
  * Creates an inlang instance.
  *
- * - Use `_import` to pass a custom import function for testing,
+ * @param settingsFilePath - Absolute path to the inlang settings file.
+ * @param nodeishFs - Filesystem that implements the NodeishFilesystemSubset interface.
+ * @param _import - Use `_import` to pass a custom import function for testing,
  *   and supporting legacy resolvedModules such as CJS.
+ * @param _capture - Use `_capture` to capture events for analytics.
  *
  */
 export declare const loadProject: (args: {

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;AAahF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAMjG;;;;;;GAMG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAqLxB,CAAA;AAqGD,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;AAchF,OAAO,EAA4B,KAAK,uBAAuB,EAAE,MAAM,0BAA0B,CAAA;AAUjG;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;sBACL,MAAM;eACb,uBAAuB;;qBAElB,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAkMxB,CAAA;AAqGD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -1,6 +1,6 @@
 import { resolveModules } from "./resolve-modules/index.js";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, LoadProjectInvalidArgument, } from "./errors.js";
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
 import { createMessagesQuery } from "./createMessagesQuery.js";
 import { debounce } from "throttle-debounce";
@@ -8,21 +8,34 @@ import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.j
 import { ProjectSettings, Message } from "./versionedInterfaces.js";
 import { tryCatch } from "@inlang/result";
 import { migrateIfOutdated } from "@inlang/project-settings/migration";
+import { createNodeishFsWithAbsolutePaths, isAbsolutePath, } from "./createNodeishFsWithAbsolutePaths.js";
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * Creates an inlang instance.
  *
- * - Use `_import` to pass a custom import function for testing,
+ * @param settingsFilePath - Absolute path to the inlang settings file.
+ * @param nodeishFs - Filesystem that implements the NodeishFilesystemSubset interface.
+ * @param _import - Use `_import` to pass a custom import function for testing,
  *   and supporting legacy resolvedModules such as CJS.
+ * @param _capture - Use `_capture` to capture events for analytics.
  *
  */
 export const loadProject = async (args) => {
+    // -- validation --------------------------------------------------------
+    //! the only place where throwing is acceptable because the project
+    //! won't even be loaded. do not throw anywhere else. otherwise, apps
+    //! can't handle errors gracefully.
+    if (!isAbsolutePath(args.settingsFilePath)) {
+        throw new LoadProjectInvalidArgument(`Expected an absolute path but received "${args.settingsFilePath}".`, { argument: "settingsFilePath" });
+    }
+    // -- load project ------------------------------------------------------
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
+        const nodeishFs = createNodeishFsWithAbsolutePaths(args);
         // -- settings ------------------------------------------------------------
         const [settings, _setSettings] = createSignal();
         createEffect(() => {
-            loadSettings({ settingsFilePath: args.settingsFilePath, nodeishFs: args.nodeishFs })
+            loadSettings({ settingsFilePath: args.settingsFilePath, nodeishFs })
                 .then((settings) => {
                 setSettings(settings);
                 // rename settings to get a convenient access to the data in Posthog
@@ -34,7 +47,7 @@ export const loadProject = async (args) => {
             });
         });
         // TODO: create FS watcher and update settings on change
-        const writeSettingsToDisk = skipFirst((settings) => _writeSettingsToDisk({ nodeishFs: args.nodeishFs, settings }));
+        const writeSettingsToDisk = skipFirst((settings) => _writeSettingsToDisk({ nodeishFs, settings }));
         const setSettings = (settings) => {
             try {
                 const validatedSettings = parseSettings(settings);
@@ -55,7 +68,7 @@ export const loadProject = async (args) => {
             const _settings = settings();
             if (!_settings)
                 return;
-            resolveModules({ settings: _settings, nodeishFs: args.nodeishFs, _import: args._import })
+            resolveModules({ settings: _settings, nodeishFs, _import: args._import })
                 .then((resolvedModules) => {
                 setResolvedModules(resolvedModules);
             })

package/dist/loadProject.test.js

@@ -1,8 +1,10 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect, vi } from "vitest";
 import { loadProject } from "./loadProject.js";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
+import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
 import { createNodeishMemoryFs } from "@lix-js/fs";
+import { createMessage } from "./test-utilities/createMessage.js";
+import { tryCatch } from "@inlang/result";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
     let value;
@@ -79,11 +81,22 @@ const _import = async (name) => ({
 });
 // ------------------------------------------------------------------------------------------------
 describe("initialization", () => {
+    it("should throw if settingsFilePath is not an absolute path", async () => {
+        const fs = createNodeishMemoryFs();
+        const result = await tryCatch(() => loadProject({
+            settingsFilePath: "relative/path",
+            nodeishFs: fs,
+            _import,
+        }));
+        expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
+        expect(result.data).toBeUndefined();
+    });
     describe("settings", () => {
         it("should return an error if settings file is not found", async () => {
             const fs = createNodeishMemoryFs();
+            fs.mkdir("/user/project", { recursive: true });
             const project = await loadProject({
-                settingsFilePath: "./test.json",
+                settingsFilePath: "/user/project/test.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -91,9 +104,10 @@ describe("initialization", () => {
         });
         it("should return an error if settings file is not a valid JSON", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", "invalid json");
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", "invalid json");
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -101,9 +115,10 @@ describe("initialization", () => {
         });
         it("should return an error if settings file is does not match schema", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify({}));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({}));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -111,9 +126,10 @@ describe("initialization", () => {
         });
         it("should return the parsed settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -122,18 +138,23 @@ describe("initialization", () => {
         it("should not re-write the settings to disk when initializing", async () => {
             const fs = await createNodeishMemoryFs();
             const settingsWithDeifferentFormatting = JSON.stringify(settings, undefined, 4);
-            await fs.writeFile("./project.inlang.json", settingsWithDeifferentFormatting);
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", settingsWithDeifferentFormatting);
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            const settingsOnDisk = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
+            const settingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+                encoding: "utf-8",
+            });
             expect(settingsOnDisk).toBe(settingsWithDeifferentFormatting);
             project.setSettings(project.settings());
             // TODO: how can we await `setsettings` correctly
             await new Promise((resolve) => setTimeout(resolve, 0));
-            const newsettingsOnDisk = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
+            const newsettingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+                encoding: "utf-8",
+            });
             expect(newsettingsOnDisk).not.toBe(settingsWithDeifferentFormatting);
         });
     });
@@ -143,9 +164,10 @@ describe("initialization", () => {
                 default: {},
             });
             const fs = createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import: $badImport,
             });
@@ -170,9 +192,10 @@ describe("functionality", () => {
     describe("settings", () => {
         it("should return the settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -180,9 +203,10 @@ describe("functionality", () => {
         });
         it("should set a new settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -201,9 +225,10 @@ describe("functionality", () => {
     describe("setSettings", () => {
         it("should fail if settings is not valid", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -213,20 +238,21 @@ describe("functionality", () => {
         });
         it("should write settings to disk", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            const before = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
+            const before = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" });
             expect(before).toBeDefined();
             const result = project.setSettings({ ...settings, languageTags: [] });
             expect(result.data).toBeUndefined();
             expect(result.error).toBeUndefined();
             // TODO: how to wait for fs.writeFile to finish?
             await new Promise((resolve) => setTimeout(resolve, 0));
-            const after = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
+            const after = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" });
             expect(after).toBeDefined();
             expect(after).not.toBe(before);
         });
@@ -239,9 +265,10 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -266,9 +293,10 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -296,7 +324,8 @@ describe("functionality", () => {
                 saveMessages: () => undefined,
             };
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify({
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
@@ -307,7 +336,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -337,7 +366,8 @@ describe("functionality", () => {
                 saveMessages: () => undefined,
             };
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.settings.json", JSON.stringify({
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
@@ -348,7 +378,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "./project.settings.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -359,9 +389,10 @@ describe("functionality", () => {
     describe("errors", () => {
         it("should return the errors", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -373,9 +404,10 @@ describe("functionality", () => {
     describe("customApi", () => {
         it("should return the app specific api", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -387,9 +419,10 @@ describe("functionality", () => {
     describe("messages", () => {
         it("should return the messages", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -407,7 +440,8 @@ describe("functionality", () => {
                     pathPattern: "./resources/{languageTag}.json",
                 },
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             await fs.mkdir("./resources");
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
@@ -423,7 +457,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -543,13 +577,68 @@ describe("functionality", () => {
                 },
             ]);
         });
+        /*
+         * Passing all messages to saveMessages() simplifies plugins by an order of magnitude.
+         *
+         * The alternative would be to pass only the messages that changed to saveMessages().
+         * But, this would require plugins to maintain a separate data structure of messages
+         * and create optimizations, leading to (unjustified) complexity for plugin authors.
+         *
+         * Pros:
+         *   - plugins don't need to transform the data (time complexity).
+         *   - plugins don't to maintain a separate data structure (space complexity).
+         *   - plugin authors don't need to deal with optimizations (ecosystem complexity).
+         *
+         * Cons:
+         *  - Might be slow for a large number of messages. The requirement hasn't popped up yet though.
+         */
+        it("should pass all messages, regardless of which message changed, to saveMessages()", async () => {
+            const fs = createNodeishMemoryFs();
+            const settings = {
+                sourceLanguageTag: "en",
+                languageTags: ["en", "de"],
+                modules: ["plugin.js"],
+                "plugin.project.json": {
+                    pathPattern: "./resources/{languageTag}.json",
+                },
+            };
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            const mockSaveFn = vi.fn();
+            const _mockPlugin = {
+                id: "plugin.project.json",
+                description: "Mock plugin description",
+                displayName: "Mock Plugin",
+                loadMessages: () => [
+                    createMessage("first", { en: "first message" }),
+                    createMessage("second", { en: "second message" }),
+                    createMessage("third", { en: "third message" }),
+                ],
+                saveMessages: mockSaveFn,
+            };
+            const _import = async () => {
+                return {
+                    default: _mockPlugin,
+                };
+            };
+            const project = await loadProject({
+                settingsFilePath: "/user/project/project.inlang.json",
+                nodeishFs: fs,
+                _import,
+            });
+            project.query.messages.create({ data: createMessage("fourth", { en: "fourth message" }) });
+            await new Promise((resolve) => setTimeout(resolve, 510));
+            expect(mockSaveFn.mock.calls.length).toBe(1);
+            expect(mockSaveFn.mock.calls[0][0].messages).toHaveLength(4);
+        });
     });
     describe("lint", () => {
         it.todo("should throw if lint reports are not initialized yet", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -569,9 +658,10 @@ describe("functionality", () => {
                 modules: ["lintRule.js"],
             };
             const fs = createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project", { recursive: true });
+            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import: async () => ({
                     default: mockMessageLintRule,