@inlang/sdk 0.9.0 → 0.11.0

package/src/resolve-modules/createNodeishFsWithAbsolutePaths.test.ts

@@ -0,0 +1,102 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin"
+import { describe, it, expect } from "vitest"
+import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
+
+describe("createNodeishFsWithAbsolutePaths", () => {
+	it("throws an error if basePath is not an absolute path", () => {
+		const invalidBasePath = "relative/path"
+		const nodeishFs: NodeishFilesystemSubset = {
+			// @ts-expect-error
+			readFile: async () => Promise.resolve(new Uint8Array(0)),
+			readdir: async () => Promise.resolve([]),
+			mkdir: async () => Promise.resolve(""),
+			writeFile: async () => Promise.resolve(),
+		}
+
+		expect(() =>
+			createNodeishFsWithAbsolutePaths({ basePath: invalidBasePath, nodeishFs })
+		).toThrowError("The argument `settingsFilePath` of `loadProject()` must be an absolute path.")
+	})
+
+	it("intercepts paths correctly for readFile", async () => {
+		const basePath = "/absolute/path"
+		const filePath = "file.txt"
+		const expectedPath = "/absolute/path/file.txt"
+
+		const nodeishFs: NodeishFilesystemSubset = {
+			// @ts-expect-error
+			readFile: async (path) => {
+				expect(path).toBe(expectedPath)
+				return Promise.resolve(new Uint8Array(0))
+			},
+			readdir: async () => Promise.resolve([]),
+			mkdir: async () => Promise.resolve(""),
+			writeFile: async () => Promise.resolve(),
+		}
+
+		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
+		await interceptedFs.readFile(filePath, { encoding: "utf-8" })
+	})
+
+	it("intercepts paths correctly for readdir", async () => {
+		const basePath = "/absolute/path"
+		const dirPath = "dir"
+		const expectedPath = "/absolute/path/dir"
+
+		const nodeishFs: NodeishFilesystemSubset = {
+			// @ts-expect-error
+			readFile: async () => Promise.resolve(new Uint8Array(0)),
+			readdir: async (path) => {
+				expect(path).toBe(expectedPath)
+				return Promise.resolve([])
+			},
+			mkdir: async () => Promise.resolve(""),
+			writeFile: async () => Promise.resolve(),
+		}
+
+		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
+		await interceptedFs.readdir(dirPath)
+	})
+
+	it("intercepts paths correctly for mkdir", async () => {
+		const basePath = "/absolute/path"
+		const dirPath = "newDir"
+		const expectedPath = "/absolute/path/newDir"
+
+		const nodeishFs: NodeishFilesystemSubset = {
+			// @ts-expect-error
+			readFile: async () => Promise.resolve(new Uint8Array(0)),
+			readdir: async () => Promise.resolve([]),
+			mkdir: async (path) => {
+				expect(path).toBe(expectedPath)
+				return Promise.resolve("")
+			},
+			writeFile: async () => Promise.resolve(),
+		}
+
+		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
+		await interceptedFs.mkdir(dirPath)
+	})
+
+	it("intercepts paths correctly for writeFile", async () => {
+		const basePath = "/absolute/path"
+		const filePath = "file.txt"
+		const expectedPath = "/absolute/path/file.txt"
+		const data = "Hello, World!"
+
+		const nodeishFs: NodeishFilesystemSubset = {
+			// @ts-expect-error
+			readFile: async () => Promise.resolve(new Uint8Array(0)),
+			readdir: async () => Promise.resolve([]),
+			mkdir: async () => Promise.resolve(""),
+			writeFile: async (path, content) => {
+				expect(path).toBe(expectedPath)
+				expect(content).toBe(data)
+				return Promise.resolve()
+			},
+		}
+
+		const interceptedFs = createNodeishFsWithAbsolutePaths({ basePath, nodeishFs })
+		await interceptedFs.writeFile(filePath, data)
+	})
+})

package/src/resolve-modules/createNodeishFsWithAbsolutePaths.ts

@@ -0,0 +1,30 @@
+import type { NodeishFilesystemSubset } from "@inlang/plugin"
+import { normalizePath } from "@lix-js/fs"
+
+export const createNodeishFsWithAbsolutePaths = (args: {
+	basePath: string
+	nodeishFs: NodeishFilesystemSubset
+}): NodeishFilesystemSubset => {
+	const isAbsolutePath = (path: string) => /^[/\\]/.test(path)
+
+	if (!isAbsolutePath(args.basePath)) {
+		throw new Error("The argument `settingsFilePath` of `loadProject()` must be an absolute path.")
+	}
+
+	const intercept = (path: string) => {
+		if (isAbsolutePath(path)) {
+			return path
+		}
+
+		return normalizePath(args.basePath + "/" + path)
+	}
+
+	return {
+		// @ts-expect-error
+		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
+			args.nodeishFs.readFile(intercept(path), options),
+		readdir: (path: string) => args.nodeishFs.readdir(intercept(path)),
+		mkdir: (path: string) => args.nodeishFs.mkdir(intercept(path)),
+		writeFile: (path: string, data: string) => args.nodeishFs.writeFile(intercept(path), data),
+	}
+}

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

@@ -1,5 +1,4 @@
 import dedent from "dedent"
-import { normalizePath } from "@lix-js/fs"
 import type { NodeishFilesystemSubset } from "@inlang/plugin"
 import { ModuleImportError } from "./errors.js"
 
@@ -42,7 +41,9 @@ async function $import(
 	if (uri.startsWith("http")) {
 		moduleAsText = await (await fetch(uri)).text()
 	} else {
-		moduleAsText = await options.readFile(normalizePath(uri), { encoding: "utf-8" })
+		moduleAsText = await options.readFile(uri, {
+			encoding: "utf-8",
+		})
 	}
 
 	const moduleWithMimeType = "data:application/javascript," + encodeURIComponent(moduleAsText)
@@ -50,14 +51,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"
 	}
 }

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

@@ -42,56 +42,35 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 		// -- INVALID ID in META --
 		const hasInvalidId = errors.some((error) => error.path === "/id")
 		if (hasInvalidId) {
-			result.errors.push(
-				new PluginHasInvalidIdError(
-					`Plugin ${plugin.id} has an invalid id "${plugin.id}". It must be camelCase and contain a namespace like plugin.namespace.myPlugin.`,
-					{ plugin: plugin.id }
-				)
-			)
+			result.errors.push(new PluginHasInvalidIdError({ id: plugin.id }))
 		}
 
 		// -- USES RESERVED NAMESPACE --
 		if (plugin.id.includes("inlang") && !whitelistedPlugins.includes(plugin.id)) {
 			result.errors.push(
-				new PluginUsesReservedNamespaceError(
-					`Plugin ${plugin.id} uses reserved namespace 'inlang'.`,
-					{
-						plugin: plugin.id,
-					}
-				)
+				new PluginUsesReservedNamespaceError({
+					id: plugin.id,
+				})
 			)
 		}
 
 		// -- USES INVALID SCHEMA --
 		if (errors.length > 0) {
 			result.errors.push(
-				new PluginHasInvalidSchemaError(
-					`Plugin ${plugin.id} uses an invalid schema. Please check the documentation for the correct Plugin type.`,
-					{
-						plugin: plugin.id,
-						cause: errors,
-					}
-				)
+				new PluginHasInvalidSchemaError({
+					id: plugin.id,
+					errors: errors,
+				})
 			)
 		}
 
 		// -- ALREADY DEFINED LOADMESSAGES / SAVEMESSAGES / DETECTEDLANGUAGETAGS --
 		if (typeof plugin.loadMessages === "function" && result.data.loadMessages !== undefined) {
-			result.errors.push(
-				new PluginLoadMessagesFunctionAlreadyDefinedError(
-					`Plugin ${plugin.id} defines the loadMessages function, but it was already defined by another plugin.`,
-					{ plugin: plugin.id }
-				)
-			)
+			result.errors.push(new PluginLoadMessagesFunctionAlreadyDefinedError({ id: plugin.id }))
 		}
 
 		if (typeof plugin.saveMessages === "function" && result.data.saveMessages !== undefined) {
-			result.errors.push(
-				new PluginSaveMessagesFunctionAlreadyDefinedError(
-					`Plugin ${plugin.id} defines the saveMessages function, but it was already defined by another plugin.`,
-					{ plugin: plugin.id }
-				)
-			)
+			result.errors.push(new PluginSaveMessagesFunctionAlreadyDefinedError({ id: plugin.id }))
 		}
 
 		// --- ADD APP SPECIFIC API ---
@@ -103,16 +82,13 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 				})
 			)
 			if (error) {
-				// @ts-ignore
-				delete error.stack
-				result.errors.push(error as any) // TODO: add correct error type
-			}
-			if (typeof customApi !== "object") {
+				result.errors.push(new PluginReturnedInvalidCustomApiError({ id: plugin.id, cause: error }))
+			} else if (typeof customApi !== "object") {
 				result.errors.push(
-					new PluginReturnedInvalidCustomApiError(
-						`Plugin ${plugin.id} defines the addCustomApi function, but it does not return an object.`,
-						{ plugin: plugin.id, cause: error }
-					)
+					new PluginReturnedInvalidCustomApiError({
+						id: plugin.id,
+						cause: new Error(`The return value must be an object. Received "${typeof customApi}".`),
+					})
 				)
 			}
 		}
@@ -159,12 +135,7 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 		typeof result.data.loadMessages !== "function" ||
 		typeof result.data.saveMessages !== "function"
 	) {
-		result.errors.push(
-			new PluginsDoNotProvideLoadOrSaveMessagesError(
-				"It seems you did not install any plugin that handles messages. Please add one to make inlang work. See https://inlang.com/documentation/plugins/registry.",
-				{ plugin: undefined }
-			)
-		)
+		result.errors.push(new PluginsDoNotProvideLoadOrSaveMessagesError())
 	}
 
 	return result

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

@@ -1,4 +1,4 @@
-import type { NodeishFilesystem as LisaNodeishFilesystem } from "@lix-js/fs"
+import type { NodeishFilesystem } from "@lix-js/fs"
 import type {
 	PluginReturnedInvalidCustomApiError,
 	PluginLoadMessagesFunctionAlreadyDefinedError,
@@ -18,7 +18,7 @@ import type { ProjectSettings } from "@inlang/project-settings"
  * - only uses minimally required functions to decrease the API footprint on the ecosystem.
  */
 export type NodeishFilesystemSubset = Pick<
-	LisaNodeishFilesystem,
+	NodeishFilesystem,
 	"readFile" | "readdir" | "mkdir" | "writeFile"
 >
 

package/src/resolve-modules/resolveModules.test.ts

@@ -23,7 +23,7 @@ it("should return an error if a plugin cannot be imported", async () => {
 		settings,
 		nodeishFs: {} as any,
 		_import: () => {
-			throw new ModuleImportError("Could not import", {
+			throw new ModuleImportError({
 				module: settings.modules[0]!,
 				cause: new Error("Could not import"),
 			})
@@ -94,7 +94,7 @@ it("should return an error if a module cannot be imported", async () => {
 	}
 
 	const _import = async () => {
-		throw new ModuleImportError("Could not import", {
+		throw new ModuleImportError({
 			module: settings.modules[0]!,
 			cause: new Error(),
 		})

package/src/resolve-modules/resolveModules.ts

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