@inlang/sdk 0.32.0 → 0.34.0

package/src/storage/helpers.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest"
+// import { parseLixUri, parseOrigin } from "./helpers.js"
+import { normalizeMessage, stringifyMessage } from "./helper.js"
+import type { Message } from "@inlang/message"
+
+const unsortedMessageRaw: Message = {
+	alias: {},
+	selectors: [],
+	id: "footer_categories_apps",
+	variants: [
+		{ languageTag: "a", match: ["*", "1"], pattern: [{ type: "Text", value: "2" }] },
+		{ languageTag: "a", match: ["*", "*"], pattern: [{ type: "Text", value: "1" }] },
+		{
+			languageTag: "a",
+			match: ["1", "*"],
+			pattern: [
+				{ type: "Text", value: "2" },
+				{ type: "Text", value: "2" },
+			],
+		},
+		{ languageTag: "b", match: [], pattern: [{ type: "Text", value: "4" }] },
+		{ languageTag: "a", match: ["1", "1"], pattern: [{ type: "Text", value: "2" }] },
+		{ languageTag: "c", match: [], pattern: [{ value: "5", type: "Text" }] },
+		{ match: [], languageTag: "d", pattern: [{ type: "Text", value: "6" }] },
+		{ languageTag: "e", match: [], pattern: [{ type: "Text", value: "7" }] },
+		{ languageTag: "f", match: [], pattern: [{ type: "Text", value: "8" }] },
+		{ languageTag: "g", match: [], pattern: [{ type: "Text", value: "9" }] },
+	],
+}
+
+const sortedMessageRaw: Message = {
+	alias: {},
+	id: "footer_categories_apps",
+	selectors: [],
+	variants: [
+		{ languageTag: "a", match: ["*", "*"], pattern: [{ type: "Text", value: "1" }] },
+		{ languageTag: "a", match: ["*", "1"], pattern: [{ type: "Text", value: "2" }] },
+		{
+			languageTag: "a",
+			match: ["1", "*"],
+			pattern: [
+				{ type: "Text", value: "2" },
+				{ type: "Text", value: "2" },
+			],
+		},
+		{ languageTag: "a", match: ["1", "1"], pattern: [{ type: "Text", value: "2" }] },
+		{ languageTag: "b", match: [], pattern: [{ type: "Text", value: "4" }] },
+		{ languageTag: "c", match: [], pattern: [{ type: "Text", value: "5" }] },
+		{ languageTag: "d", match: [], pattern: [{ type: "Text", value: "6" }] },
+		{ languageTag: "e", match: [], pattern: [{ type: "Text", value: "7" }] },
+		{ languageTag: "f", match: [], pattern: [{ type: "Text", value: "8" }] },
+		{ languageTag: "g", match: [], pattern: [{ type: "Text", value: "9" }] },
+	],
+}
+
+// stringify with no indentation
+function str(obj: any) {
+	return JSON.stringify(obj)
+}
+
+// stringify with 2 space indentation
+function str2(obj: any) {
+	return JSON.stringify(obj, undefined, 2)
+}
+
+// stringify with 4 space indentation
+function str4(obj: any) {
+	return JSON.stringify(obj, undefined, 4)
+}
+
+describe("normalizeMessage", () => {
+	it("should return the message with sorted keys and variants", () => {
+		// test cases are not the same (deep equal) before normalization
+		// array order of variants is different
+		expect(unsortedMessageRaw).not.toEqual(sortedMessageRaw)
+
+		// test cases are the same after normalization
+		expect(normalizeMessage(unsortedMessageRaw)).toEqual(sortedMessageRaw)
+
+		// stringify results are not the same before normalization
+		expect(str(unsortedMessageRaw)).not.toBe(str(sortedMessageRaw))
+
+		// stringify results are the same after normalization
+		expect(str(normalizeMessage(unsortedMessageRaw))).toBe(str(sortedMessageRaw))
+		expect(str2(normalizeMessage(unsortedMessageRaw))).toBe(str2(sortedMessageRaw))
+		expect(str4(normalizeMessage(unsortedMessageRaw))).toBe(str4(sortedMessageRaw))
+	})
+})
+
+describe("stringifyMessage", () => {
+	it("should normalize and JSON stringify a message with 4 space indentation", () => {
+		expect(stringifyMessage(unsortedMessageRaw)).toBe(str4(sortedMessageRaw))
+		expect(stringifyMessage(sortedMessageRaw)).toBe(str4(sortedMessageRaw))
+	})
+})

package/src/validateProjectPath.test.ts

@@ -0,0 +1,68 @@
+import { assert, describe, expect, it } from "vitest"
+import {
+	assertValidProjectPath,
+	isAbsolutePath,
+	isInlangProjectPath,
+	pathExists,
+} from "./validateProjectPath.js"
+import { mockRepo } from "@lix-js/client"
+
+describe("isAbsolutePath", () => {
+	it("should correctly identify Unix absolute paths", () => {
+		assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"))
+		assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"))
+		assert.isFalse(isAbsolutePath("relative/path/to/file.txt"))
+	})
+
+	it("should correctly identify Windows absolute paths", () => {
+		assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"))
+		assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"))
+		assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"))
+	})
+
+	it("should handle edge cases", () => {
+		assert.isFalse(isAbsolutePath("")) // Empty path should return false
+		assert.isFalse(isAbsolutePath("relative/path/../file.txt")) // Relative path with ".." should return false
+		assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"))
+		assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"))
+	})
+})
+
+describe("isInlangProjectPath", () => {
+	it("should correctly identify valid inlang project paths", () => {
+		assert.isTrue(isInlangProjectPath("/path/to/orange-mouse.inlang"))
+		assert.isFalse(isInlangProjectPath("relative/path/to/file.txt"))
+		assert.isFalse(isInlangProjectPath("/path/to/.inlang"))
+		assert.isFalse(isInlangProjectPath("/path/to/white-elephant.inlang/"))
+		assert.isFalse(isInlangProjectPath("/path/to/blue-elephant.inlang/settings.json"))
+	})
+})
+
+describe("assertValidProjectPath", () => {
+	it("should not throw for valid project paths", () => {
+		assert.doesNotThrow(() => assertValidProjectPath("/path/to/brown-mouse.inlang"))
+		assert.doesNotThrow(() => assertValidProjectPath("/path/to/green-elephant.inlang"))
+	})
+
+	it("should throw for invalid project paths", () => {
+		assert.throws(() => assertValidProjectPath("relative/path/to/flying-lizard.inlang"))
+		assert.throws(() => assertValidProjectPath("/path/to/loud-mouse.inlang/"))
+		assert.throws(() => assertValidProjectPath("/path/to/green-elephant.inlang/settings.json"))
+	})
+})
+
+// moar tests in paraglide-js/src/services/file-handling/exists.test.ts
+describe("pathExists", () => {
+	it("should work for files", async () => {
+		const repo = await mockRepo()
+		await repo.nodeishFs.writeFile("/test.txt", "hello")
+		expect(await pathExists("/test.txt", repo.nodeishFs)).toBe(true)
+		expect(await pathExists("/does-not-exist.txt", repo.nodeishFs)).toBe(false)
+	})
+	it("should work for directories", async () => {
+		const repo = await mockRepo()
+		await repo.nodeishFs.mkdir("/test/project.inlang", { recursive: true })
+		expect(await pathExists("/test/project.inlang", repo.nodeishFs)).toBe(true)
+		expect(await pathExists("/test/white-gorilla.inlang", repo.nodeishFs)).toBe(false)
+	})
+})

package/src/validateProjectPath.ts

@@ -0,0 +1,58 @@
+import type { NodeishFilesystem } from "@lix-js/fs"
+
+/**
+ * validate that a project path is absolute and ends with {name}.inlang.
+ *
+ * @throws if the path is not valid.
+ */
+export function assertValidProjectPath(projectPath: string) {
+	if (!isAbsolutePath(projectPath)) {
+		throw new Error(`Expected an absolute path but received "${projectPath}".`)
+	}
+	if (!isInlangProjectPath(projectPath)) {
+		throw new Error(
+			`Expected a path ending in "{name}.inlang" but received "${projectPath}".\n\nValid examples: \n- "/path/to/micky-mouse.inlang"\n- "/path/to/green-elephant.inlang\n`
+		)
+	}
+}
+
+/**
+ * tests whether a path ends with {name}.inlang
+ * (does not remove trailing slash)
+ */
+export function isInlangProjectPath(path: string) {
+	return /[^\\/]+\.inlang$/.test(path)
+}
+
+/**
+ * tests whether a path starts with a forward slash (/) or a windows-style
+ * drive letter (C: or D:, etc.) followed by a slash
+ */
+export function isAbsolutePath(path: string) {
+	return /^\/|^[A-Za-z]:[\\/]/.test(path)
+
+	// OG from sdk/src/isAbsolutePath.ts - TODO: find out where this regex came from
+	// const matchPosixAndWindowsAbsolutePaths =
+	// 	/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
+	// return matchPosixAndWindowsAbsolutePaths.test(path)
+}
+
+/**
+ * Returns true if the path exists (file or directory), false otherwise.
+ *
+ */
+export async function pathExists(filePath: string, nodeishFs: NodeishFilesystem) {
+	// from paraglide-js/src/services/file-handling/exists.ts
+	// TODO: add fs.exists to @lix-js/fs
+	try {
+		await nodeishFs.stat(filePath)
+		return true
+	} catch (error) {
+		//@ts-ignore
+		if (error.code === "ENOENT") {
+			return false
+		} else {
+			throw new Error(`Failed to check if path exists: ${error}`, { cause: error })
+		}
+	}
+}

package/dist/isAbsolutePath.d.ts

@@ -1,2 +0,0 @@
-export declare const isAbsolutePath: (path: string) => boolean;
-//# sourceMappingURL=isAbsolutePath.d.ts.map

package/dist/isAbsolutePath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isAbsolutePath.d.ts","sourceRoot":"","sources":["../src/isAbsolutePath.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,SAAU,MAAM,YAI1C,CAAA"}

package/dist/isAbsolutePath.js

@@ -1,4 +0,0 @@
-export const isAbsolutePath = (path) => {
-    const matchPosixAndWindowsAbsolutePaths = /^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/;
-    return matchPosixAndWindowsAbsolutePaths.test(path);
-};

package/dist/isAbsolutePath.test.d.ts

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

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

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

package/dist/isAbsolutePath.test.js

@@ -1,20 +0,0 @@
-import { assert, describe, it } from "vitest";
-import { isAbsolutePath } from "./isAbsolutePath.js";
-describe("isAbsolutePath", () => {
-    it("should correctly identify Unix absolute paths", () => {
-        assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"));
-        assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"));
-        assert.isFalse(isAbsolutePath("relative/path/to/file.txt"));
-    });
-    it("should correctly identify Windows absolute paths", () => {
-        assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"));
-        assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"));
-        assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"));
-    });
-    it("should handle edge cases", () => {
-        assert.isFalse(isAbsolutePath("")); // Empty path should return false
-        assert.isFalse(isAbsolutePath("relative/path/../file.txt")); // Relative path with ".." should return false
-        assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"));
-        assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"));
-    });
-});

package/src/isAbsolutePath.test.ts

@@ -1,23 +0,0 @@
-import { assert, describe, it } from "vitest"
-import { isAbsolutePath } from "./isAbsolutePath.js"
-
-describe("isAbsolutePath", () => {
-	it("should correctly identify Unix absolute paths", () => {
-		assert.isTrue(isAbsolutePath("/home/user/documents/file.txt"))
-		assert.isTrue(isAbsolutePath("/usr/local/bin/script.sh"))
-		assert.isFalse(isAbsolutePath("relative/path/to/file.txt"))
-	})
-
-	it("should correctly identify Windows absolute paths", () => {
-		assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"))
-		assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"))
-		assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"))
-	})
-
-	it("should handle edge cases", () => {
-		assert.isFalse(isAbsolutePath("")) // Empty path should return false
-		assert.isFalse(isAbsolutePath("relative/path/../file.txt")) // Relative path with ".." should return false
-		assert.isFalse(isAbsolutePath("../relative/path/to/file.txt"))
-		assert.isFalse(isAbsolutePath("./relative/path/to/file.txt"))
-	})
-})

package/src/isAbsolutePath.ts

@@ -1,5 +0,0 @@
-export const isAbsolutePath = (path: string) => {
-	const matchPosixAndWindowsAbsolutePaths =
-		/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
-	return matchPosixAndWindowsAbsolutePaths.test(path)
-}