@inlang/sdk 0.32.0 → 0.34.0

package/dist/validateProjectPath.d.ts

@@ -0,0 +1,23 @@
+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 declare function assertValidProjectPath(projectPath: string): void;
+/**
+ * tests whether a path ends with {name}.inlang
+ * (does not remove trailing slash)
+ */
+export declare function isInlangProjectPath(path: string): boolean;
+/**
+ * tests whether a path starts with a forward slash (/) or a windows-style
+ * drive letter (C: or D:, etc.) followed by a slash
+ */
+export declare function isAbsolutePath(path: string): boolean;
+/**
+ * Returns true if the path exists (file or directory), false otherwise.
+ *
+ */
+export declare function pathExists(filePath: string, nodeishFs: NodeishFilesystem): Promise<boolean>;
+//# sourceMappingURL=validateProjectPath.d.ts.map

package/dist/validateProjectPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateProjectPath.d.ts","sourceRoot":"","sources":["../src/validateProjectPath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,QASzD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,WAE/C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,WAO1C;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,oBAc9E"}

package/dist/validateProjectPath.js

@@ -0,0 +1,52 @@
+/**
+ * validate that a project path is absolute and ends with {name}.inlang.
+ *
+ * @throws if the path is not valid.
+ */
+export function assertValidProjectPath(projectPath) {
+    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) {
+    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) {
+    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, nodeishFs) {
+    // 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/validateProjectPath.test.d.ts

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

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

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

package/dist/validateProjectPath.test.js

@@ -0,0 +1,56 @@
+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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.32.0",
+  "version": "0.34.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -32,16 +32,16 @@
     "murmurhash3js": "^3.0.1",
     "solid-js": "1.6.12",
     "throttle-debounce": "^5.0.0",
-    "@inlang/language-tag": "1.5.1",
     "@inlang/json-types": "1.1.0",
     "@inlang/message": "2.1.0",
-    "@inlang/message-lint-rule": "1.4.5",
-    "@inlang/module": "1.2.9",
-    "@inlang/plugin": "2.4.9",
-    "@inlang/project-settings": "2.4.0",
+    "@inlang/message-lint-rule": "1.4.6",
+    "@inlang/language-tag": "1.5.1",
+    "@inlang/module": "1.2.10",
+    "@inlang/project-settings": "2.4.1",
+    "@inlang/plugin": "2.4.10",
     "@inlang/result": "1.1.0",
     "@inlang/translatable": "1.3.1",
-    "@lix-js/client": "1.2.0",
+    "@lix-js/client": "1.3.0",
     "@lix-js/fs": "1.0.0"
   },
   "devDependencies": {

package/src/createNewProject.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest"
+import { createNewProject } from "./createNewProject.js"
+import { mockRepo } from "@lix-js/client"
+import { defaultProjectSettings } from "./defaultProjectSettings.js"
+import { loadProject } from "./loadProject.js"
+import { createMessage } from "./test-utilities/createMessage.js"
+
+function sleep(ms: number) {
+	return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+describe("createNewProject", () => {
+	it("should throw if a path does not end with .inlang", async () => {
+		const repo = await mockRepo()
+		const projectPath = "/test/project.inl"
+		try {
+			await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
+			// should not reach this point
+			throw new Error("Expected an error")
+		} catch (e) {
+			expect((e as Error).message).toMatch(
+				'Expected a path ending in "{name}.inlang" but received "/test/project.inl"'
+			)
+		}
+	})
+
+	it("should throw if projectPath is not an absolute path", async () => {
+		const repo = await mockRepo()
+		const projectPath = "test/project.inlang"
+		try {
+			await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
+			// should not reach this point
+			throw new Error("Expected an error")
+		} catch (e) {
+			expect((e as Error).message).toMatch(
+				'Expected an absolute path but received "test/project.inlang"'
+			)
+		}
+	})
+
+	it("should throw if the path already exists", async () => {
+		const repo = await mockRepo()
+		const projectPath = "/test/project.inlang"
+		await repo.nodeishFs.mkdir(projectPath, { recursive: true })
+		try {
+			await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
+			// should not reach this point
+			throw new Error("Expected an error")
+		} catch (e) {
+			expect((e as Error).message).toMatch(
+				'projectPath already exists, received "/test/project.inlang"'
+			)
+		}
+	})
+
+	it("should create default defaultProjectSettings in projectPath", async () => {
+		const repo = await mockRepo()
+		const projectPath = "/test/project.inlang"
+		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
+		const json = await repo.nodeishFs.readFile(`${projectPath}/settings.json`, {
+			encoding: "utf-8",
+		})
+		const settings = JSON.parse(json)
+		expect(settings).toEqual(defaultProjectSettings)
+	})
+
+	it("should create different projectSettings in projectPath", async () => {
+		const repo = await mockRepo()
+		const projectPath = "/test/project.inlang"
+		const projectSettings = { ...defaultProjectSettings, languageTags: ["en", "de", "fr"] }
+		await createNewProject({ projectPath, repo, projectSettings })
+		const json = await repo.nodeishFs.readFile(`${projectPath}/settings.json`, {
+			encoding: "utf-8",
+		})
+		const settings = JSON.parse(json)
+		expect(settings).toEqual(projectSettings)
+		expect(settings).not.toEqual(defaultProjectSettings)
+	})
+
+	it("should load the project after creating it", async () => {
+		const repo = await mockRepo()
+		const projectPath = "/test/project.inlang"
+		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
+
+		const project = await loadProject({ projectPath, repo })
+		expect(project.errors().length).toBe(0)
+	})
+
+	it("should create messages inside the project directory", async () => {
+		const repo = await mockRepo()
+		const projectPath = "/test/project.inlang"
+		await createNewProject({ projectPath, repo, projectSettings: defaultProjectSettings })
+		const project = await loadProject({ projectPath, repo })
+		expect(project.errors().length).toBe(0)
+
+		const testMessage = createMessage("test", { en: "test message" })
+		project.query.messages.create({ data: testMessage })
+		const messages = project.query.messages.getAll()
+		expect(messages.length).toBe(1)
+		expect(messages[0]).toEqual(testMessage)
+
+		await sleep(20)
+
+		const json = await repo.nodeishFs.readFile("/test/messages/en.json", { encoding: "utf-8" })
+		const jsonMessages = JSON.parse(json)
+		expect(jsonMessages["test"]).toEqual("test message")
+	})
+})

package/src/createNewProject.ts

@@ -0,0 +1,31 @@
+import type { Repository } from "@lix-js/client"
+import { ProjectSettings } from "@inlang/project-settings"
+import { assertValidProjectPath, pathExists } from "./validateProjectPath.js"
+import { defaultProjectSettings } from "./defaultProjectSettings.js"
+
+/**
+ * Creates a new project in the given directory.
+ * The directory must be an absolute path, must not exist, and must end with {name}.inlang
+ * Uses defaultProjectSettings unless projectSettings are provided.
+ *
+ * @param projectPath - Absolute path to the [name].inlang directory
+ * @param repo - An instance of a lix repo as returned by `openRepository`
+ * @param projectSettings - Optional project settings to use for the new project.
+ */
+export async function createNewProject(args: {
+	projectPath: string
+	repo: Repository
+	projectSettings: ProjectSettings
+}): Promise<void> {
+	assertValidProjectPath(args.projectPath)
+
+	const nodeishFs = args.repo.nodeishFs
+	if (await pathExists(args.projectPath, nodeishFs)) {
+		throw new Error(`projectPath already exists, received "${args.projectPath}"`)
+	}
+	await nodeishFs.mkdir(args.projectPath, { recursive: true })
+
+	const settingsText = JSON.stringify(args.projectSettings ?? defaultProjectSettings, undefined, 2)
+
+	await nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsText)
+}

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -1,5 +1,5 @@
 import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
-import { isAbsolutePath } from "./isAbsolutePath.js"
+import { isAbsolutePath } from "./validateProjectPath.js"
 
 /**
  * Wraps the nodeish filesystem subset with a function that intercepts paths

package/src/defaultProjectSettings.ts

@@ -0,0 +1,27 @@
+import type { ProjectSettings } from "@inlang/project-settings"
+
+/**
+ * Default project settings for createNewProject
+ * from paraglide-js/src/cli/commands/init/defaults.ts
+ */
+export const defaultProjectSettings = {
+	$schema: "https://inlang.com/schema/project-settings",
+	sourceLanguageTag: "en",
+	languageTags: ["en"],
+	modules: [
+		// for instant gratification, we're adding common rules
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-empty-pattern@latest/dist/index.js",
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-missing-translation@latest/dist/index.js",
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-without-source@latest/dist/index.js",
+		"https://cdn.jsdelivr.net/npm/@inlang/message-lint-rule-valid-js-identifier@latest/dist/index.js",
+
+		// default to the message format plugin because it supports all features
+		"https://cdn.jsdelivr.net/npm/@inlang/plugin-message-format@latest/dist/index.js",
+
+		// the m function matcher should be installed by default in case Sherlock (VS Code extension) is adopted
+		"https://cdn.jsdelivr.net/npm/@inlang/plugin-m-function-matcher@latest/dist/index.js",
+	],
+	"plugin.inlang.messageFormat": {
+		pathPattern: "./messages/{languageTag}.json",
+	},
+} satisfies ProjectSettings

package/src/index.ts

@@ -12,6 +12,8 @@ export type {
 	Subscribable,
 } from "./api.js"
 export { type ImportFunction, createImport } from "./resolve-modules/index.js"
+export { createNewProject } from "./createNewProject.js"
+export { defaultProjectSettings } from "./defaultProjectSettings.js"
 export { loadProject } from "./loadProject.js"
 export { listProjects } from "./listProjects.js"
 export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js"
@@ -24,6 +26,7 @@ export {
 	PluginSaveMessagesError,
 } from "./errors.js"
 
+export { normalizeMessage } from "./storage/helper.js"
 export * from "./messages/variant.js"
 export * from "./versionedInterfaces.js"
 export { InlangModule } from "@inlang/module"

package/src/loadProject.test.ts

@@ -11,7 +11,6 @@ import type {
 import type { ImportFunction } from "./resolve-modules/index.js"
 import type { InlangModule } from "@inlang/module"
 import {
-	LoadProjectInvalidArgument,
 	ProjectSettingsFileJSONSyntaxError,
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
@@ -175,7 +174,7 @@ it("should throw if a project (path) does not have a name", async () => {
 			_import,
 		})
 	)
-	expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument)
+	expect(project?.error?.message).toMatch('Expected a path ending in "{name}.inlang" but received ')
 })
 
 it("should throw if a project path does not end with .inlang", async () => {
@@ -195,7 +194,9 @@ it("should throw if a project path does not end with .inlang", async () => {
 				_import,
 			})
 		)
-		expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument)
+		expect(project.error?.message).toMatch(
+			'Expected a path ending in "{name}.inlang" but received '
+		)
 	}
 })
 
@@ -210,7 +211,7 @@ describe("initialization", () => {
 				_import,
 			})
 		)
-		expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument)
+		expect(result.error?.message).toBe('Expected an absolute path but received "relative/path".')
 		expect(result.data).toBeUndefined()
 	})
 

package/src/loadProject.ts

@@ -12,7 +12,6 @@ import {
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
 	PluginSaveMessagesError,
-	LoadProjectInvalidArgument,
 	PluginLoadMessagesError,
 } from "./errors.js"
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js"
@@ -23,7 +22,7 @@ import { tryCatch, type Result } from "@inlang/result"
 import { migrateIfOutdated } from "@inlang/project-settings/migration"
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
 import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
-import { isAbsolutePath } from "./isAbsolutePath.js"
+import { assertValidProjectPath } from "./validateProjectPath.js"
 import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js"
 
 import { stringifyMessage as stringifyMessage } from "./storage/helper.js"
@@ -40,7 +39,8 @@ import { identifyProject } from "./telemetry/groupIdentify.js"
 import type { NodeishStats } from "@lix-js/fs"
 
 import _debug from "debug"
-const debug = _debug("loadProject")
+const debug = _debug("sdk:loadProject")
+const debugLock = _debug("sdk:lockfile")
 
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
@@ -93,17 +93,7 @@ export async function loadProject(args: {
 	// won't even be loaded. do not throw anywhere else. otherwise, apps
 	// can't handle errors gracefully.
 
-	if (!isAbsolutePath(args.projectPath)) {
-		throw new LoadProjectInvalidArgument(
-			`Expected an absolute path but received "${args.projectPath}".`,
-			{ argument: "projectPath" }
-		)
-	} else if (/[^\\/]+\.inlang$/.test(projectPath) === false) {
-		throw new LoadProjectInvalidArgument(
-			`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`,
-			{ argument: "projectPath" }
-		)
-	}
+	assertValidProjectPath(projectPath)
 
 	const nodeishFs = createNodeishFsWithAbsolutePaths({
 		projectPath,
@@ -674,7 +664,7 @@ async function loadMessagesViaPlugin(
 
 				// NOTE could use hash instead of the whole object JSON to save memory...
 				if (messageState.messageLoadHash[loadedMessageClone.id] === importedEnecoded) {
-					debug("skipping upsert!")
+					// debug("skipping upsert!")
 					continue
 				}
 
@@ -913,10 +903,10 @@ async function acquireFileLock(
 	}
 
 	try {
-		debug(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount)
+		debugLock(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount)
 		await fs.mkdir(lockDirPath)
 		const stats = await fs.stat(lockDirPath)
-		debug(lockOrigin + " acquired a lockfile Retry Nr.: " + tryCount)
+		debugLock(lockOrigin + " acquired a lockfile Retry Nr.: " + tryCount)
 		return stats.mtimeMs
 	} catch (error: any) {
 		if (error.code !== "EEXIST") {
@@ -933,12 +923,14 @@ async function acquireFileLock(
 	} catch (fstatError: any) {
 		if (fstatError.code === "ENOENT") {
 			// lock file seems to be gone :) - lets try again
-			debug(lockOrigin + " tryCount++ lock file seems to be gone :) - lets try again " + tryCount)
+			debugLock(
+				lockOrigin + " tryCount++ lock file seems to be gone :) - lets try again " + tryCount
+			)
 			return acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1)
 		}
 		throw fstatError
 	}
-	debug(
+	debugLock(
 		lockOrigin +
 			" tries to acquire a lockfile  - lock currently in use... starting probe phase " +
 			tryCount
@@ -951,7 +943,7 @@ async function acquireFileLock(
 				probeCounts += 1
 				let lockFileStats: undefined | NodeishStats = undefined
 				try {
-					debug(
+					debugLock(
 						lockOrigin + " tries to acquire a lockfile - check if the lock is free now " + tryCount
 					)
 
@@ -959,7 +951,7 @@ async function acquireFileLock(
 					lockFileStats = await fs.stat(lockDirPath)
 				} catch (fstatError: any) {
 					if (fstatError.code === "ENOENT") {
-						debug(
+						debugLock(
 							lockOrigin +
 								" tryCount++ in Promise - tries to acquire a lockfile - lock file seems to be free now - try to acquire " +
 								tryCount
@@ -974,7 +966,7 @@ async function acquireFileLock(
 				if (lockFileStats.mtimeMs === currentLockTime) {
 					if (probeCounts >= nProbes) {
 						// ok maximum lock time ran up (we waitetd nProbes * probeInterval) - we consider the lock to be stale
-						debug(
+						debugLock(
 							lockOrigin +
 								" tries to acquire a lockfile  - lock not free - but stale lets drop it" +
 								tryCount
@@ -990,7 +982,7 @@ async function acquireFileLock(
 							return reject(rmLockError)
 						}
 						try {
-							debug(
+							debugLock(
 								lockOrigin +
 									" tryCount++ same locker - try to acquire again after removing stale lock " +
 									tryCount
@@ -1006,7 +998,9 @@ async function acquireFileLock(
 					}
 				} else {
 					try {
-						debug(lockOrigin + " tryCount++ different locker - try to acquire again " + tryCount)
+						debugLock(
+							lockOrigin + " tryCount++ different locker - try to acquire again " + tryCount
+						)
 						const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1)
 						return resolve(lock)
 					} catch (error) {
@@ -1025,7 +1019,7 @@ async function releaseLock(
 	lockOrigin: string,
 	lockTime: number
 ) {
-	debug(lockOrigin + " releasing the lock ")
+	debugLock(lockOrigin + " releasing the lock ")
 	try {
 		const stats = await fs.stat(lockDirPath)
 		if (stats.mtimeMs === lockTime) {
@@ -1033,13 +1027,13 @@ async function releaseLock(
 			await fs.rmdir(lockDirPath)
 		}
 	} catch (statError: any) {
-		debug(lockOrigin + " couldn't release the lock")
+		debugLock(lockOrigin + " couldn't release the lock")
 		if (statError.code === "ENOENT") {
 			// ok seeks like the log was released by someone else
-			debug(lockOrigin + " WARNING - the lock was released by a different process")
+			debugLock(lockOrigin + " WARNING - the lock was released by a different process")
 			return
 		}
-		debug(statError)
+		debugLock(statError)
 		throw statError
 	}
 }

package/src/migrations/maybeCreateFirstProjectId.test.ts

@@ -1,7 +1,6 @@
 import { generateProjectId } from "./maybeCreateFirstProjectId.js"
 import { it, expect } from "vitest"
-import { openRepository } from "@lix-js/client/src/openRepository.ts"
-import { mockRepo, createNodeishMemoryFs } from "@lix-js/client"
+import { mockRepo } from "@lix-js/client"
 import { type Snapshot } from "@lix-js/fs"
 // eslint-disable-next-line no-restricted-imports -- test
 import { readFileSync } from "node:fs"
@@ -22,12 +21,10 @@ it("should generate a project id", async () => {
 })
 
 it("should return undefined if repoMeta contains error", async () => {
-	const repoWithError = await openRepository("https://github.com/inlang/no-exist", {
-		nodeishFs: createNodeishMemoryFs(),
-	})
+	await repo.nodeishFs.rm("/.git", { recursive: true })
 
 	const projectId = await generateProjectId({
-		repo: repoWithError,
+		repo: repo,
 		projectPath: "mocked_project_path",
 	})
 	expect(projectId).toBeUndefined()

package/src/storage/helper.ts

@@ -22,27 +22,53 @@ export function getPathFromMessageId(id: string) {
 	return path
 }
 
-export function stringifyMessage(message: Message) {
-	// create a new object do specify key output order
+/**
+ * Returns a copy of a message object with sorted variants and object keys.
+ * This produces a deterministic result when passed to stringify
+ * independent of the initialization order.
+ */
+export function normalizeMessage(message: Message) {
+	// order keys in message
 	const messageWithSortedKeys: any = {}
 	for (const key of Object.keys(message).sort()) {
 		messageWithSortedKeys[key] = (message as any)[key]
 	}
 
-	// lets order variants as well
-	messageWithSortedKeys["variants"] = messageWithSortedKeys["variants"].sort(
-		(variantA: Variant, variantB: Variant) => {
-			// First, compare by language
+	// order variants
+	messageWithSortedKeys["variants"] = messageWithSortedKeys["variants"]
+		.sort((variantA: Variant, variantB: Variant) => {
+			// compare by language
 			const languageComparison = variantA.languageTag.localeCompare(variantB.languageTag)
 
-			// If languages are the same, compare by match
+			// if languages are the same, compare by match
 			if (languageComparison === 0) {
 				return variantA.match.join("-").localeCompare(variantB.match.join("-"))
 			}
 
 			return languageComparison
-		}
-	)
+		})
+		// order keys in each variant
+		.map((variant: Variant) => {
+			const variantWithSortedKeys: any = {}
+			for (const variantKey of Object.keys(variant).sort()) {
+				if (variantKey === "pattern") {
+					variantWithSortedKeys[variantKey] = (variant as any)["pattern"].map((token: any) => {
+						const tokenWithSortedKey: any = {}
+						for (const tokenKey of Object.keys(token).sort()) {
+							tokenWithSortedKey[tokenKey] = token[tokenKey]
+						}
+						return tokenWithSortedKey
+					})
+				} else {
+					variantWithSortedKeys[variantKey] = (variant as any)[variantKey]
+				}
+			}
+			return variantWithSortedKeys
+		})
 
-	return JSON.stringify(messageWithSortedKeys, undefined, 4)
+	return messageWithSortedKeys as Message
+}
+
+export function stringifyMessage(message: Message) {
+	return JSON.stringify(normalizeMessage(message), undefined, 4)
 }