@inlang/sdk 0.8.0 → 0.10.0

package/dist/resolve-modules/plugins/resolvePlugins.test.js

@@ -2,56 +2,87 @@
 import { describe, expect, it } from "vitest";
 import { resolvePlugins } from "./resolvePlugins.js";
 import { PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginUsesReservedNamespaceError, PluginReturnedInvalidCustomApiError, PluginHasInvalidSchemaError, PluginsDoNotProvideLoadOrSaveMessagesError, } from "./errors.js";
-describe("generally", () => {
-    it("should return an error if a plugin uses an invalid id", async () => {
-        const mockPlugin = {
-            // @ts-expect-error - invalid id
-            id: "no-namespace",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            loadMessages: () => undefined,
-            saveMessages: () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidIdError);
+it("should return an error if a plugin uses an invalid id", async () => {
+    const mockPlugin = {
+        // @ts-expect-error - invalid id
+        id: "no-namespace",
+        description: { en: "My plugin description" },
+        displayName: { en: "My plugin" },
+        loadMessages: () => undefined,
+        saveMessages: () => undefined,
+    };
+    const resolved = await resolvePlugins({
+        plugins: [mockPlugin],
+        settings: {},
+        nodeishFs: {},
     });
-    it("should return an error if a plugin uses APIs that are not available", async () => {
-        const mockPlugin = {
-            id: "plugin.namespace.undefinedApi",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            // @ts-expect-error the key is not available in type
-            nonExistentKey: {
-                nonexistentOptions: "value",
-            },
-            loadMessages: () => undefined,
-            saveMessages: () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidSchemaError);
+    expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidIdError);
+});
+it("should return an error if a plugin uses APIs that are not available", async () => {
+    const mockPlugin = {
+        id: "plugin.namespace.undefinedApi",
+        description: { en: "My plugin description" },
+        displayName: { en: "My plugin" },
+        // @ts-expect-error the key is not available in type
+        nonExistentKey: {
+            nonexistentOptions: "value",
+        },
+        loadMessages: () => undefined,
+        saveMessages: () => undefined,
+    };
+    const resolved = await resolvePlugins({
+        plugins: [mockPlugin],
+        settings: {},
+        nodeishFs: {},
     });
-    it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
-        const mockPlugin = {
-            id: "plugin.inlang.notWhitelisted",
-            description: { en: "My plugin description" },
-            displayName: { en: "My plugin" },
-            loadMessages: () => undefined,
-        };
-        const resolved = await resolvePlugins({
-            plugins: [mockPlugin],
-            settings: {},
-            nodeishFs: {},
-        });
-        expect(resolved.errors[0]).toBeInstanceOf(PluginUsesReservedNamespaceError);
+    expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidSchemaError);
+});
+it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
+    const mockPlugin = {
+        id: "plugin.inlang.notWhitelisted",
+        description: { en: "My plugin description" },
+        displayName: { en: "My plugin" },
+        loadMessages: () => undefined,
+    };
+    const resolved = await resolvePlugins({
+        plugins: [mockPlugin],
+        settings: {},
+        nodeishFs: {},
+    });
+    expect(resolved.errors[0]).toBeInstanceOf(PluginUsesReservedNamespaceError);
+});
+it("should expose the project settings including the plugin settings", async () => {
+    const settings = {
+        sourceLanguageTag: "en",
+        languageTags: ["en", "de"],
+        modules: [],
+        "plugin.namespace.placeholder": {
+            myPluginSetting: "value",
+        },
+    };
+    const mockPlugin = {
+        id: "plugin.namespace.placeholder",
+        description: { en: "My plugin description" },
+        displayName: { en: "My plugin" },
+        saveMessages: async ({ settings }) => {
+            expect(settings).toStrictEqual(settings);
+        },
+        addCustomApi: ({ settings }) => {
+            expect(settings).toStrictEqual(settings);
+            return {};
+        },
+        loadMessages: async ({ settings }) => {
+            expect(settings).toStrictEqual(settings);
+            return [];
+        },
+    };
+    const resolved = await resolvePlugins({
+        plugins: [mockPlugin],
+        settings: settings,
+        nodeishFs: {},
     });
+    await resolved.data.loadMessages({ settings });
+    await resolved.data.saveMessages({ settings, messages: [] });
 });
 describe("loadMessages", () => {
     it("should load messages from a local source", async () => {
@@ -67,8 +98,7 @@ describe("loadMessages", () => {
             nodeishFs: {},
         });
         expect(await resolved.data.loadMessages({
-            languageTags: ["en"],
-            sourceLanguageTag: "en",
+            settings: {},
         })).toEqual([{ id: "test", expressions: [], selectors: [], variants: [] }]);
     });
     it("should collect an error if function is defined twice in multiple plugins", async () => {

package/dist/resolve-modules/plugins/types.d.ts

@@ -1,9 +1,8 @@
-import type { LanguageTag } from "@inlang/language-tag";
 import type { NodeishFilesystem as LisaNodeishFilesystem } from "@lix-js/fs";
 import type { PluginReturnedInvalidCustomApiError, PluginLoadMessagesFunctionAlreadyDefinedError, PluginSaveMessagesFunctionAlreadyDefinedError, PluginHasInvalidIdError, PluginHasInvalidSchemaError, PluginUsesReservedNamespaceError, PluginsDoNotProvideLoadOrSaveMessagesError } from "./errors.js";
 import type { Message } from "@inlang/message";
-import type { JSONObject } from "@inlang/json-types";
 import type { CustomApiInlangIdeExtension, Plugin } from "@inlang/plugin";
+import type { ProjectSettings } from "@inlang/project-settings";
 /**
  * The filesystem is a subset of project lisa's nodeish filesystem.
  *
@@ -15,7 +14,7 @@ export type NodeishFilesystemSubset = Pick<LisaNodeishFilesystem, "readFile" | "
  */
 export type ResolvePluginsFunction = (args: {
     plugins: Array<Plugin>;
-    settings: Record<Plugin["id"], JSONObject>;
+    settings: ProjectSettings;
     nodeishFs: NodeishFilesystemSubset;
 }) => Promise<{
     data: ResolvedPluginApi;
@@ -26,10 +25,10 @@ export type ResolvePluginsFunction = (args: {
  */
 export type ResolvedPluginApi = {
     loadMessages: (args: {
-        languageTags: LanguageTag[];
-        sourceLanguageTag: LanguageTag;
+        settings: ProjectSettings;
     }) => Promise<Message[]> | Message[];
     saveMessages: (args: {
+        settings: ProjectSettings;
         messages: Message[];
     }) => Promise<void> | void;
     /**

package/dist/resolve-modules/plugins/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,iBAAiB,IAAI,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,KAAK,EACX,mCAAmC,EACnC,6CAA6C,EAC7C,6CAA6C,EAC7C,uBAAuB,EACvB,2BAA2B,EAC3B,gCAAgC,EAChC,0CAA0C,EAC1C,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAEzE;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACzC,qBAAqB,EACrB,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAC9C,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE;IAC3C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,CAAA;IAC1C,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAK,OAAO,CAAC;IACb,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,KAAK,CACV,mCAAmC,GACnC,6CAA6C,GAC7C,6CAA6C,GAC7C,uBAAuB,GACvB,2BAA2B,GAC3B,gCAAgC,GAChC,0CAA0C,CAC5C,CAAA;CACD,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE;QACpB,YAAY,EAAE,WAAW,EAAE,CAAA;QAC3B,iBAAiB,EAAE,WAAW,CAAA;KAC9B,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAA;IACpC,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IACrE;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,EAAE,MAAM,CAAC,OAAO,MAAM,IAAI,MAAM,EAAE,GAAG,WAAW,MAAM,IAAI,MAAM,EAAE,EAAE,OAAO,CAAC,GAAG;QACvF,yBAAyB,CAAC,EAAE,2BAA2B,CAAA;KACvD,CAAA;CACD,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/resolve-modules/plugins/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,IAAI,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAC5E,OAAO,KAAK,EACX,mCAAmC,EACnC,6CAA6C,EAC7C,6CAA6C,EAC7C,uBAAuB,EACvB,2BAA2B,EAC3B,gCAAgC,EAChC,0CAA0C,EAC1C,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAC9C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACzC,qBAAqB,EACrB,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,CAC9C,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,IAAI,EAAE;IAC3C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACtB,QAAQ,EAAE,eAAe,CAAA;IACzB,SAAS,EAAE,uBAAuB,CAAA;CAClC,KAAK,OAAO,CAAC;IACb,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,EAAE,KAAK,CACV,mCAAmC,GACnC,6CAA6C,GAC7C,6CAA6C,GAC7C,uBAAuB,GACvB,2BAA2B,GAC3B,gCAAgC,GAChC,0CAA0C,CAC5C,CAAA;CACD,CAAC,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC/B,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,eAAe,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,OAAO,EAAE,CAAA;IACrF,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,QAAQ,EAAE,eAAe,CAAC;QAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;IAChG;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,EAAE,MAAM,CAAC,OAAO,MAAM,IAAI,MAAM,EAAE,GAAG,WAAW,MAAM,IAAI,MAAM,EAAE,EAAE,OAAO,CAAC,GAAG;QACvF,yBAAyB,CAAC,EAAE,2BAA2B,CAAA;KACvD,CAAA;CACD,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"resolveModules.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/resolveModules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAkBvD,eAAO,MAAM,cAAc,EAAE,qBAgF5B,CAAA"}
+{"version":3,"file":"resolveModules.d.ts","sourceRoot":"","sources":["../../src/resolve-modules/resolveModules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AAkBvD,eAAO,MAAM,cAAc,EAAE,qBA+E5B,CAAA"}

package/dist/resolve-modules/resolveModules.js

@@ -19,7 +19,7 @@ export const resolveModules = async (args) => {
         const importedModule = await tryCatch(() => _import(module));
         // -- IMPORT MODULE --
         if (importedModule.error) {
-            moduleErrors.push(new ModuleImportError(`Couldn't import the plugin "${module}"`, {
+            moduleErrors.push(new ModuleImportError({
                 module: module,
                 cause: importedModule.error,
             }));
@@ -27,16 +27,17 @@ export const resolveModules = async (args) => {
         }
         // -- MODULE DOES NOT EXPORT ANYTHING --
         if (importedModule.data?.default === undefined) {
-            moduleErrors.push(new ModuleHasNoExportsError(`Module "${module}" has no exports.`, {
+            moduleErrors.push(new ModuleHasNoExportsError({
                 module: module,
             }));
             continue;
         }
         const isValidModule = ModuleCompiler.Check(importedModule.data);
         if (isValidModule === false) {
-            const errors = [...ModuleCompiler.Errors(importedModule.data)].map((e) => `${e.path} ${e.message}`);
-            moduleErrors.push(new ModuleExportIsInvalidError(`Module "${module}" is invalid: ` + errors.join("\n"), {
+            const errors = [...ModuleCompiler.Errors(importedModule.data)];
+            moduleErrors.push(new ModuleExportIsInvalidError({
                 module: module,
+                errors,
             }));
             continue;
         }

package/dist/resolve-modules/resolveModules.test.js

@@ -11,7 +11,7 @@ it("should return an error if a plugin cannot be imported", async () => {
         settings,
         nodeishFs: {},
         _import: () => {
-            throw new ModuleImportError("Could not import", {
+            throw new ModuleImportError({
                 module: settings.modules[0],
                 cause: new Error("Could not import"),
             });
@@ -74,7 +74,7 @@ it("should return an error if a module cannot be imported", async () => {
         modules: ["https://myplugin.com/index.js"],
     };
     const _import = async () => {
-        throw new ModuleImportError("Could not import", {
+        throw new ModuleImportError({
             module: settings.modules[0],
             cause: new Error(),
         });

package/dist/test-utilities/createMessage.d.ts

@@ -9,8 +9,8 @@ export declare const createMessage: (id: string, patterns: Record<string, Patter
             type: "Text";
             value: string;
         } | {
-            name: string;
             type: "VariableReference";
+            name: string;
         })[];
     }[];
 };

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@inlang/sdk",
 	"type": "module",
-	"version": "0.8.0",
+	"version": "0.10.0",
 	"license": "Apache-2.0",
 	"publishConfig": {
 		"access": "public"

package/src/adapter/solidAdapter.test.ts

@@ -175,7 +175,7 @@ describe("messages", () => {
 			description: {
 				en: "wo",
 			},
-			loadMessages: ({ languageTags }) => (languageTags.length ? exampleMessages : []),
+			loadMessages: ({ settings }) => (settings.languageTags.length ? exampleMessages : []),
 			saveMessages: () => undefined,
 		}
 

package/src/errors.ts

@@ -1,34 +1,43 @@
+import type { ValueError } from "@sinclair/typebox/errors"
+
 export class ProjectSettingsInvalidError extends Error {
-	constructor(message: string, options: ErrorOptions) {
-		super(message, options)
+	constructor(options: { errors: ValueError[] }) {
+		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: string, options: ErrorOptions) {
-		super(message, options)
+	constructor(options: { cause: ErrorOptions["cause"]; path: string }) {
+		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: string, options: ErrorOptions) {
-		super(message, options)
+	constructor(options: { cause?: ErrorOptions["cause"]; path: string }) {
+		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: string, options: ErrorOptions) {
-		super(message, options)
+	constructor(options: { cause: ErrorOptions["cause"] }) {
+		super(`An error occured in saveMessages() caused by ${options.cause}.`, options)
 		this.name = "PluginSaveMessagesError"
 	}
 }
 
 export class PluginLoadMessagesError extends Error {
-	constructor(message: string, options: ErrorOptions) {
-		super(message, options)
+	constructor(options: { cause: ErrorOptions["cause"] }) {
+		super(`An error occured in loadMessages() caused by ${options.cause}.`, options)
 		this.name = "PluginLoadMessagesError"
 	}
 }

package/src/loadProject.test.ts

@@ -482,17 +482,16 @@ describe("functionality", () => {
 		it("should call saveMessages() on updates", async () => {
 			const fs = createNodeishMemoryFs()
 
-			await fs.writeFile(
-				"./project.inlang.json",
-				JSON.stringify({
-					sourceLanguageTag: "en",
-					languageTags: ["en", "de"],
-					modules: ["plugin.js"],
-					"plugin.project.json": {
-						pathPattern: "./resources/{languageTag}.json",
-					},
-				})
-			)
+			const settings: ProjectSettings = {
+				sourceLanguageTag: "en",
+				languageTags: ["en", "de"],
+				modules: ["plugin.js"],
+				"plugin.project.json": {
+					pathPattern: "./resources/{languageTag}.json",
+				},
+			}
+
+			await fs.writeFile("./project.inlang.json", JSON.stringify(settings))
 
 			await fs.mkdir("./resources")
 
@@ -583,9 +582,7 @@ describe("functionality", () => {
 
 			expect(mockSaveFn.mock.calls.length).toBe(1)
 
-			expect(mockSaveFn.mock.calls[0][0].settings).toStrictEqual({
-				pathPattern: "./resources/{languageTag}.json",
-			})
+			expect(mockSaveFn.mock.calls[0][0].settings).toStrictEqual(settings)
 
 			expect(Object.values(mockSaveFn.mock.calls[0][0].messages)).toStrictEqual([
 				{

package/src/loadProject.ts

@@ -73,7 +73,9 @@ export const loadProject = async (args: {
 					return { error }
 				}
 
-				throw new Error("unhandled")
+				throw new Error(
+					"Unhandled error in setSettings. This is an internal bug. Please file an issue."
+				)
 			}
 		}
 
@@ -113,17 +115,14 @@ export const loadProject = async (args: {
 
 			makeTrulyAsync(
 				_resolvedModules.resolvedPluginApi.loadMessages({
-					languageTags: settingsValue!.languageTags,
-					sourceLanguageTag: settingsValue!.sourceLanguageTag,
+					settings: settingsValue,
 				})
 			)
 				.then((messages) => {
 					setMessages(messages)
 					markInitAsComplete()
 				})
-				.catch((err) =>
-					markInitAsFailed(new PluginLoadMessagesError("Error in load messages", { cause: err }))
-				)
+				.catch((err) => markInitAsFailed(new PluginLoadMessagesError({ cause: err })))
 		})
 
 		// -- installed items ----------------------------------------------------
@@ -174,9 +173,12 @@ export const loadProject = async (args: {
 				500,
 				async (newMessages) => {
 					try {
-						await resolvedModules()?.resolvedPluginApi.saveMessages({ messages: newMessages })
+						await resolvedModules()?.resolvedPluginApi.saveMessages({
+							settings: settingsValue,
+							messages: newMessages,
+						})
 					} catch (err) {
-						throw new PluginSaveMessagesError("Error in saving messages", {
+						throw new PluginSaveMessagesError({
 							cause: err,
 						})
 					}
@@ -229,18 +231,17 @@ const loadSettings = async (args: {
 		async () => await args.nodeishFs.readFile(args.settingsFilePath, { encoding: "utf-8" })
 	)
 	if (settingsFileError)
-		throw new ProjectSettingsFileNotFoundError(
-			`Could not locate settings file in (${args.settingsFilePath}).`,
-			{
-				cause: settingsFileError,
-			}
-		)
+		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)
@@ -251,8 +252,8 @@ const parseSettings = (settings: unknown) => {
 	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/src/resolve-modules/errors.ts

@@ -1,12 +1,13 @@
+import type { ValueError } from "@sinclair/typebox/errors"
 export * from "./plugins/errors.js"
 export * from "./message-lint-rules/errors.js"
 
 export class ModuleError extends Error {
-	public readonly Module: string
+	public readonly module: string
 	constructor(message: string, options: { module: string; cause?: Error }) {
 		super(message)
 		this.name = "ModuleError"
-		this.Module = options.module
+		this.module = options.module
 		this.cause = options.cause
 	}
 }
@@ -15,8 +16,8 @@ export class ModuleError extends Error {
  * Error when a Module does not export any plugins or lint rules.
  */
 export class ModuleHasNoExportsError extends ModuleError {
-	constructor(message: string, options: { module: string; cause?: Error }) {
-		super(message, options)
+	constructor(options: { module: string; cause?: Error }) {
+		super(`Module "${module}" has no exports. Every module must have an "export default".`, options)
 		this.name = "ModuleHasNoExportsError"
 	}
 }
@@ -25,15 +26,20 @@ export class ModuleHasNoExportsError extends ModuleError {
  * Error when a Module cannot be imported.
  */
 export class ModuleImportError extends ModuleError {
-	constructor(message: string, options: { module: string; cause: Error }) {
-		super(message, options)
+	constructor(options: { module: string; cause: Error }) {
+		super(`Couldn't import the plugin "${module}":\n\n${options.cause}`, options)
 		this.name = "ModuleImportError"
 	}
 }
 
 export class ModuleExportIsInvalidError extends ModuleError {
-	constructor(message: string, options: { module: string; cause?: Error }) {
-		super(message, options)
+	constructor(options: { module: string; errors: ValueError[] }) {
+		super(
+			`The export(s) of "${module}" are invalid:\n\n${options.errors
+				.map((error) => `Path "${error.path}" with value "${error.value}": "${error.message}"`)
+				.join("\n")}`,
+			options
+		)
 		this.name = "ModuleExportIsInvalidError"
 	}
 }

package/src/resolve-modules/import.ts

@@ -50,14 +50,13 @@ async function $import(
 	try {
 		return await import(/* @vite-ignore */ moduleWithMimeType)
 	} catch (error) {
-		let message = `Error while importing ${uri}: ${(error as Error)?.message ?? "Unknown error"}`
 		if (error instanceof SyntaxError && uri.includes("jsdelivr")) {
-			message += dedent`\n\n
+			error.message += dedent`\n\n
 Are you sure that the file exists on JSDelivr?
 
 The error indicates that the imported file does not exist on JSDelivr. For non-existent files, JSDelivr returns a 404 text that JS cannot parse as a module and throws a SyntaxError.
 			`
 		}
-		throw new ModuleImportError(message, { module: uri, cause: error as Error })
+		throw new ModuleImportError({ module: uri, cause: error as Error })
 	}
 }

package/src/resolve-modules/message-lint-rules/errors.ts

@@ -1,9 +1,9 @@
-export class MessageLintRuleIsInvalidError extends Error {
-	public readonly module: string
+import type { MessageLintRule } from "@inlang/message-lint-rule"
+import type { ValueError } from "@sinclair/typebox/errors"
 
-	constructor(message: string, options: { module: string; cause?: Error }) {
-		super(message)
-		this.module = options.module
+export class MessageLintRuleIsInvalidError extends Error {
+	constructor(options: { id: MessageLintRule["id"]; errors: ValueError[] }) {
+		super(`The message lint rule "${options.id}" is invalid:\n\n${options.errors.join("\n")}`)
 		this.name = "MessageLintRuleIsInvalidError"
 	}
 }

package/src/resolve-modules/message-lint-rules/resolveMessageLintRules.ts

@@ -9,9 +9,11 @@ export const resolveMessageLintRules = (args: { messageLintRules: Array<MessageL
 	}
 	for (const rule of args.messageLintRules) {
 		if (Value.Check(MessageLintRule, rule) === false) {
+			const errors = [...Value.Errors(MessageLintRule, rule)]
 			result.errors.push(
-				new MessageLintRuleIsInvalidError(`Couldn't parse lint rule "${rule.id}"`, {
-					module: "not implemented",
+				new MessageLintRuleIsInvalidError({
+					id: rule.id,
+					errors,
 				})
 			)
 			continue

package/src/resolve-modules/plugins/errors.ts

@@ -1,65 +1,63 @@
 import type { Plugin } from "@inlang/plugin"
+import type { ValueError } from "@sinclair/typebox/errors"
 
-type PluginErrorOptions = {
-	plugin: Plugin["id"] | undefined
-} & Partial<Error>
-
-class PluginError extends Error {
-	public readonly plugin: string
-
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message)
-		this.name = "PluginError"
-		this.plugin = options.plugin ?? "unknown"
-	}
-}
-
-export class PluginHasInvalidIdError extends PluginError {
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message, options)
+export class PluginHasInvalidIdError extends Error {
+	constructor(options: { id: Plugin["id"] }) {
+		super(
+			`Plugin "${options.id}" has an invalid id. The id must:\n1) Start with "plugin."\n2) camelCase\n3) Contain a namespace.\nAn example would be "plugin.namespace.myPlugin".`
+		)
 		this.name = "PluginHasInvalidIdError"
 	}
 }
 
-export class PluginUsesReservedNamespaceError extends PluginError {
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message, options)
+export class PluginUsesReservedNamespaceError extends Error {
+	constructor(options: { id: Plugin["id"] }) {
+		super(`Plugin ${options.id} uses reserved namespace 'inlang'.`)
 		this.name = "PluginUsesReservedNamespaceError"
 	}
 }
 
-export class PluginHasInvalidSchemaError extends PluginError {
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message, options)
+export class PluginHasInvalidSchemaError extends Error {
+	constructor(options: { id: Plugin["id"]; errors: ValueError[] }) {
+		super(
+			`Plugin "${options.id}" has an invalid schema:\n\n${options.errors
+				.map((error) => `Path "${error.path}" with value "${error.value}": "${error.message}"`)
+				.join("\n")})}\n\nPlease refer to the documentation for the correct schema.`
+		)
 		this.name = "PluginHasInvalidSchemaError"
 	}
 }
 
-export class PluginLoadMessagesFunctionAlreadyDefinedError extends PluginError {
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message, options)
+export class PluginLoadMessagesFunctionAlreadyDefinedError extends Error {
+	constructor(options: { id: Plugin["id"] }) {
+		super(
+			`Plugin "${options.id}" defines the \`loadMessages()\` function, but it was already defined by another plugin.\n\nInlang only allows one plugin to define the \`loadMessages()\` function.`
+		)
 		this.name = "PluginLoadMessagesFunctionAlreadyDefinedError"
 	}
 }
 
-export class PluginSaveMessagesFunctionAlreadyDefinedError extends PluginError {
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message, options)
+export class PluginSaveMessagesFunctionAlreadyDefinedError extends Error {
+	constructor(options: { id: Plugin["id"] }) {
+		super(
+			`Plugin "${options.id}" defines the \`saveMessages()\` function, but it was already defined by another plugin.\n\nInlang only allows one plugin to define the \`saveMessages()\` function.`
+		)
 		this.name = "PluginSaveMessagesFunctionAlreadyDefinedError"
 	}
 }
 
-export class PluginReturnedInvalidCustomApiError extends PluginError {
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message, options)
+export class PluginReturnedInvalidCustomApiError extends Error {
+	constructor(options: { id: Plugin["id"]; cause: ErrorOptions["cause"] }) {
+		super(`Plugin "${options.id}" returned an invalid custom API:\n\n${options.cause}`, options)
 		this.name = "PluginReturnedInvalidCustomApiError"
 	}
 }
 
-export class PluginsDoNotProvideLoadOrSaveMessagesError extends PluginError {
-	constructor(message: string, options: PluginErrorOptions) {
-		super(message, options)
+export class PluginsDoNotProvideLoadOrSaveMessagesError extends Error {
+	constructor() {
+		super(
+			`No plugin provides a \`loadMessages()\` or \`saveMessages()\` function\n\nIn case no plugin threw an error, you likely forgot to add a plugin that handles the loading and saving of messages. Refer to the marketplace for available plugins https://inlang.com/marketplace.`
+		)
 		this.name = "PluginsDoNotProvideLoadOrSaveMessagesError"
-		options.plugin = "plugin.inlang.missing"
 	}
 }