@inlang/sdk 0.24.1 → 0.26.0

package/dist/loadProject.test.js

@@ -2,10 +2,10 @@
 import { describe, it, expect, vi } from "vitest";
 import { loadProject } from "./loadProject.js";
 import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
-import { createNodeishMemoryFs, normalizePath } from "@lix-js/fs";
+import { normalizePath } from "@lix-js/fs";
 import { createMessage } from "./test-utilities/createMessage.js";
 import { tryCatch } from "@inlang/result";
-import { mockRepo, openRepository } 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";
@@ -85,13 +85,9 @@ 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",
-        })),
-    });
-}
+const ciTestRepoSnapshot = JSON.parse(readFileSync(resolve(__dirname, "../mocks/ci-test-repo-no-shallow.json"), {
+    encoding: "utf-8",
+}));
 // ------------------------------------------------------------------------------------------------
 /**
  * Dear Developers,
@@ -100,8 +96,7 @@ async function openCiTestRepo() {
  * like files: they can be renamed and moved around.
  */
 it("should throw if a project (path) does not have a name", async () => {
-    const fs = createNodeishMemoryFs();
-    const repo = await openRepository("file://", { nodeishFs: fs });
+    const repo = await mockRepo();
     const project = await tryCatch(() => loadProject({
         projectPath: "/source-code/.inlang",
         repo,
@@ -110,8 +105,7 @@ it("should throw if a project (path) does not have a name", async () => {
     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 repo = await mockRepo();
     const invalidPaths = [
         "/source-code/frontend.inlang/settings",
         "/source-code/frontend.inlang/settings.json",
@@ -128,8 +122,7 @@ 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 repo = await mockRepo();
         const result = await tryCatch(() => loadProject({
             projectPath: "relative/path",
             repo,
@@ -139,7 +132,7 @@ describe("initialization", () => {
         expect(result.data).toBeUndefined();
     });
     it("should generate projectId on missing projectid", async () => {
-        const repo = await openCiTestRepo();
+        const repo = await mockRepo({ fromSnapshot: ciTestRepoSnapshot });
         const existing = await repo.nodeishFs
             .readFile("/project.inlang/project_id", {
             encoding: "utf-8",
@@ -166,7 +159,7 @@ describe("initialization", () => {
         expect(result.data).toBeDefined();
     });
     it("should reuse projectId on existing projectid", async () => {
-        const repo = await openCiTestRepo();
+        const repo = await mockRepo({ fromSnapshot: ciTestRepoSnapshot });
         repo.nodeishFs.writeFile("/project.inlang/project_id", "testId");
         const result = await tryCatch(() => loadProject({
             projectPath: "/project.inlang",
@@ -185,10 +178,10 @@ describe("initialization", () => {
         expect(result.data).toBeDefined();
     });
     it("should resolve from a windows path", async () => {
-        const fs = createNodeishMemoryFs();
+        const repo = await mockRepo();
+        const fs = repo.nodeishFs;
         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",
             repo,
@@ -199,9 +192,9 @@ describe("initialization", () => {
     });
     describe("settings", () => {
         it("should return an error if settings file is not found", async () => {
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             fs.mkdir("/user/project", { recursive: true });
-            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/non-existend-project.inlang",
                 repo,
@@ -210,10 +203,10 @@ describe("initialization", () => {
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileNotFoundError);
         });
         it("should return an error if settings file is not a valid JSON", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -222,10 +215,10 @@ describe("initialization", () => {
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileJSONSyntaxError);
         });
         it("should return an error if settings file is does not match schema", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -234,10 +227,10 @@ describe("initialization", () => {
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsInvalidError);
         });
         it("should return the parsed settings", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -246,11 +239,11 @@ describe("initialization", () => {
             expect(project.settings()).toStrictEqual(settings);
         });
         it("should not re-write the settings to disk when initializing", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -274,10 +267,10 @@ describe("initialization", () => {
             const $badImport = async () => ({
                 default: {},
             });
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -303,10 +296,10 @@ describe("initialization", () => {
 describe("functionality", () => {
     describe("settings", () => {
         it("should return the settings", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -315,10 +308,10 @@ describe("functionality", () => {
             expect(getValue(project.settings)).toStrictEqual(settings);
         });
         it("should set a new settings", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -338,10 +331,10 @@ describe("functionality", () => {
     });
     describe("setSettings", () => {
         it("should fail if settings are not valid", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -352,7 +345,8 @@ describe("functionality", () => {
             expect(result.error).toBeInstanceOf(ProjectSettingsInvalidError);
         });
         it("should throw an error if sourceLanguageTag is not in languageTags", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             await fs.mkdir("/user/project.inlang", { recursive: true });
             const settings = {
                 sourceLanguageTag: "en",
@@ -360,7 +354,6 @@ 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",
                 repo,
@@ -370,10 +363,10 @@ describe("functionality", () => {
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsInvalidError);
         });
         it("should write settings to disk", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -393,7 +386,8 @@ describe("functionality", () => {
     });
     describe("installed", () => {
         it("should return the installed items", async () => {
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
@@ -401,7 +395,6 @@ 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",
                 repo,
@@ -422,7 +415,8 @@ describe("functionality", () => {
             });
         });
         it("should apply 'warning' as default lint level to lint rules that have no lint level defined in the settings", async () => {
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
@@ -430,7 +424,6 @@ 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",
                 repo,
@@ -459,14 +452,14 @@ describe("functionality", () => {
                 loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
                 saveMessages: () => undefined,
             };
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 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,
@@ -502,14 +495,14 @@ describe("functionality", () => {
                 loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
                 saveMessages: () => undefined,
             };
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             await fs.mkdir("/user/project.inlang", { recursive: true });
             await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 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,
@@ -526,10 +519,10 @@ describe("functionality", () => {
     });
     describe("errors", () => {
         it("should return the errors", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -542,10 +535,10 @@ describe("functionality", () => {
     });
     describe("customApi", () => {
         it("should return the app specific api", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -558,10 +551,10 @@ describe("functionality", () => {
     });
     describe("messages", () => {
         it("should return the messages", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -572,7 +565,8 @@ describe("functionality", () => {
     });
     describe("query", () => {
         it("should call saveMessages() on updates", async () => {
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en", "de"],
@@ -584,7 +578,6 @@ 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",
@@ -735,7 +728,8 @@ describe("functionality", () => {
          *  - Might be slow for a large number of messages. The requirement hasn't popped up yet though.
          */
         it("should pass all messages, regardless of which message changed, to saveMessages()", async () => {
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en", "de"],
@@ -746,7 +740,6 @@ 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",
@@ -777,10 +770,10 @@ describe("functionality", () => {
     });
     describe("lint", () => {
         it.todo("should throw if lint reports are not initialized yet", async () => {
-            const fs = await createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -801,10 +794,10 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["lintRule.js"],
             };
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             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",
                 repo,
@@ -818,7 +811,8 @@ describe("functionality", () => {
     });
     describe("watcher", () => {
         it("changing files in resources should trigger callback of message query", async () => {
-            const fs = createNodeishMemoryFs();
+            const repo = await mockRepo();
+            const fs = repo.nodeishFs;
             const messages = {
                 $schema: "https://inlang.com/schema/inlang-message-format",
                 data: [
@@ -862,7 +856,6 @@ 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"),

package/dist/telemetry/groupIdentify.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Capture an event.
+ *
+ * - manually calling the PostHog API because the SDKs were not platform angostic (and generally bloated)
+ */
+export declare const identifyProject: (args: {
+    projectId: string;
+    /**
+     * Please use snake_case for property names.
+     */
+    properties: Record<string, any>;
+}) => Promise<void>;
+//# sourceMappingURL=groupIdentify.d.ts.map

package/dist/telemetry/groupIdentify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groupIdentify.d.ts","sourceRoot":"","sources":["../../src/telemetry/groupIdentify.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,eAAO,MAAM,eAAe,SAAgB;IAC3C,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,UAAU,EAAE,OAAO,MAAM,EAAE,GAAG,CAAC,CAAA;CAC/B,kBA2BA,CAAA"}

package/dist/telemetry/groupIdentify.js

@@ -0,0 +1,35 @@
+import { ENV_VARIABLES } from "../env-variables/index.js";
+/**
+ * Capture an event.
+ *
+ * - manually calling the PostHog API because the SDKs were not platform angostic (and generally bloated)
+ */
+export const identifyProject = async (args) => {
+    // do not send events if the token is not set
+    // (assuming this eases testing)
+    if (ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN === undefined) {
+        return;
+    }
+    try {
+        await fetch("https://eu.posthog.com/capture/", {
+            method: "POST",
+            body: JSON.stringify({
+                api_key: ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN,
+                event: "$groupidentify",
+                // id is "unknown" because no user information is available
+                distinct_id: "unknown",
+                properties: {
+                    $group_type: "project",
+                    $group_key: args.projectId,
+                    $group_set: {
+                        ...args.properties,
+                    },
+                },
+            }),
+        });
+    }
+    catch (e) {
+        // TODO implement sentry logging
+        // do not console.log and avoid exposing internal errors to the user
+    }
+};

package/package.json

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

package/src/adapter/solidAdapter.test.ts

@@ -4,8 +4,7 @@ import type { ImportFunction } from "../resolve-modules/index.js"
 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 { mockRepo } from "@lix-js/client"
 import type {
 	Message,
 	ProjectSettings,
@@ -90,10 +89,10 @@ const $import: ImportFunction = async (name) => ({
 
 describe("config", () => {
 	it("should react to changes in config", async () => {
-		const fs = createNodeishMemoryFs()
+		const repo = await mockRepo()
+		const fs = repo.nodeishFs
 		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",
@@ -124,10 +123,10 @@ describe("config", () => {
 
 describe("installed", () => {
 	it("react to changes that are unrelated to installed items", async () => {
-		const fs = createNodeishMemoryFs()
+		const repo = await mockRepo()
+		const fs = repo.nodeishFs
 		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",
@@ -161,7 +160,8 @@ describe("installed", () => {
 
 describe("messages", () => {
 	it("should react to changes in config", async () => {
-		const fs = createNodeishMemoryFs()
+		const repo = await mockRepo()
+		const fs = repo.nodeishFs
 		const mockConfig: ProjectSettings = {
 			sourceLanguageTag: "en",
 			languageTags: ["en", "de"],
@@ -193,7 +193,6 @@ 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",
@@ -221,10 +220,10 @@ describe("messages", () => {
 	})
 
 	it("should react to changes in messages", async () => {
-		const fs = createNodeishMemoryFs()
+		const repo = await mockRepo()
+		const fs = repo.nodeishFs
 		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",
@@ -284,10 +283,10 @@ describe("messages", () => {
 describe("lint", () => {
 	it.todo("should react to changes in config", async () => {
 		await createRoot(async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			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",
@@ -324,9 +323,9 @@ describe("lint", () => {
 
 	it.todo("should react to changes to messages", async () => {
 		await createRoot(async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			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",

package/src/adapter/solidAdapter.ts

@@ -13,6 +13,7 @@ export const solidAdapter = (
 	}
 
 	return {
+		id: project.id,
 		customApi: convert(project.customApi),
 		settings: convert(project.settings),
 		errors: convert(project.errors),
@@ -45,6 +46,7 @@ export const solidAdapter = (
 }
 
 export type InlangProjectWithSolidAdapter = {
+	id: InlangProject["id"]
 	customApi: () => ReturnType<InlangProject["customApi"]>
 	installed: {
 		plugins: () => ReturnType<InlangProject["installed"]["plugins"]>

package/src/api.ts

@@ -34,6 +34,11 @@ export type InstalledMessageLintRule = {
 }
 
 export type InlangProject = {
+	/**
+	 * The project's id.
+	 */
+	// TODO #2063 make project id non-optional when every project is guaranteed to a project id
+	id?: string
 	installed: {
 		plugins: Subscribable<InstalledPlugin[]>
 		messageLintRules: Subscribable<InstalledMessageLintRule[]>