@inlang/sdk 0.23.0 → 0.24.1

package/dist/adapter/solidAdapter.test.js

@@ -4,6 +4,7 @@ import { createEffect, from, createRoot } from "../reactivity/solid.js";
 import { solidAdapter } from "./solidAdapter.js";
 import { loadProject } from "../loadProject.js";
 import { createNodeishMemoryFs } from "@lix-js/fs";
+import { openRepository } from "@lix-js/client";
 // ------------------------------------------------------------------------------------------------
 const config = {
     sourceLanguageTag: "en",
@@ -74,9 +75,10 @@ describe("config", () => {
         const fs = createNodeishMemoryFs();
         await fs.mkdir("/user/project.inlang", { recursive: true });
         await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config));
+        const repo = await openRepository("file://", { nodeishFs: fs });
         const project = solidAdapter(await loadProject({
             projectPath: "/user/project.inlang",
-            nodeishFs: fs,
+            repo,
             _import: $import,
         }), { from });
         let counter = 0;
@@ -98,9 +100,10 @@ describe("installed", () => {
         const fs = createNodeishMemoryFs();
         await fs.mkdir("/user/project.inlang", { recursive: true });
         await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config));
+        const repo = await openRepository("file://", { nodeishFs: fs });
         const project = solidAdapter(await loadProject({
             projectPath: "/user/project.inlang",
-            nodeishFs: fs,
+            repo,
             _import: $import,
         }), { from });
         let counterPlugins = 0;
@@ -151,9 +154,10 @@ describe("messages", () => {
         const mockImport = async () => ({ default: mockPlugin });
         await fs.mkdir("/user/project.inlang.inlang", { recursive: true });
         await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(mockConfig));
+        const repo = await openRepository("file://", { nodeishFs: fs });
         const project = solidAdapter(await loadProject({
             projectPath: "/user/project.inlang.inlang",
-            nodeishFs: fs,
+            repo,
             _import: mockImport,
         }), { from });
         let counter = 0;
@@ -172,9 +176,10 @@ describe("messages", () => {
         const fs = createNodeishMemoryFs();
         await fs.mkdir("/user/project.inlang.inlang", { recursive: true });
         await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(config));
+        const repo = await openRepository("file://", { nodeishFs: fs });
         const project = solidAdapter(await loadProject({
             projectPath: "/user/project.inlang.inlang",
-            nodeishFs: fs,
+            repo,
             _import: $import,
         }), { from });
         let counter = 0;
@@ -218,9 +223,10 @@ describe("lint", () => {
             const fs = createNodeishMemoryFs();
             await fs.mkdir("./project.inlang", { recursive: true });
             await fs.writeFile("./project.inlang/settings.json", JSON.stringify(config));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = solidAdapter(await loadProject({
                 projectPath: "./project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import: $import,
             }), { from });
             let counter = 0;
@@ -245,9 +251,10 @@ describe("lint", () => {
         await createRoot(async () => {
             const fs = createNodeishMemoryFs();
             await fs.writeFile("./project.config.json", JSON.stringify(config));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = solidAdapter(await loadProject({
                 projectPath: "./project.config.json",
-                nodeishFs: fs,
+                repo,
                 _import: $import,
             }), { from });
             let counter = 0;

package/dist/loadProject.test.js

@@ -5,10 +5,12 @@ import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, Project
 import { createNodeishMemoryFs, normalizePath } from "@lix-js/fs";
 import { createMessage } from "./test-utilities/createMessage.js";
 import { tryCatch } from "@inlang/result";
-import { mockRepo } from "@lix-js/client";
+import { mockRepo, openRepository } from "@lix-js/client";
 import {} from "@lix-js/fs";
 // eslint-disable-next-line no-restricted-imports -- test
 import { readFileSync } from "node:fs";
+// eslint-disable-next-line no-restricted-imports -- test
+import { resolve } from "node:path";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
     let value;
@@ -83,6 +85,13 @@ const mockMessageLintRule = {
 const _import = async (name) => ({
     default: name === "plugin.js" ? mockPlugin : mockMessageLintRule,
 });
+async function openCiTestRepo() {
+    return await mockRepo({
+        fromSnapshot: JSON.parse(readFileSync(resolve(__dirname, "../mocks/ci-test-repo-no-shallow.json"), {
+            encoding: "utf-8",
+        })),
+    });
+}
 // ------------------------------------------------------------------------------------------------
 /**
  * Dear Developers,
@@ -92,15 +101,17 @@ const _import = async (name) => ({
  */
 it("should throw if a project (path) does not have a name", async () => {
     const fs = createNodeishMemoryFs();
+    const repo = await openRepository("file://", { nodeishFs: fs });
     const project = await tryCatch(() => loadProject({
         projectPath: "/source-code/.inlang",
-        nodeishFs: fs,
+        repo,
         _import,
     }));
     expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
 });
 it("should throw if a project path does not end with .inlang", async () => {
     const fs = createNodeishMemoryFs();
+    const repo = await openRepository("file://", { nodeishFs: fs });
     const invalidPaths = [
         "/source-code/frontend.inlang/settings",
         "/source-code/frontend.inlang/settings.json",
@@ -109,7 +120,7 @@ it("should throw if a project path does not end with .inlang", async () => {
     for (const invalidPath of invalidPaths) {
         const project = await tryCatch(() => loadProject({
             projectPath: invalidPath,
-            nodeishFs: fs,
+            repo,
             _import,
         }));
         expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
@@ -118,17 +129,17 @@ it("should throw if a project path does not end with .inlang", async () => {
 describe("initialization", () => {
     it("should throw if projectPath is not an absolute path", async () => {
         const fs = createNodeishMemoryFs();
+        const repo = await openRepository("file://", { nodeishFs: fs });
         const result = await tryCatch(() => loadProject({
             projectPath: "relative/path",
-            nodeishFs: fs,
+            repo,
             _import,
         }));
         expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
         expect(result.data).toBeUndefined();
     });
     it("should generate projectId on missing projectid", async () => {
-        const ciTestRepo = JSON.parse(readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" }));
-        const repo = await mockRepo({ fromSnapshot: ciTestRepo });
+        const repo = await openCiTestRepo();
         const existing = await repo.nodeishFs
             .readFile("/project.inlang/project_id", {
             encoding: "utf-8",
@@ -150,13 +161,12 @@ describe("initialization", () => {
             .catch((error) => {
             return { error };
         });
-        expect(newId).toBe("e8c61726bc2f437ec6a260abb632b3c59195059b60031e648b5afbafa7f3d79a");
+        expect(newId).toBe("aef225403be8b526dfb492a4617fd59d8181e8fef2c7f4aff56ab299046e36ed");
         expect(result.error).toBeUndefined();
         expect(result.data).toBeDefined();
     });
     it("should reuse projectId on existing projectid", async () => {
-        const ciTestRepo = JSON.parse(readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" }));
-        const repo = await mockRepo({ fromSnapshot: ciTestRepo });
+        const repo = await openCiTestRepo();
         repo.nodeishFs.writeFile("/project.inlang/project_id", "testId");
         const result = await tryCatch(() => loadProject({
             projectPath: "/project.inlang",
@@ -178,9 +188,10 @@ describe("initialization", () => {
         const fs = createNodeishMemoryFs();
         fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true });
         fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings));
+        const repo = await openRepository("file://", { nodeishFs: fs });
         const result = await tryCatch(() => loadProject({
             projectPath: "C:\\Users\\user\\project.inlang",
-            nodeishFs: fs,
+            repo,
             _import,
         }));
         expect(result.error).toBeUndefined();
@@ -190,9 +201,10 @@ describe("initialization", () => {
         it("should return an error if settings file is not found", async () => {
             const fs = createNodeishMemoryFs();
             fs.mkdir("/user/project", { recursive: true });
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/non-existend-project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileNotFoundError);
@@ -201,9 +213,10 @@ describe("initialization", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", "invalid json");
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileJSONSyntaxError);
@@ -212,9 +225,10 @@ describe("initialization", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({}));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsInvalidError);
@@ -223,9 +237,10 @@ describe("initialization", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.settings()).toStrictEqual(settings);
@@ -235,9 +250,10 @@ describe("initialization", () => {
             const settingsWithDeifferentFormatting = JSON.stringify(settings, undefined, 4);
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", settingsWithDeifferentFormatting);
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             const settingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
@@ -261,9 +277,10 @@ describe("initialization", () => {
             const fs = createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import: $badImport,
             });
             expect(project.errors()).not.toHaveLength(0);
@@ -289,9 +306,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(getValue(project.settings)).toStrictEqual(settings);
@@ -300,9 +318,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.settings()).toStrictEqual(settings);
@@ -322,9 +341,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             const result = project.setSettings({});
@@ -340,9 +360,10 @@ describe("functionality", () => {
                 modules: [],
             };
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()).toHaveLength(1);
@@ -352,9 +373,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             const before = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" });
@@ -379,9 +401,10 @@ describe("functionality", () => {
             };
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.installed.plugins()[0]).toStrictEqual({
@@ -407,9 +430,10 @@ describe("functionality", () => {
             };
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.installed.messageLintRules()[0]?.level).toBe("warning");
@@ -442,6 +466,7 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             }));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const _import = async (name) => {
                 return {
                     default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
@@ -449,7 +474,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             await new Promise((resolve) => setTimeout(resolve, 510));
@@ -484,6 +509,7 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             }));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const _import = async (name) => {
                 return {
                     default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
@@ -491,7 +517,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             await new Promise((resolve) => setTimeout(resolve, 510));
@@ -503,9 +529,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             project.errors.subscribe((errors) => {
@@ -518,9 +545,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             project.customApi.subscribe((api) => {
@@ -533,9 +561,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(Object.values(project.query.messages.getAll())).toEqual(exampleMessages);
@@ -555,6 +584,7 @@ describe("functionality", () => {
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             await fs.mkdir("./resources");
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
                 id: "plugin.project.json",
@@ -570,7 +600,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             await project.query.messages.upsert({
@@ -716,6 +746,7 @@ describe("functionality", () => {
             };
             await fs.mkdir("./project.inlang", { recursive: true });
             await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
                 id: "plugin.placeholder.name",
@@ -735,7 +766,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             project.query.messages.create({ data: createMessage("fourth", { en: "fourth message" }) });
@@ -749,9 +780,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             await fs.mkdir("/user/project", { recursive: true });
             await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project/project.inlang.json",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             // TODO: test with real lint rules
@@ -772,9 +804,10 @@ describe("functionality", () => {
             const fs = createNodeishMemoryFs();
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import: async () => ({
                     default: mockMessageLintRule,
                 }),
@@ -829,10 +862,11 @@ describe("functionality", () => {
             };
             await fs.mkdir("./project.inlang", { recursive: true });
             await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             // establish watcher
             const project = await loadProject({
                 projectPath: normalizePath("/project.inlang"),
-                nodeishFs: fs,
+                repo,
                 _import: async () => ({
                     default: mockMessageFormatPlugin,
                 }),

package/dist/migrations/maybeCreateFirstProjectId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"maybeCreateFirstProjectId.d.ts","sourceRoot":"","sources":["../../src/migrations/maybeCreateFirstProjectId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACrD,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,UAAU,CAAA;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,+BAWvF"}
+{"version":3,"file":"maybeCreateFirstProjectId.d.ts","sourceRoot":"","sources":["../../src/migrations/maybeCreateFirstProjectId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACrD,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,UAAU,CAAA;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,+BAUvF"}

package/dist/migrations/maybeCreateFirstProjectId.js

@@ -30,9 +30,8 @@ export async function generateProjectId(args) {
         return undefined;
     }
     const firstCommitHash = await args.repo.getFirstCommitHash();
-    const originHash = await args.repo.getOrigin({ safeHashOnly: true });
     if (firstCommitHash) {
-        return hash(`${firstCommitHash + args.projectPath + originHash}`);
+        return hash(`${firstCommitHash + args.projectPath}`);
     }
     return undefined;
 }

package/dist/migrations/maybeCreateFirstProjectId.test.js

@@ -13,7 +13,7 @@ it("should return if repo is undefined", async () => {
 });
 it("should generate a project id", async () => {
     const projectId = await generateProjectId({ repo, projectPath: "mocked_project_path" });
-    expect(projectId).toBe("959bcf0a30e678c9b90a3c76d1a281d085eab55f289c5439b6b10849baa1920c");
+    expect(projectId).toBe("432d7ef29c510e99d95e2d14ef57a0797a1603859b5a851b7dff7e77161b8c08");
 });
 it("should return undefined if repoMeta contains error", async () => {
     const repoWithError = await openRepository("https://github.com/inlang/no-exist", {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.23.0",
+  "version": "0.24.1",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -27,15 +27,15 @@
     "throttle-debounce": "^5.0.0",
     "@inlang/json-types": "1.1.0",
     "@inlang/language-tag": "1.4.0",
-    "@inlang/message": "2.0.1",
     "@inlang/message-lint-rule": "1.4.1",
-    "@inlang/module": "1.2.2",
-    "@inlang/plugin": "2.4.2",
+    "@inlang/module": "1.2.3",
+    "@inlang/plugin": "2.4.3",
+    "@inlang/result": "1.1.0",
     "@inlang/project-settings": "2.2.1",
-    "@inlang/translatable": "1.2.1",
-    "@lix-js/fs": "0.5.0",
-    "@lix-js/client": "0.5.0",
-    "@inlang/result": "1.1.0"
+    "@inlang/message": "2.0.1",
+    "@lix-js/fs": "0.6.0",
+    "@lix-js/client": "0.7.0",
+    "@inlang/translatable": "1.2.1"
   },
   "devDependencies": {
     "@types/throttle-debounce": "5.0.0",

package/src/adapter/solidAdapter.test.ts

@@ -5,6 +5,7 @@ import { createEffect, from, createRoot } from "../reactivity/solid.js"
 import { solidAdapter } from "./solidAdapter.js"
 import { loadProject } from "../loadProject.js"
 import { createNodeishMemoryFs } from "@lix-js/fs"
+import { openRepository } from "@lix-js/client"
 import type {
 	Message,
 	ProjectSettings,
@@ -92,10 +93,11 @@ describe("config", () => {
 		const fs = createNodeishMemoryFs()
 		await fs.mkdir("/user/project.inlang", { recursive: true })
 		await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
+		const repo = await openRepository("file://", { nodeishFs: fs })
 		const project = solidAdapter(
 			await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import: $import,
 			}),
 			{ from }
@@ -125,10 +127,11 @@ describe("installed", () => {
 		const fs = createNodeishMemoryFs()
 		await fs.mkdir("/user/project.inlang", { recursive: true })
 		await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
+		const repo = await openRepository("file://", { nodeishFs: fs })
 		const project = solidAdapter(
 			await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import: $import,
 			}),
 			{ from }
@@ -190,10 +193,11 @@ describe("messages", () => {
 
 		await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
 		await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(mockConfig))
+		const repo = await openRepository("file://", { nodeishFs: fs })
 		const project = solidAdapter(
 			await loadProject({
 				projectPath: "/user/project.inlang.inlang",
-				nodeishFs: fs,
+				repo,
 				_import: mockImport,
 			}),
 			{ from }
@@ -220,10 +224,11 @@ describe("messages", () => {
 		const fs = createNodeishMemoryFs()
 		await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
 		await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(config))
+		const repo = await openRepository("file://", { nodeishFs: fs })
 		const project = solidAdapter(
 			await loadProject({
 				projectPath: "/user/project.inlang.inlang",
-				nodeishFs: fs,
+				repo,
 				_import: $import,
 			}),
 			{ from }
@@ -282,10 +287,11 @@ describe("lint", () => {
 			const fs = createNodeishMemoryFs()
 			await fs.mkdir("./project.inlang", { recursive: true })
 			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(config))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = solidAdapter(
 				await loadProject({
 					projectPath: "./project.inlang",
-					nodeishFs: fs,
+					repo,
 					_import: $import,
 				}),
 				{ from }
@@ -320,10 +326,11 @@ describe("lint", () => {
 		await createRoot(async () => {
 			const fs = createNodeishMemoryFs()
 			await fs.writeFile("./project.config.json", JSON.stringify(config))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = solidAdapter(
 				await loadProject({
 					projectPath: "./project.config.json",
-					nodeishFs: fs,
+					repo,
 					_import: $import,
 				}),
 				{ from }

package/src/loadProject.test.ts

@@ -19,10 +19,12 @@ import {
 import { createNodeishMemoryFs, normalizePath } from "@lix-js/fs"
 import { createMessage } from "./test-utilities/createMessage.js"
 import { tryCatch } from "@inlang/result"
-import { mockRepo } from "@lix-js/client"
+import { mockRepo, openRepository } from "@lix-js/client"
 import { type Snapshot } from "@lix-js/fs"
 // eslint-disable-next-line no-restricted-imports -- test
 import { readFileSync } from "node:fs"
+// eslint-disable-next-line no-restricted-imports -- test
+import { resolve } from "node:path"
 
 // ------------------------------------------------------------------------------------------------
 
@@ -107,6 +109,16 @@ const _import: ImportFunction = async (name) =>
 		default: name === "plugin.js" ? mockPlugin : mockMessageLintRule,
 	} satisfies InlangModule)
 
+async function openCiTestRepo() {
+	return await mockRepo({
+		fromSnapshot: JSON.parse(
+			readFileSync(resolve(__dirname, "../mocks/ci-test-repo-no-shallow.json"), {
+				encoding: "utf-8",
+			})
+		) as Snapshot,
+	})
+}
+
 // ------------------------------------------------------------------------------------------------
 
 /**
@@ -117,10 +129,11 @@ const _import: ImportFunction = async (name) =>
  */
 it("should throw if a project (path) does not have a name", async () => {
 	const fs = createNodeishMemoryFs()
+	const repo = await openRepository("file://", { nodeishFs: fs })
 	const project = await tryCatch(() =>
 		loadProject({
 			projectPath: "/source-code/.inlang",
-			nodeishFs: fs,
+			repo,
 			_import,
 		})
 	)
@@ -129,6 +142,7 @@ it("should throw if a project (path) does not have a name", async () => {
 
 it("should throw if a project path does not end with .inlang", async () => {
 	const fs = createNodeishMemoryFs()
+	const repo = await openRepository("file://", { nodeishFs: fs })
 
 	const invalidPaths = [
 		"/source-code/frontend.inlang/settings",
@@ -140,7 +154,7 @@ it("should throw if a project path does not end with .inlang", async () => {
 		const project = await tryCatch(() =>
 			loadProject({
 				projectPath: invalidPath,
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 		)
@@ -151,11 +165,12 @@ it("should throw if a project path does not end with .inlang", async () => {
 describe("initialization", () => {
 	it("should throw if projectPath is not an absolute path", async () => {
 		const fs = createNodeishMemoryFs()
+		const repo = await openRepository("file://", { nodeishFs: fs })
 
 		const result = await tryCatch(() =>
 			loadProject({
 				projectPath: "relative/path",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 		)
@@ -164,10 +179,7 @@ describe("initialization", () => {
 	})
 
 	it("should generate projectId on missing projectid", async () => {
-		const ciTestRepo: Snapshot = JSON.parse(
-			readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" })
-		)
-		const repo = await mockRepo({ fromSnapshot: ciTestRepo })
+		const repo = await openCiTestRepo()
 
 		const existing = await repo.nodeishFs
 			.readFile("/project.inlang/project_id", {
@@ -196,17 +208,14 @@ describe("initialization", () => {
 				return { error }
 			})
 
-		expect(newId).toBe("e8c61726bc2f437ec6a260abb632b3c59195059b60031e648b5afbafa7f3d79a")
+		expect(newId).toBe("aef225403be8b526dfb492a4617fd59d8181e8fef2c7f4aff56ab299046e36ed")
 
 		expect(result.error).toBeUndefined()
 		expect(result.data).toBeDefined()
 	})
 
 	it("should reuse projectId on existing projectid", async () => {
-		const ciTestRepo: Snapshot = JSON.parse(
-			readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" })
-		)
-		const repo = await mockRepo({ fromSnapshot: ciTestRepo })
+		const repo = await openCiTestRepo()
 
 		repo.nodeishFs.writeFile("/project.inlang/project_id", "testId")
 
@@ -236,11 +245,12 @@ describe("initialization", () => {
 		const fs = createNodeishMemoryFs()
 		fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true })
 		fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings))
+		const repo = await openRepository("file://", { nodeishFs: fs })
 
 		const result = await tryCatch(() =>
 			loadProject({
 				projectPath: "C:\\Users\\user\\project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 		)
@@ -253,10 +263,11 @@ describe("initialization", () => {
 		it("should return an error if settings file is not found", async () => {
 			const fs = createNodeishMemoryFs()
 			fs.mkdir("/user/project", { recursive: true })
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/non-existend-project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -267,10 +278,11 @@ describe("initialization", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", "invalid json")
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -281,10 +293,11 @@ describe("initialization", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({}))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -295,9 +308,10 @@ describe("initialization", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -309,10 +323,11 @@ describe("initialization", () => {
 			const settingsWithDeifferentFormatting = JSON.stringify(settings, undefined, 4)
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", settingsWithDeifferentFormatting)
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -342,10 +357,11 @@ describe("initialization", () => {
 			const fs = createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import: $badImport,
 			})
 
@@ -375,9 +391,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -388,9 +405,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -414,9 +432,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -436,10 +455,11 @@ describe("functionality", () => {
 			}
 
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -451,9 +471,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -483,9 +504,10 @@ describe("functionality", () => {
 			}
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -516,10 +538,11 @@ describe("functionality", () => {
 
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -558,6 +581,7 @@ describe("functionality", () => {
 					modules: ["plugin.js", "lintRule.js"],
 				} satisfies ProjectSettings)
 			)
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const _import: ImportFunction = async (name) => {
 				return {
@@ -566,7 +590,7 @@ describe("functionality", () => {
 			}
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -609,6 +633,7 @@ describe("functionality", () => {
 					modules: ["plugin.js", "lintRule.js"],
 				} satisfies ProjectSettings)
 			)
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const _import: ImportFunction = async (name) => {
 				return {
 					default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
@@ -617,7 +642,7 @@ describe("functionality", () => {
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -634,9 +659,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 			project.errors.subscribe((errors) => {
@@ -650,9 +676,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -667,9 +694,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -694,6 +722,7 @@ describe("functionality", () => {
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 
 			await fs.mkdir("./resources")
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const mockSaveFn = vi.fn()
 
@@ -714,7 +743,7 @@ describe("functionality", () => {
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -869,6 +898,7 @@ describe("functionality", () => {
 
 			await fs.mkdir("./project.inlang", { recursive: true })
 			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const mockSaveFn = vi.fn()
 
@@ -893,7 +923,7 @@ describe("functionality", () => {
 
 			const project = await loadProject({
 				projectPath: "/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 
@@ -911,9 +941,10 @@ describe("functionality", () => {
 			const fs = await createNodeishMemoryFs()
 			await fs.mkdir("/user/project", { recursive: true })
 			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project/project.inlang.json",
-				nodeishFs: fs,
+				repo,
 				_import,
 			})
 			// TODO: test with real lint rules
@@ -933,9 +964,10 @@ describe("functionality", () => {
 			const fs = createNodeishMemoryFs()
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
-				nodeishFs: fs,
+				repo,
 				_import: async () => ({
 					default: mockMessageLintRule,
 				}),
@@ -998,11 +1030,12 @@ describe("functionality", () => {
 
 			await fs.mkdir("./project.inlang", { recursive: true })
 			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings))
+			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			// establish watcher
 			const project = await loadProject({
 				projectPath: normalizePath("/project.inlang"),
-				nodeishFs: fs,
+				repo,
 				_import: async () => ({
 					default: mockMessageFormatPlugin,
 				}),

package/src/migrations/maybeCreateFirstProjectId.test.ts

@@ -18,7 +18,7 @@ it("should return if repo is undefined", async () => {
 
 it("should generate a project id", async () => {
 	const projectId = await generateProjectId({ repo, projectPath: "mocked_project_path" })
-	expect(projectId).toBe("959bcf0a30e678c9b90a3c76d1a281d085eab55f289c5439b6b10849baa1920c")
+	expect(projectId).toBe("432d7ef29c510e99d95e2d14ef57a0797a1603859b5a851b7dff7e77161b8c08")
 })
 
 it("should return undefined if repoMeta contains error", async () => {

package/src/migrations/maybeCreateFirstProjectId.ts

@@ -35,10 +35,9 @@ export async function generateProjectId(args: { repo?: Repository; projectPath:
 		return undefined
 	}
 	const firstCommitHash = await args.repo.getFirstCommitHash()
-	const originHash = await args.repo.getOrigin({ safeHashOnly: true })
 
 	if (firstCommitHash) {
-		return hash(`${firstCommitHash + args.projectPath + originHash}`)
+		return hash(`${firstCommitHash + args.projectPath}`)
 	}
 	return undefined
 }