@inlang/sdk 0.17.0 → 0.19.0

package/src/loadProject.test.ts

@@ -1,7 +1,13 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect, vi } from "vitest"
 import { loadProject } from "./loadProject.js"
-import type { ProjectSettings, Plugin, MessageLintRule, Message } from "./versionedInterfaces.js"
+import type {
+	ProjectSettings,
+	Plugin,
+	MessageLintRule,
+	Message,
+	NodeishFilesystemSubset,
+} from "./versionedInterfaces.js"
 import type { ImportFunction } from "./resolve-modules/index.js"
 import type { InlangModule } from "@inlang/module"
 import {
@@ -10,7 +16,7 @@ import {
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
 } from "./errors.js"
-import { createNodeishMemoryFs } from "@lix-js/fs"
+import { createNodeishMemoryFs, normalizePath } from "@lix-js/fs"
 import { createMessage } from "./test-utilities/createMessage.js"
 import { tryCatch } from "@inlang/result"
 
@@ -99,13 +105,52 @@ const _import: ImportFunction = async (name) =>
 
 // ------------------------------------------------------------------------------------------------
 
+/**
+ * Dear Developers,
+ *
+ * Inlang projects (folders) are not like .vscode, .git, or .github folders. Treat em
+ * like files: they can be renamed and moved around.
+ */
+it("should throw if a project (path) does not have a name", async () => {
+	const fs = createNodeishMemoryFs()
+	const project = await tryCatch(() =>
+		loadProject({
+			projectPath: "/source-code/.inlang",
+			nodeishFs: fs,
+			_import,
+		})
+	)
+	expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument)
+})
+
+it("should throw if a project path does not end with .inlang", async () => {
+	const fs = createNodeishMemoryFs()
+
+	const invalidPaths = [
+		"/source-code/frontend.inlang/settings",
+		"/source-code/frontend.inlang/settings.json",
+		"/source-code/frontend.inlang.md",
+	]
+
+	for (const invalidPath of invalidPaths) {
+		const project = await tryCatch(() =>
+			loadProject({
+				projectPath: invalidPath,
+				nodeishFs: fs,
+				_import,
+			})
+		)
+		expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument)
+	}
+})
+
 describe("initialization", () => {
-	it("should throw if settingsFilePath is not an absolute path", async () => {
+	it("should throw if projectPath is not an absolute path", async () => {
 		const fs = createNodeishMemoryFs()
 
 		const result = await tryCatch(() =>
 			loadProject({
-				settingsFilePath: "relative/path",
+				projectPath: "relative/path",
 				nodeishFs: fs,
 				_import,
 			})
@@ -116,12 +161,12 @@ describe("initialization", () => {
 
 	it("should resolve from a windows path", async () => {
 		const fs = createNodeishMemoryFs()
-		fs.mkdir("C:\\Users\\user\\project", { recursive: true })
-		fs.writeFile("C:\\Users\\user\\project\\project.inlang.json", JSON.stringify(settings))
+		fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true })
+		fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings))
 
 		const result = await tryCatch(() =>
 			loadProject({
-				settingsFilePath: "C:\\Users\\user\\project\\project.inlang.json",
+				projectPath: "C:\\Users\\user\\project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -137,7 +182,7 @@ describe("initialization", () => {
 			fs.mkdir("/user/project", { recursive: true })
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/test.json",
+				projectPath: "/user/non-existend-project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -147,11 +192,11 @@ describe("initialization", () => {
 
 		it("should return an error if settings file is not a valid JSON", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", "invalid json")
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", "invalid json")
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -161,11 +206,11 @@ describe("initialization", () => {
 
 		it("should return an error if settings file is does not match schema", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({}))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({}))
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -175,10 +220,10 @@ describe("initialization", () => {
 
 		it("should return the parsed settings", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -189,16 +234,16 @@ 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.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", settingsWithDeifferentFormatting)
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", settingsWithDeifferentFormatting)
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
 
-			const settingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+			const settingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
 				encoding: "utf-8",
 			})
 			expect(settingsOnDisk).toBe(settingsWithDeifferentFormatting)
@@ -207,7 +252,7 @@ describe("initialization", () => {
 			// TODO: how can we await `setsettings` correctly
 			await new Promise((resolve) => setTimeout(resolve, 0))
 
-			const newsettingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+			const newsettingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
 				encoding: "utf-8",
 			})
 			expect(newsettingsOnDisk).not.toBe(settingsWithDeifferentFormatting)
@@ -222,11 +267,11 @@ describe("initialization", () => {
 				} satisfies InlangModule)
 
 			const fs = createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import: $badImport,
 			})
@@ -255,10 +300,10 @@ describe("functionality", () => {
 	describe("settings", () => {
 		it("should return the settings", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -268,10 +313,10 @@ describe("functionality", () => {
 
 		it("should set a new settings", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -292,12 +337,12 @@ describe("functionality", () => {
 	})
 
 	describe("setSettings", () => {
-		it("should fail if settings is not valid", async () => {
+		it("should fail if settings are not valid", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -309,7 +354,7 @@ describe("functionality", () => {
 
 		it("should throw an error if sourceLanguageTag is not in languageTags", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
+			await fs.mkdir("/user/project.inlang", { recursive: true })
 
 			const settings: ProjectSettings = {
 				sourceLanguageTag: "en",
@@ -317,10 +362,10 @@ describe("functionality", () => {
 				modules: [],
 			}
 
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -331,25 +376,25 @@ describe("functionality", () => {
 
 		it("should write settings to disk", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
 
-			const before = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" })
+			const before = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" })
 			expect(before).toBeDefined()
 
-			const result = project.setSettings({ ...settings, languageTags: ["en"] })
+			const result = project.setSettings({ ...settings, languageTags: ["en", "nl", "de"] })
 			expect(result.data).toBeUndefined()
 			expect(result.error).toBeUndefined()
 
 			// TODO: how to wait for fs.writeFile to finish?
-			await new Promise((resolve) => setTimeout(resolve, 0))
+			await new Promise((resolve) => setTimeout(resolve, 50))
 
-			const after = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" })
+			const after = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" })
 			expect(after).toBeDefined()
 			expect(after).not.toBe(before)
 		})
@@ -363,10 +408,10 @@ describe("functionality", () => {
 				languageTags: ["en"],
 				modules: ["plugin.js", "lintRule.js"],
 			}
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -396,11 +441,11 @@ describe("functionality", () => {
 				modules: ["plugin.js", "lintRule.js"],
 			}
 
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -431,9 +476,9 @@ describe("functionality", () => {
 				saveMessages: () => undefined,
 			}
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
+			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile(
-				"/user/project/project.inlang.json",
+				"/user/project.inlang/settings.json",
 				JSON.stringify({
 					sourceLanguageTag: "en",
 					languageTags: ["en"],
@@ -447,7 +492,7 @@ describe("functionality", () => {
 				} satisfies InlangModule
 			}
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -482,9 +527,9 @@ describe("functionality", () => {
 				saveMessages: () => undefined,
 			}
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
+			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile(
-				"/user/project/project.inlang.json",
+				"/user/project.inlang/settings.json",
 				JSON.stringify({
 					sourceLanguageTag: "en",
 					languageTags: ["en"],
@@ -498,7 +543,7 @@ describe("functionality", () => {
 			}
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -514,10 +559,10 @@ describe("functionality", () => {
 	describe("errors", () => {
 		it("should return the errors", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -530,10 +575,10 @@ describe("functionality", () => {
 	describe("customApi", () => {
 		it("should return the app specific api", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -547,10 +592,10 @@ describe("functionality", () => {
 	describe("messages", () => {
 		it("should return the messages", async () => {
 			const fs = await createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -572,8 +617,8 @@ describe("functionality", () => {
 				},
 			}
 
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 
 			await fs.mkdir("./resources")
 
@@ -595,7 +640,7 @@ describe("functionality", () => {
 			}
 
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -750,7 +795,8 @@ describe("functionality", () => {
 				},
 			}
 
-			await fs.writeFile("./project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("./project.inlang", { recursive: true })
+			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings))
 
 			const mockSaveFn = vi.fn()
 
@@ -774,7 +820,7 @@ describe("functionality", () => {
 			}
 
 			const project = await loadProject({
-				settingsFilePath: "/project.inlang.json",
+				projectPath: "/project.inlang",
 				nodeishFs: fs,
 				_import,
 			})
@@ -794,7 +840,7 @@ describe("functionality", () => {
 			await fs.mkdir("/user/project", { recursive: true })
 			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project/project.inlang.json",
 				nodeishFs: fs,
 				_import,
 			})
@@ -813,10 +859,10 @@ describe("functionality", () => {
 				modules: ["lintRule.js"],
 			}
 			const fs = createNodeishMemoryFs()
-			await fs.mkdir("/user/project", { recursive: true })
-			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 			const project = await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import: async () => ({
 					default: mockMessageLintRule,
@@ -826,4 +872,89 @@ describe("functionality", () => {
 			project.query.messageLintReports.getAll.subscribe((r) => expect(r).toEqual([]))
 		})
 	})
+
+	describe("watcher", () => {
+		it("changing files in resources should trigger callback of message query", async () => {
+			const fs = createNodeishMemoryFs()
+
+			const messages = {
+				$schema: "https://inlang.com/schema/inlang-message-format",
+				data: [
+					{
+						id: "test",
+						selectors: [],
+						variants: [
+							{
+								match: [],
+								languageTag: "en",
+								pattern: [
+									{
+										type: "Text",
+										value: "test",
+									},
+								],
+							},
+						],
+					},
+				],
+			}
+
+			await fs.writeFile("./messages.json", JSON.stringify(messages))
+
+			const getMessages = async (customFs: NodeishFilesystemSubset) => {
+				const file = await customFs.readFile("./messages.json", { encoding: "utf-8" })
+				return JSON.parse(file.toString()).data
+			}
+
+			const mockMessageFormatPlugin: Plugin = {
+				id: "plugin.inlang.messageFormat",
+				description: { en: "Mock plugin description" },
+				displayName: { en: "Mock Plugin" },
+
+				loadMessages: async (args) => await getMessages(args.nodeishFs),
+				saveMessages: () => undefined as any,
+			}
+
+			const settings: ProjectSettings = {
+				sourceLanguageTag: "en",
+				languageTags: ["en"],
+				modules: ["plugin.js"],
+				"plugin.inlang.messageFormat": {
+					filePath: "./messages.json",
+				},
+			}
+
+			await fs.mkdir("./project.inlang", { recursive: true })
+			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings))
+
+			// establish watcher
+			const project = await loadProject({
+				projectPath: normalizePath("/project.inlang"),
+				nodeishFs: fs,
+				_import: async () => ({
+					default: mockMessageFormatPlugin,
+				}),
+			})
+
+			let counter = 0
+
+			project.query.messages.getAll.subscribe(() => {
+				counter = counter + 1
+			})
+
+			expect(counter).toBe(1)
+
+			// change file
+			await fs.writeFile("./messages.json", JSON.stringify(messages))
+			await new Promise((resolve) => setTimeout(resolve, 0))
+
+			expect(counter).toBe(2)
+
+			// change file
+			await fs.writeFile("./messages.json", JSON.stringify(messages))
+			await new Promise((resolve) => setTimeout(resolve, 0))
+
+			expect(counter).toBe(3)
+		})
+	})
 })