@inlang/sdk 0.32.0 → 0.34.0

package/dist/createNewProject.d.ts

@@ -0,0 +1,17 @@
+import type { Repository } from "@lix-js/client";
+import { ProjectSettings } from "@inlang/project-settings";
+/**
+ * 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 declare function createNewProject(args: {
+    projectPath: string;
+    repo: Repository;
+    projectSettings: ProjectSettings;
+}): Promise<void>;
+//# sourceMappingURL=createNewProject.d.ts.map

package/dist/createNewProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createNewProject.d.ts","sourceRoot":"","sources":["../src/createNewProject.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAI1D;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,eAAe,EAAE,eAAe,CAAA;CAChC,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhB"}

package/dist/createNewProject.js

@@ -0,0 +1,22 @@
+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) {
+    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/dist/createNewProject.test.d.ts

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

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

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

package/dist/createNewProject.test.js

@@ -0,0 +1,93 @@
+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) {
+    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.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.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.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/dist/createNodeishFsWithAbsolutePaths.js

@@ -1,5 +1,5 @@
 import { normalizePath } 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
  * and prepends the base path.

package/dist/defaultProjectSettings.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Default project settings for createNewProject
+ * from paraglide-js/src/cli/commands/init/defaults.ts
+ */
+export declare const defaultProjectSettings: {
+    $schema: "https://inlang.com/schema/project-settings";
+    sourceLanguageTag: string;
+    languageTags: string[];
+    modules: string[];
+    "plugin.inlang.messageFormat": {
+        pathPattern: string;
+    };
+};
+//# sourceMappingURL=defaultProjectSettings.d.ts.map

package/dist/defaultProjectSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultProjectSettings.d.ts","sourceRoot":"","sources":["../src/defaultProjectSettings.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;CAoBR,CAAA"}

package/dist/defaultProjectSettings.js

@@ -0,0 +1,23 @@
+/**
+ * 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",
+    },
+};

package/dist/index.d.ts

@@ -5,11 +5,14 @@
  */
 export type { InlangProject, InstalledMessageLintRule, InstalledPlugin, MessageQueryApi, 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";
 export { createMessagesQuery } from "./createMessagesQuery.js";
 export { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, 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/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,YAAY,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,KAAK,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EACN,kCAAkC,EAClC,gCAAgC,EAChC,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,GACvB,MAAM,aAAa,CAAA;AAEpB,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACX,aAAa,EACb,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,YAAY,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAA;AACpE,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,KAAK,6BAA6B,EAAE,MAAM,2BAA2B,CAAA;AAC5F,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC9D,OAAO,EACN,kCAAkC,EAClC,gCAAgC,EAChC,2BAA2B,EAC3B,uBAAuB,EACvB,uBAAuB,GACvB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACtD,cAAc,uBAAuB,CAAA;AACrC,cAAc,0BAA0B,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -4,11 +4,14 @@
  *! EXPORT AS LITTLE AS POSSIBLE TO MINIMIZE THE CHANCE OF BREAKING CHANGES.
  */
 export { 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 } from "./adapter/solidAdapter.js";
 export { createMessagesQuery } from "./createMessagesQuery.js";
 export { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, 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/dist/loadProject.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAyBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAgChD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CAqYzB;AAsHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}
+{"version":3,"file":"loadProject.d.ts","sourceRoot":"","sources":["../src/loadProject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EAGb,YAAY,EACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,cAAc,EAAkB,MAAM,4BAA4B,CAAA;AAwBhF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAiChD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAAC,IAAI,EAAE;IACvC,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,EAAE,UAAU,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,cAAc,CAAA;CACxB,GAAG,OAAO,CAAC,aAAa,CAAC,CA2XzB;AAsHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -1,6 +1,6 @@
 import { resolveModules } from "./resolve-modules/index.js";
 import { TypeCompiler, ValueErrorType } from "@sinclair/typebox/compiler";
-import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginSaveMessagesError, LoadProjectInvalidArgument, PluginLoadMessagesError, } from "./errors.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginSaveMessagesError, PluginLoadMessagesError, } from "./errors.js";
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
 import { createMessagesQuery } from "./createMessagesQuery.js";
 import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js";
@@ -9,7 +9,7 @@ import { tryCatch } from "@inlang/result";
 import { migrateIfOutdated } from "@inlang/project-settings/migration";
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js";
 import { normalizePath } 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";
 import { humanIdHash } from "./storage/human-id/human-readable-id.js";
@@ -18,7 +18,8 @@ import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectI
 import { capture } from "./telemetry/capture.js";
 import { identifyProject } from "./telemetry/groupIdentify.js";
 import _debug from "debug";
-const debug = _debug("loadProject");
+const debug = _debug("sdk:loadProject");
+const debugLock = _debug("sdk:lockfile");
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * @param projectPath - Absolute path to the inlang settings file.
@@ -43,12 +44,7 @@ export async function loadProject(args) {
     // the only place where throwing is acceptable because the project
     // 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,
         nodeishFs: args.repo.nodeishFs,
@@ -454,7 +450,7 @@ async function loadMessagesViaPlugin(fs, lockDirPath, messageState, messagesQuer
                 const importedEnecoded = stringifyMessage(loadedMessageClone);
                 // 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;
                 }
                 // This logic is preventing cycles - could also be handled if update api had a parameter for who triggered update
@@ -635,10 +631,10 @@ async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
         throw new Error(lockOrigin + " exceeded maximum Retries (5) to acquire lockfile " + tryCount);
     }
     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) {
@@ -655,12 +651,12 @@ async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
     catch (fstatError) {
         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(lockOrigin +
+    debugLock(lockOrigin +
         " tries to acquire a lockfile  - lock currently in use... starting probe phase " +
         tryCount);
     return new Promise((resolve, reject) => {
@@ -670,13 +666,13 @@ async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
                 probeCounts += 1;
                 let lockFileStats = undefined;
                 try {
-                    debug(lockOrigin + " tries to acquire a lockfile - check if the lock is free now " + tryCount);
+                    debugLock(lockOrigin + " tries to acquire a lockfile - check if the lock is free now " + tryCount);
                     // alright lets give it another try
                     lockFileStats = await fs.stat(lockDirPath);
                 }
                 catch (fstatError) {
                     if (fstatError.code === "ENOENT") {
-                        debug(lockOrigin +
+                        debugLock(lockOrigin +
                             " tryCount++ in Promise - tries to acquire a lockfile - lock file seems to be free now - try to acquire " +
                             tryCount);
                         const lock = acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
@@ -688,7 +684,7 @@ async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
                 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(lockOrigin +
+                        debugLock(lockOrigin +
                             " tries to acquire a lockfile  - lock not free - but stale lets drop it" +
                             tryCount);
                         try {
@@ -703,7 +699,7 @@ async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
                             return reject(rmLockError);
                         }
                         try {
-                            debug(lockOrigin +
+                            debugLock(lockOrigin +
                                 " tryCount++ same locker - try to acquire again after removing stale lock " +
                                 tryCount);
                             const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1);
@@ -720,7 +716,7 @@ async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
                 }
                 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);
                     }
@@ -734,7 +730,7 @@ async function acquireFileLock(fs, lockDirPath, lockOrigin, tryCount = 0) {
     });
 }
 async function releaseLock(fs, lockDirPath, lockOrigin, lockTime) {
-    debug(lockOrigin + " releasing the lock ");
+    debugLock(lockOrigin + " releasing the lock ");
     try {
         const stats = await fs.stat(lockDirPath);
         if (stats.mtimeMs === lockTime) {
@@ -743,13 +739,13 @@ async function releaseLock(fs, lockDirPath, lockOrigin, lockTime) {
         }
     }
     catch (statError) {
-        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/dist/loadProject.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect, vi } from "vitest";
 import { loadProject } from "./loadProject.js";
-import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
 import { normalizePath } from "@lix-js/fs";
 import { createMessage } from "./test-utilities/createMessage.js";
 import { tryCatch } from "@inlang/result";
@@ -144,7 +144,7 @@ it("should throw if a project (path) does not have a name", async () => {
         repo,
         _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 () => {
     const repo = await mockRepo();
@@ -159,7 +159,7 @@ it("should throw if a project path does not end with .inlang", async () => {
             repo,
             _import,
         }));
-        expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
+        expect(project.error?.message).toMatch('Expected a path ending in "{name}.inlang" but received ');
     }
 });
 describe("initialization", () => {
@@ -170,7 +170,7 @@ describe("initialization", () => {
             repo,
             _import,
         }));
-        expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
+        expect(result.error?.message).toBe('Expected an absolute path but received "relative/path".');
         expect(result.data).toBeUndefined();
     });
     it("should generate projectId on missing projectid", async () => {

package/dist/migrations/maybeCreateFirstProjectId.test.js

@@ -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 {} from "@lix-js/fs";
 // eslint-disable-next-line no-restricted-imports -- test
 import { readFileSync } from "node:fs";
@@ -16,11 +15,9 @@ it("should generate a project id", async () => {
     expect(projectId).toBe("432d7ef29c510e99d95e2d14ef57a0797a1603859b5a851b7dff7e77161b8c08");
 });
 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/dist/storage/helper.d.ts

@@ -1,5 +1,29 @@
 import { Message } from "../versionedInterfaces.js";
 export declare function getMessageIdFromPath(path: string): string | undefined;
 export declare function getPathFromMessageId(id: string): string;
+/**
+ * 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 declare function normalizeMessage(message: Message): {
+    id: string;
+    alias: Record<string, string>;
+    selectors: {
+        type: "VariableReference";
+        name: string;
+    }[];
+    variants: {
+        languageTag: string;
+        match: string[];
+        pattern: ({
+            type: "Text";
+            value: string;
+        } | {
+            type: "VariableReference";
+            name: string;
+        })[];
+    }[];
+};
 export declare function stringifyMessage(message: Message): string;
 //# sourceMappingURL=helper.d.ts.map

package/dist/storage/helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/storage/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAW,MAAM,2BAA2B,CAAA;AAI5D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,sBAahD;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,UAG9C;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,UAuBhD"}
+{"version":3,"file":"helper.d.ts","sourceRoot":"","sources":["../../src/storage/helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAW,MAAM,2BAA2B,CAAA;AAI5D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,sBAahD;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,UAG9C;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO;;;;;;;;;;;;;;;;;;EAwChD;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,UAEhD"}

package/dist/storage/helper.js

@@ -15,21 +15,49 @@ export function getPathFromMessageId(id) {
     const path = id.replace("_", "/") + fileExtension;
     return path;
 }
-export function stringifyMessage(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) {
+    // order keys in message
     const messageWithSortedKeys = {};
     for (const key of Object.keys(message).sort()) {
         messageWithSortedKeys[key] = message[key];
     }
-    // lets order variants as well
-    messageWithSortedKeys["variants"] = messageWithSortedKeys["variants"].sort((variantA, variantB) => {
-        // First, compare by language
+    // order variants
+    messageWithSortedKeys["variants"] = messageWithSortedKeys["variants"]
+        .sort((variantA, variantB) => {
+        // 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) => {
+        const variantWithSortedKeys = {};
+        for (const variantKey of Object.keys(variant).sort()) {
+            if (variantKey === "pattern") {
+                variantWithSortedKeys[variantKey] = variant["pattern"].map((token) => {
+                    const tokenWithSortedKey = {};
+                    for (const tokenKey of Object.keys(token).sort()) {
+                        tokenWithSortedKey[tokenKey] = token[tokenKey];
+                    }
+                    return tokenWithSortedKey;
+                });
+            }
+            else {
+                variantWithSortedKeys[variantKey] = variant[variantKey];
+            }
+        }
+        return variantWithSortedKeys;
     });
-    return JSON.stringify(messageWithSortedKeys, undefined, 4);
+    return messageWithSortedKeys;
+}
+export function stringifyMessage(message) {
+    return JSON.stringify(normalizeMessage(message), undefined, 4);
 }

package/dist/storage/helpers.test.d.ts

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

package/dist/storage/helpers.test.d.ts.map

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

package/dist/storage/helpers.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from "vitest";
+// import { parseLixUri, parseOrigin } from "./helpers.js"
+import { normalizeMessage, stringifyMessage } from "./helper.js";
+const unsortedMessageRaw = {
+    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 = {
+    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) {
+    return JSON.stringify(obj);
+}
+// stringify with 2 space indentation
+function str2(obj) {
+    return JSON.stringify(obj, undefined, 2);
+}
+// stringify with 4 space indentation
+function str4(obj) {
+    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));
+    });
+});