@inlang/sdk 0.9.0 → 0.11.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/errors.d.ts

@@ -1,16 +1,29 @@
+import type { ValueError } from "@sinclair/typebox/errors";
 export declare class ProjectSettingsInvalidError extends Error {
-    constructor(message: string, options: ErrorOptions);
+    constructor(options: {
+        errors: ValueError[];
+    });
 }
 export declare class ProjectSettingsFileJSONSyntaxError extends Error {
-    constructor(message: string, options: ErrorOptions);
+    constructor(options: {
+        cause: ErrorOptions["cause"];
+        path: string;
+    });
 }
 export declare class ProjectSettingsFileNotFoundError extends Error {
-    constructor(message: string, options: ErrorOptions);
+    constructor(options: {
+        cause?: ErrorOptions["cause"];
+        path: string;
+    });
 }
 export declare class PluginSaveMessagesError extends Error {
-    constructor(message: string, options: ErrorOptions);
+    constructor(options: {
+        cause: ErrorOptions["cause"];
+    });
 }
 export declare class PluginLoadMessagesError extends Error {
-    constructor(message: string, options: ErrorOptions);
+    constructor(options: {
+        cause: ErrorOptions["cause"];
+    });
 }
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,2BAA4B,SAAQ,KAAK;gBACzC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,kCAAmC,SAAQ,KAAK;gBAChD,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,gCAAiC,SAAQ,KAAK;gBAC9C,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD;AAED,qBAAa,uBAAwB,SAAQ,KAAK;gBACrC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY;CAIlD"}
+{"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"}

package/dist/errors.js

@@ -1,30 +1,32 @@
 export class ProjectSettingsInvalidError extends Error {
-    constructor(message, options) {
-        super(message, options);
+    constructor(options) {
+        super(`The project settings are invalid:\n\n${options.errors
+            .map((error) => `The value of "${error.path}" is invalid:\n\n${error.message}`)
+            .join("\n")}`);
         this.name = "ProjectSettingsInvalidError";
     }
 }
 export class ProjectSettingsFileJSONSyntaxError extends Error {
-    constructor(message, options) {
-        super(message, options);
+    constructor(options) {
+        super(`The settings file at "${options.path}" is not a valid JSON file:\n\n${options.cause}`, options);
         this.name = "ProjectSettingsFileJSONSyntaxError";
     }
 }
 export class ProjectSettingsFileNotFoundError extends Error {
-    constructor(message, options) {
-        super(message, options);
+    constructor(options) {
+        super(`The file at "${options.path}" could not be read. Does the file exists?`, options);
         this.name = "ProjectSettingsFileNotFoundError";
     }
 }
 export class PluginSaveMessagesError extends Error {
-    constructor(message, options) {
-        super(message, options);
+    constructor(options) {
+        super(`An error occured in saveMessages() caused by ${options.cause}.`, options);
         this.name = "PluginSaveMessagesError";
     }
 }
 export class PluginLoadMessagesError extends Error {
-    constructor(message, options) {
-        super(message, options);
+    constructor(options) {
+        super(`An error occured in loadMessages() caused by ${options.cause}.`, options);
         this.name = "PluginLoadMessagesError";
     }
 }

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

package/dist/loadProject.js

@@ -8,21 +8,30 @@ 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 } from "./resolve-modules/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) => {
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
+        // -- absolute path env -----------------------------------------------
+        const nodeishFs = createNodeishFsWithAbsolutePaths({
+            nodeishFs: args.nodeishFs,
+            basePath: args.settingsFilePath.replace(/(.*?)[^/]*\..*$/, "$1"), // get directory of settings file
+        });
         // -- 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 +43,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);
@@ -46,7 +55,7 @@ export const loadProject = async (args) => {
                 if (error instanceof ProjectSettingsInvalidError) {
                     return { error };
                 }
-                throw new Error("unhandled");
+                throw new Error("Unhandled error in setSettings. This is an internal bug. Please file an issue.");
             }
         };
         // -- resolvedModules -----------------------------------------------------------
@@ -55,7 +64,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);
             })
@@ -83,7 +92,7 @@ export const loadProject = async (args) => {
                 setMessages(messages);
                 markInitAsComplete();
             })
-                .catch((err) => markInitAsFailed(new PluginLoadMessagesError("Error in load messages", { cause: err })));
+                .catch((err) => markInitAsFailed(new PluginLoadMessagesError({ cause: err })));
         });
         // -- installed items ----------------------------------------------------
         const installedMessageLintRules = () => {
@@ -122,7 +131,7 @@ export const loadProject = async (args) => {
                 });
             }
             catch (err) {
-                throw new PluginSaveMessagesError("Error in saving messages", {
+                throw new PluginSaveMessagesError({
                     cause: err,
                 });
             }
@@ -160,13 +169,15 @@ export const loadProject = async (args) => {
 const loadSettings = async (args) => {
     const { data: settingsFile, error: settingsFileError } = await tryCatch(async () => await args.nodeishFs.readFile(args.settingsFilePath, { encoding: "utf-8" }));
     if (settingsFileError)
-        throw new ProjectSettingsFileNotFoundError(`Could not locate settings file in (${args.settingsFilePath}).`, {
+        throw new ProjectSettingsFileNotFoundError({
             cause: settingsFileError,
+            path: args.settingsFilePath,
         });
     const json = tryCatch(() => JSON.parse(settingsFile));
     if (json.error) {
-        throw new ProjectSettingsFileJSONSyntaxError(`The settings is not a valid JSON file.`, {
+        throw new ProjectSettingsFileJSONSyntaxError({
             cause: json.error,
+            path: args.settingsFilePath,
         });
     }
     return parseSettings(json.data);
@@ -176,8 +187,8 @@ const parseSettings = (settings) => {
     if (settingsCompiler.Check(withMigration) === false) {
         const typeErrors = [...settingsCompiler.Errors(settings)];
         if (typeErrors.length > 0) {
-            throw new ProjectSettingsInvalidError(`The settings is invalid according to the schema.`, {
-                cause: typeErrors,
+            throw new ProjectSettingsInvalidError({
+                errors: typeErrors,
             });
         }
     }

package/dist/loadProject.test.js

@@ -3,6 +3,7 @@ import { describe, it, expect, vi } from "vitest";
 import { loadProject } from "./loadProject.js";
 import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
 import { createNodeishMemoryFs } from "@lix-js/fs";
+import { createMessage } from "./test-utilities/createMessage.js";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
     let value;
@@ -82,8 +83,9 @@ describe("initialization", () => {
     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 +93,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 +104,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 +115,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 +127,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 +153,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 +181,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 +192,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 +214,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 +227,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 +254,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 +282,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 +313,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 +325,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -337,7 +355,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 +367,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "./project.settings.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -359,9 +378,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 +393,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 +408,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 +429,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 +446,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "./project.inlang.json",
+                settingsFilePath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -543,13 +566,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 +647,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,

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.d.ts

@@ -0,0 +1,6 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin";
+export declare const createNodeishFsWithAbsolutePaths: (args: {
+    basePath: string;
+    nodeishFs: NodeishFilesystemSubset;
+}) => NodeishFilesystemSubset;
+//# sourceMappingURL=createNodeishFsWithAbsolutePaths.d.ts.map

package/dist/resolve-modules/createNodeishFsWithAbsolutePaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNodeishFsWithAbsolutePaths.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/createNodeishFsWithAbsolutePaths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D,eAAO,MAAM,gCAAgC,SAAU;IACtD,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAG,uBAuBH,CAAA"}