@inlang/sdk 0.19.0 → 0.20.0

package/README.md

@@ -13,4 +13,4 @@ Developer-first localization infrastructure that is built on git. Your git repos
 
 # @inlang/sdk
 
-The core module bundles "sdk" modules that depend on each other and is everything one needs to build [plugins](https://inlang.com/documentation/plugin) or entire [apps](https://inlang.com/documentation/develop-app) on inlang.
+The core module bundles "sdk" modules that depend on each other and is everything one needs to build [plugins](https://inlang.com/documentation/plugin) or entire [apps](https://inlang.com/documentation/build-app) on inlang.

package/dist/createMessageLintReportsQuery.d.ts

@@ -1,9 +1,8 @@
-import type { InlangProject, InstalledMessageLintRule } from "./api.js";
+import type { InlangProject, InstalledMessageLintRule, MessageQueryApi } from "./api.js";
 import type { ProjectSettings } from "@inlang/project-settings";
 import type { resolveModules } from "./resolve-modules/index.js";
-import type { Message } from "./versionedInterfaces.js";
 /**
  * Creates a reactive query API for messages.
  */
-export declare function createMessageLintReportsQuery(messages: () => Array<Message> | undefined, settings: () => ProjectSettings, installedMessageLintRules: () => Array<InstalledMessageLintRule>, resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined): InlangProject["query"]["messageLintReports"];
+export declare function createMessageLintReportsQuery(messagesQuery: MessageQueryApi, settings: () => ProjectSettings, installedMessageLintRules: () => Array<InstalledMessageLintRule>, resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined, hasWatcher: boolean): InlangProject["query"]["messageLintReports"];
 //# sourceMappingURL=createMessageLintReportsQuery.d.ts.map

package/dist/createMessageLintReportsQuery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createMessageLintReportsQuery.d.ts","sourceRoot":"","sources":["../src/createMessageLintReportsQuery.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,wBAAwB,EAA8B,MAAM,UAAU,CAAA;AACnG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAChE,OAAO,KAAK,EAAqB,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAI1E;;GAEG;AACH,wBAAgB,6BAA6B,CAC5C,QAAQ,EAAE,MAAM,KAAK,CAAC,OAAO,CAAC,GAAG,SAAS,EAC1C,QAAQ,EAAE,MAAM,eAAe,EAC/B,yBAAyB,EAAE,MAAM,KAAK,CAAC,wBAAwB,CAAC,EAChE,eAAe,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,GAAG,SAAS,GAC3E,aAAa,CAAC,OAAO,CAAC,CAAC,oBAAoB,CAAC,CAqD9C"}
+{"version":3,"file":"createMessageLintReportsQuery.d.ts","sourceRoot":"","sources":["../src/createMessageLintReportsQuery.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EACb,wBAAwB,EAExB,eAAe,EACf,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAOhE;;GAEG;AACH,wBAAgB,6BAA6B,CAC5C,aAAa,EAAE,eAAe,EAC9B,QAAQ,EAAE,MAAM,eAAe,EAC/B,yBAAyB,EAAE,MAAM,KAAK,CAAC,wBAAwB,CAAC,EAChE,eAAe,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,GAAG,SAAS,EAC7E,UAAU,EAAE,OAAO,GACjB,aAAa,CAAC,OAAO,CAAC,CAAC,oBAAoB,CAAC,CA2E9C"}

package/dist/createMessageLintReportsQuery.js

@@ -1,33 +1,54 @@
-import { createEffect } from "./reactivity/solid.js";
 import { createSubscribable } from "./loadProject.js";
 import { lintSingleMessage } from "./lint/index.js";
 import { ReactiveMap } from "./reactivity/map.js";
+import { debounce } from "throttle-debounce";
+import { createEffect } from "./reactivity/solid.js";
 /**
  * Creates a reactive query API for messages.
  */
-export function createMessageLintReportsQuery(messages, settings, installedMessageLintRules, resolvedModules) {
+export function createMessageLintReportsQuery(messagesQuery, settings, installedMessageLintRules, resolvedModules, hasWatcher) {
     // @ts-expect-error
     const index = new ReactiveMap();
+    const modules = resolvedModules();
+    const rulesArray = modules?.messageLintRules;
+    const messageLintRuleLevels = Object.fromEntries(installedMessageLintRules().map((rule) => [rule.id, rule.level]));
+    const settingsObject = () => {
+        return {
+            ...settings(),
+            messageLintRuleLevels,
+        };
+    };
+    const messages = messagesQuery.getAll();
     createEffect(() => {
-        const modules = resolvedModules();
-        const _messages = messages();
-        const _settings = settings();
-        if (_messages && _settings && modules) {
-            // index.clear()
-            for (const message of _messages) {
-                // TODO: only lint changed messages and update arrays selectively
-                lintSingleMessage({
-                    rules: modules.messageLintRules,
-                    settings: {
-                        ..._settings,
-                        messageLintRuleLevels: Object.fromEntries(installedMessageLintRules().map((rule) => [rule.id, rule.level])),
-                    },
-                    messages: _messages,
-                    message: message,
-                }).then((report) => {
-                    if (report.errors.length === 0 &&
-                        JSON.stringify(index.get(message.id)) !== JSON.stringify(report.data)) {
-                        index.set(message.id, report.data || []);
+        if (rulesArray) {
+            for (const messageId of messagesQuery.includedMessageIds()) {
+                createEffect(() => {
+                    const message = messagesQuery.get({ where: { id: messageId } });
+                    if (hasWatcher) {
+                        lintSingleMessage({
+                            rules: rulesArray,
+                            settings: settingsObject(),
+                            messages: messages,
+                            message: message,
+                        }).then((report) => {
+                            if (report.errors.length === 0 && index.get(messageId) !== report.data) {
+                                index.set(messageId, report.data);
+                            }
+                        });
+                    }
+                    else {
+                        debounce(500, (message) => {
+                            lintSingleMessage({
+                                rules: rulesArray,
+                                settings: settingsObject(),
+                                messages: messages,
+                                message: message,
+                            }).then((report) => {
+                                if (report.errors.length === 0 && index.get(messageId) !== report.data) {
+                                    index.set(messageId, report.data);
+                                }
+                            });
+                        }, { atBegin: false })(message);
                     }
                 });
             }

package/dist/generateProjectId.d.ts

@@ -0,0 +1,3 @@
+import type { Repository } from "@lix-js/client";
+export declare function generateProjectId(repo: Repository, projectPath: string): Promise<string | undefined>;
+//# sourceMappingURL=generateProjectId.d.ts.map

package/dist/generateProjectId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateProjectId.d.ts","sourceRoot":"","sources":["../src/generateProjectId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,+BAU5E"}

package/dist/generateProjectId.js

@@ -0,0 +1,11 @@
+import { hash } from "@lix-js/client";
+export async function generateProjectId(repo, projectPath) {
+    if (!repo || !projectPath) {
+        return undefined;
+    }
+    const repoMeta = await repo.getMeta();
+    if (repoMeta && !("error" in repoMeta)) {
+        return hash(`${repoMeta.id + projectPath}`);
+    }
+    return undefined;
+}

package/dist/generateProjectId.test.d.ts

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

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

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

package/dist/generateProjectId.test.js

@@ -0,0 +1,18 @@
+import { generateProjectId } from "./generateProjectId.js";
+import { describe, it, expect } from "vitest";
+import { openRepository } from "@lix-js/client/src/openRepository.ts";
+import { mockRepo, createNodeishMemoryFs } from "@lix-js/client";
+describe("generateProjectId", async () => {
+    const repo = await mockRepo();
+    it("should generate a project id", async () => {
+        const projectId = await generateProjectId(repo, "mocked_project_path");
+        expect(projectId).toBe("0c83325bf9068eb01091c522d4b8e3765aff42e36fc781c041b44439bbe3e734");
+    });
+    it("should return undefined if repoMeta contains error", async () => {
+        const errorRepo = await openRepository("https://github.com/inlang/no-exist", {
+            nodeishFs: createNodeishMemoryFs(),
+        });
+        const projectId = await generateProjectId(errorRepo, "mocked_project_path");
+        expect(projectId).toBeUndefined();
+    });
+});

package/dist/index.d.ts

@@ -6,6 +6,7 @@
 export type { InlangProject, InstalledMessageLintRule, InstalledPlugin, MessageQueryApi, Subscribable, } from "./api.js";
 export { type ImportFunction, createImport } from "./resolve-modules/index.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";

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,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,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"}

package/dist/index.js

@@ -5,6 +5,7 @@
  */
 export { createImport } from "./resolve-modules/index.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";

package/dist/listProjects.d.ts

@@ -0,0 +1,5 @@
+import type { NodeishFilesystem } from "@lix-js/fs";
+export declare const listProjects: (nodeishFs: NodeishFilesystem, from: string) => Promise<Array<{
+    projectPath: string;
+}>>;
+//# sourceMappingURL=listProjects.d.ts.map

package/dist/listProjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listProjects.d.ts","sourceRoot":"","sources":["../src/listProjects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD,eAAO,MAAM,YAAY,cACb,iBAAiB,QACtB,MAAM,KACV,QAAQ,MAAM;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAiCxC,CAAA"}

package/dist/listProjects.js

@@ -0,0 +1,31 @@
+export const listProjects = async (nodeishFs, from) => {
+    // !TODO: Remove this limit once we introduce caching
+    const recursionLimit = 5;
+    const projects = [];
+    async function searchDir(path, depth) {
+        if (depth > recursionLimit) {
+            return;
+        }
+        const files = await nodeishFs.readdir(path);
+        for (const file of files) {
+            const filePath = `${path}/${file}`;
+            const stats = await nodeishFs.stat(filePath);
+            if (stats.isDirectory()) {
+                if (file === "node_modules")
+                    continue;
+                if (file.endsWith(".inlang")) {
+                    projects.push({ projectPath: filePath });
+                }
+                else {
+                    await searchDir(filePath, depth + 1);
+                }
+            }
+        }
+    }
+    await searchDir(from, 0);
+    // remove double slashes
+    for (const project of projects) {
+        project.projectPath = project.projectPath.replace(/\/\//g, "/");
+    }
+    return projects;
+};

package/dist/listProjects.test.d.ts

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

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

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

package/dist/listProjects.test.js

@@ -0,0 +1,56 @@
+import { assert, describe, it } from "vitest";
+import { listProjects } from "./listProjects.js";
+import { createNodeishMemoryFs } from "@lix-js/fs";
+const settings = {
+    sourceLanguageTag: "en",
+    languageTags: ["en"],
+    modules: ["plugin.js", "lintRule.js"],
+    messageLintRuleLevels: {
+        "messageLintRule.project.missingTranslation": "error",
+    },
+    "plugin.project.i18next": {
+        pathPattern: "./examples/example01/{languageTag}.json",
+        variableReferencePattern: ["{", "}"],
+    },
+};
+describe("listProjects", () => {
+    it("should find all projects a given path", async () => {
+        const fs = createNodeishMemoryFs();
+        await fs.mkdir("/user/dir1/project.inlang", { recursive: true });
+        await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings));
+        await fs.mkdir("/user/dir2/project.inlang", { recursive: true });
+        await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings));
+        await listProjects(fs, "/user").then((projects) => {
+            assert(projects.length === 2);
+        });
+    });
+    it("should return objects inside of an array with the projectPath", async () => {
+        const fs = createNodeishMemoryFs();
+        await fs.mkdir("/user/dir1/project.inlang", { recursive: true });
+        await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings));
+        await fs.mkdir("/user/dir2/project.inlang", { recursive: true });
+        await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings));
+        await listProjects(fs, "/user").then((projects) => {
+            assert.isTrue(typeof projects[0] === "object");
+            assert.isTrue(typeof projects[0]?.projectPath === "string");
+        });
+    });
+    it("should limit the recursion depth to 5", async () => {
+        const fs = createNodeishMemoryFs();
+        await fs.mkdir("/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang", { recursive: true });
+        await fs.writeFile("/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang/settings.json", JSON.stringify(settings));
+        await listProjects(fs, "/user").then((projects) => {
+            assert(projects.length === 0);
+        });
+    });
+    it("should also find files inside of a dir that ends with *.inlang", async () => {
+        const fs = createNodeishMemoryFs();
+        await fs.mkdir("/user/dir1/go.inlang", { recursive: true });
+        await fs.writeFile("/user/dir1/go.inlang/settings.json", JSON.stringify(settings));
+        await fs.mkdir("/user/dir2/flutter.inlang", { recursive: true });
+        await fs.writeFile("/user/dir2/flutter.inlang/settings.json", JSON.stringify(settings));
+        await listProjects(fs, "/user").then((projects) => {
+            assert(projects.length === 2);
+        });
+    });
+});

package/dist/loadProject.d.ts

@@ -1,6 +1,7 @@
 import type { InlangProject, Subscribable } from "./api.js";
 import { type ImportFunction } from "./resolve-modules/index.js";
 import { type NodeishFilesystem } from "@lix-js/fs";
+import type { Repository } from "@lix-js/client";
 /**
  * Creates an inlang instance.
  *
@@ -13,6 +14,7 @@ import { type NodeishFilesystem } from "@lix-js/fs";
  */
 export declare const loadProject: (args: {
     projectPath: string;
+    repo?: Repository | undefined;
     nodeishFs: NodeishFilesystem;
     _import?: ImportFunction | undefined;
     _capture?: ((id: string, props: Record<string, unknown>) => void) | undefined;

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;AAkBhF,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAOlE;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;iBACV,MAAM;eACR,iBAAiB;;qBAEZ,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAkOxB,CAAA;AAwHD,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;AAkBhF,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAIlE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAKhD;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;iBACV,MAAM;;eAER,iBAAiB;;qBAEZ,MAAM,SAAS,OAAO,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI;MAC5D,QAAQ,aAAa,CAkQxB,CAAA;AAwHD,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAQtE"}

package/dist/loadProject.js

@@ -13,6 +13,7 @@ import { normalizePath } from "@lix-js/fs";
 import { isAbsolutePath } from "./isAbsolutePath.js";
 import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js";
 import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js";
+import { generateProjectId } from "./generateProjectId.js";
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * Creates an inlang instance.
@@ -39,21 +40,48 @@ export const loadProject = async (args) => {
         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" });
     }
     // -- load project ------------------------------------------------------
+    let idError;
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
         const nodeishFs = createNodeishFsWithAbsolutePaths({
             projectPath,
             nodeishFs: args.nodeishFs,
         });
+        let projectId;
+        try {
+            projectId = await nodeishFs.readFile(projectPath + "/project_id", {
+                encoding: "utf-8",
+            });
+        }
+        catch (error) {
+            // @ts-ignore
+            if (error.code === "ENOENT") {
+                if (args.repo) {
+                    projectId = await generateProjectId(args.repo, projectPath);
+                    if (projectId) {
+                        await nodeishFs.writeFile(projectPath + "/project_id", projectId);
+                    }
+                }
+            }
+            else {
+                idError = error;
+            }
+        }
         // -- settings ------------------------------------------------------------
         const [settings, _setSettings] = createSignal();
         createEffect(() => {
+            // TODO:
+            // if (projectId) {
+            // 	telemetryBrowser.group("project", projectId, {
+            // 		name: projectId,
+            // 	})
+            // }
             loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs })
                 .then((settings) => {
                 setSettings(settings);
                 // rename settings to get a convenient access to the data in Posthog
                 const project_settings = settings;
-                args._capture?.("SDK used settings", { project_settings });
+                args._capture?.("SDK used settings", { project_settings, group: projectId });
             })
                 .catch((err) => {
                 markInitAsFailed(err);
@@ -90,11 +118,10 @@ export const loadProject = async (args) => {
         // -- messages ----------------------------------------------------------
         let settingsValue;
         createEffect(() => (settingsValue = settings())); // workaround to not run effects twice (e.g. settings change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
+        // please don't use this as source of truth, use the query instead
+        // needed for granular linting
         const [messages, setMessages] = createSignal();
         createEffect(() => {
-            const conf = settings();
-            if (!conf)
-                return;
             const _resolvedModules = resolvedModules();
             if (!_resolvedModules)
                 return;
@@ -148,8 +175,10 @@ export const loadProject = async (args) => {
         };
         // -- app ---------------------------------------------------------------
         const initializeError = await initialized.catch((error) => error);
+        const abortController = new AbortController();
+        const hasWatcher = nodeishFs.watch("/", { signal: abortController.signal }) !== undefined;
         const messagesQuery = createMessagesQuery(() => messages() || []);
-        const lintReportsQuery = createMessageLintReportsQuery(messages, settings, installedMessageLintRules, resolvedModules);
+        const lintReportsQuery = createMessageLintReportsQuery(messagesQuery, settings, installedMessageLintRules, resolvedModules, hasWatcher);
         const debouncedSave = skipFirst(debounce(500, async (newMessages) => {
             try {
                 if (JSON.stringify(newMessages) !== JSON.stringify(messages())) {
@@ -167,7 +196,7 @@ export const loadProject = async (args) => {
             const abortController = new AbortController();
             if (newMessages.length !== 0 &&
                 JSON.stringify(newMessages) !== JSON.stringify(messages()) &&
-                nodeishFs.watch("/", { signal: abortController.signal }) === undefined) {
+                nodeishFs.watch("/", { signal: abortController.signal }) !== undefined) {
                 setMessages(newMessages);
             }
         }, { atBegin: false }));
@@ -181,6 +210,7 @@ export const loadProject = async (args) => {
             },
             errors: createSubscribable(() => [
                 ...(initializeError ? [initializeError] : []),
+                ...(idError ? [idError] : []),
                 ...(resolvedModules() ? resolvedModules().errors : []),
                 // have a query error exposed
                 //...(lintErrors() ?? []),

package/dist/loadProject.test.js

@@ -5,6 +5,7 @@ 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";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
     let value;
@@ -122,6 +123,54 @@ describe("initialization", () => {
         expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
         expect(result.data).toBeUndefined();
     });
+    it("should generate projectId on missing projectid", async () => {
+        const repo = await mockRepo();
+        const existing = await repo.nodeishFs
+            .readFile("/project.inlang/project_id", {
+            encoding: "utf-8",
+        })
+            .catch((error) => {
+            return { error };
+        });
+        // @ts-ignore
+        expect(existing.error.code).toBe("ENOENT");
+        const result = await tryCatch(() => loadProject({
+            projectPath: "/project.inlang",
+            nodeishFs: repo.nodeishFs,
+            repo,
+            _import,
+        }));
+        const newId = await repo.nodeishFs
+            .readFile("/project.inlang/project_id", {
+            encoding: "utf-8",
+        })
+            .catch((error) => {
+            return { error };
+        });
+        expect(newId).toBe("7cd6c2b7cf12febf99496408917123fdfe158b6bc442914f5fb42aa74346bd50");
+        expect(result.error).toBeUndefined();
+        expect(result.data).toBeDefined();
+    });
+    it("should reuse projectId on existing projectid", async () => {
+        const repo = await mockRepo();
+        repo.nodeishFs.writeFile("/project.inlang/project_id", "testId");
+        const result = await tryCatch(() => loadProject({
+            projectPath: "/project.inlang",
+            nodeishFs: repo.nodeishFs,
+            repo,
+            _import,
+        }));
+        const newId = await repo.nodeishFs
+            .readFile("/project.inlang/project_id", {
+            encoding: "utf-8",
+        })
+            .catch((error) => {
+            return { error };
+        });
+        expect(newId).toBe("testId");
+        expect(result.error).toBeUndefined();
+        expect(result.data).toBeDefined();
+    });
     it("should resolve from a windows path", async () => {
         const fs = createNodeishMemoryFs();
         fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.19.0",
+  "version": "0.20.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -21,20 +21,21 @@
   },
   "dependencies": {
     "@sinclair/typebox": "^0.31.17",
+    "dedent": "1.5.1",
     "deepmerge-ts": "^5.1.0",
     "solid-js": "1.6.12",
-    "throttle-debounce": "5.0.0",
-    "dedent": "1.5.1",
+    "throttle-debounce": "^5.0.0",
     "@inlang/json-types": "1.1.0",
-    "@inlang/message-lint-rule": "1.4.0",
-    "@inlang/translatable": "1.2.0",
-    "@inlang/module": "1.2.0",
-    "@inlang/language-tag": "1.2.0",
     "@inlang/message": "2.0.0",
+    "@inlang/language-tag": "1.2.0",
+    "@inlang/message-lint-rule": "1.4.0",
     "@inlang/plugin": "2.4.0",
-    "@inlang/result": "1.1.0",
+    "@inlang/module": "1.2.0",
     "@inlang/project-settings": "2.2.0",
-    "@lix-js/fs": "0.4.0"
+    "@inlang/result": "1.1.0",
+    "@lix-js/fs": "0.4.0",
+    "@lix-js/client": "0.2.0",
+    "@inlang/translatable": "1.2.0"
   },
   "devDependencies": {
     "@types/throttle-debounce": "5.0.0",

package/src/createMessageLintReportsQuery.ts

@@ -1,50 +1,79 @@
-import { createEffect } from "./reactivity/solid.js"
 import { createSubscribable } from "./loadProject.js"
-import type { InlangProject, InstalledMessageLintRule, MessageLintReportsQueryApi } from "./api.js"
+import type {
+	InlangProject,
+	InstalledMessageLintRule,
+	MessageLintReportsQueryApi,
+	MessageQueryApi,
+} from "./api.js"
 import type { ProjectSettings } from "@inlang/project-settings"
 import type { resolveModules } from "./resolve-modules/index.js"
 import type { MessageLintReport, Message } from "./versionedInterfaces.js"
 import { lintSingleMessage } from "./lint/index.js"
 import { ReactiveMap } from "./reactivity/map.js"
+import { debounce } from "throttle-debounce"
+import { createEffect } from "./reactivity/solid.js"
 
 /**
  * Creates a reactive query API for messages.
  */
 export function createMessageLintReportsQuery(
-	messages: () => Array<Message> | undefined,
+	messagesQuery: MessageQueryApi,
 	settings: () => ProjectSettings,
 	installedMessageLintRules: () => Array<InstalledMessageLintRule>,
-	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined
+	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined,
+	hasWatcher: boolean
 ): InlangProject["query"]["messageLintReports"] {
 	// @ts-expect-error
 	const index = new ReactiveMap<MessageLintReport["messageId"], MessageLintReport[]>()
 
-	createEffect(() => {
-		const modules = resolvedModules()
-		const _messages = messages()
-		const _settings = settings()
+	const modules = resolvedModules()
 
-		if (_messages && _settings && modules) {
-			// index.clear()
-			for (const message of _messages) {
-				// TODO: only lint changed messages and update arrays selectively
+	const rulesArray = modules?.messageLintRules
+	const messageLintRuleLevels = Object.fromEntries(
+		installedMessageLintRules().map((rule) => [rule.id, rule.level])
+	)
+	const settingsObject = () => {
+		return {
+			...settings(),
+			messageLintRuleLevels,
+		}
+	}
+
+	const messages = messagesQuery.getAll() as Message[]
 
-				lintSingleMessage({
-					rules: modules.messageLintRules,
-					settings: {
-						..._settings,
-						messageLintRuleLevels: Object.fromEntries(
-							installedMessageLintRules().map((rule) => [rule.id, rule.level])
-						),
-					},
-					messages: _messages,
-					message: message,
-				}).then((report) => {
-					if (
-						report.errors.length === 0 &&
-						JSON.stringify(index.get(message.id)) !== JSON.stringify(report.data)
-					) {
-						index.set(message.id, report.data || [])
+	createEffect(() => {
+		if (rulesArray) {
+			for (const messageId of messagesQuery.includedMessageIds()) {
+				createEffect(() => {
+					const message = messagesQuery.get({ where: { id: messageId } })
+					if (hasWatcher) {
+						lintSingleMessage({
+							rules: rulesArray,
+							settings: settingsObject(),
+							messages: messages,
+							message: message,
+						}).then((report) => {
+							if (report.errors.length === 0 && index.get(messageId) !== report.data) {
+								index.set(messageId, report.data)
+							}
+						})
+					} else {
+						debounce(
+							500,
+							(message) => {
+								lintSingleMessage({
+									rules: rulesArray,
+									settings: settingsObject(),
+									messages: messages,
+									message: message,
+								}).then((report) => {
+									if (report.errors.length === 0 && index.get(messageId) !== report.data) {
+										index.set(messageId, report.data)
+									}
+								})
+							},
+							{ atBegin: false }
+						)(message)
 					}
 				})
 			}

package/src/generateProjectId.test.ts

@@ -0,0 +1,22 @@
+import { generateProjectId } from "./generateProjectId.js"
+import { describe, it, expect } from "vitest"
+import { openRepository } from "@lix-js/client/src/openRepository.ts"
+import { mockRepo, createNodeishMemoryFs } from "@lix-js/client"
+
+describe("generateProjectId", async () => {
+	const repo = await mockRepo()
+
+	it("should generate a project id", async () => {
+		const projectId = await generateProjectId(repo, "mocked_project_path")
+		expect(projectId).toBe("0c83325bf9068eb01091c522d4b8e3765aff42e36fc781c041b44439bbe3e734")
+	})
+
+	it("should return undefined if repoMeta contains error", async () => {
+		const errorRepo = await openRepository("https://github.com/inlang/no-exist", {
+			nodeishFs: createNodeishMemoryFs(),
+		})
+
+		const projectId = await generateProjectId(errorRepo, "mocked_project_path")
+		expect(projectId).toBeUndefined()
+	})
+})

package/src/generateProjectId.ts

@@ -0,0 +1,14 @@
+import type { Repository } from "@lix-js/client"
+import { hash } from "@lix-js/client"
+
+export async function generateProjectId(repo: Repository, projectPath: string) {
+	if (!repo || !projectPath) {
+		return undefined
+	}
+	const repoMeta = await repo.getMeta()
+
+	if (repoMeta && !("error" in repoMeta)) {
+		return hash(`${repoMeta.id + projectPath}`)
+	}
+	return undefined
+}

package/src/index.ts

@@ -13,6 +13,7 @@ export type {
 } from "./api.js"
 export { type ImportFunction, createImport } from "./resolve-modules/index.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 {

package/src/listProjects.test.ts

@@ -0,0 +1,69 @@
+import { assert, describe, it } from "vitest"
+import { listProjects } from "./listProjects.js"
+import { createNodeishMemoryFs } from "@lix-js/fs"
+import type { ProjectSettings } from "@inlang/project-settings"
+
+const settings: ProjectSettings = {
+	sourceLanguageTag: "en",
+	languageTags: ["en"],
+	modules: ["plugin.js", "lintRule.js"],
+	messageLintRuleLevels: {
+		"messageLintRule.project.missingTranslation": "error",
+	},
+	"plugin.project.i18next": {
+		pathPattern: "./examples/example01/{languageTag}.json",
+		variableReferencePattern: ["{", "}"],
+	},
+}
+
+describe("listProjects", () => {
+	it("should find all projects a given path", async () => {
+		const fs = createNodeishMemoryFs()
+		await fs.mkdir("/user/dir1/project.inlang", { recursive: true })
+		await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings))
+		await fs.mkdir("/user/dir2/project.inlang", { recursive: true })
+		await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings))
+
+		await listProjects(fs, "/user").then((projects) => {
+			assert(projects.length === 2)
+		})
+	})
+
+	it("should return objects inside of an array with the projectPath", async () => {
+		const fs = createNodeishMemoryFs()
+		await fs.mkdir("/user/dir1/project.inlang", { recursive: true })
+		await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings))
+		await fs.mkdir("/user/dir2/project.inlang", { recursive: true })
+		await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings))
+
+		await listProjects(fs, "/user").then((projects) => {
+			assert.isTrue(typeof projects[0] === "object")
+			assert.isTrue(typeof projects[0]?.projectPath === "string")
+		})
+	})
+
+	it("should limit the recursion depth to 5", async () => {
+		const fs = createNodeishMemoryFs()
+		await fs.mkdir("/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang", { recursive: true })
+		await fs.writeFile(
+			"/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang/settings.json",
+			JSON.stringify(settings)
+		)
+
+		await listProjects(fs, "/user").then((projects) => {
+			assert(projects.length === 0)
+		})
+	})
+
+	it("should also find files inside of a dir that ends with *.inlang", async () => {
+		const fs = createNodeishMemoryFs()
+		await fs.mkdir("/user/dir1/go.inlang", { recursive: true })
+		await fs.writeFile("/user/dir1/go.inlang/settings.json", JSON.stringify(settings))
+		await fs.mkdir("/user/dir2/flutter.inlang", { recursive: true })
+		await fs.writeFile("/user/dir2/flutter.inlang/settings.json", JSON.stringify(settings))
+
+		await listProjects(fs, "/user").then((projects) => {
+			assert(projects.length === 2)
+		})
+	})
+})

package/src/listProjects.ts

@@ -0,0 +1,39 @@
+import type { NodeishFilesystem } from "@lix-js/fs"
+
+export const listProjects = async (
+	nodeishFs: NodeishFilesystem,
+	from: string
+): Promise<Array<{ projectPath: string }>> => {
+	// !TODO: Remove this limit once we introduce caching
+	const recursionLimit = 5
+
+	const projects: Array<{ projectPath: string }> = []
+
+	async function searchDir(path: string, depth: number) {
+		if (depth > recursionLimit) {
+			return
+		}
+
+		const files = await nodeishFs.readdir(path)
+		for (const file of files) {
+			const filePath = `${path}/${file}`
+			const stats = await nodeishFs.stat(filePath)
+			if (stats.isDirectory()) {
+				if (file === "node_modules") continue
+				if (file.endsWith(".inlang")) {
+					projects.push({ projectPath: filePath })
+				} else {
+					await searchDir(filePath, depth + 1)
+				}
+			}
+		}
+	}
+
+	await searchDir(from, 0)
+
+	// remove double slashes
+	for (const project of projects) {
+		project.projectPath = project.projectPath.replace(/\/\//g, "/")
+	}
+	return projects
+}

package/src/loadProject.test.ts

@@ -19,6 +19,7 @@ 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"
 
 // ------------------------------------------------------------------------------------------------
 
@@ -159,6 +160,71 @@ describe("initialization", () => {
 		expect(result.data).toBeUndefined()
 	})
 
+	it("should generate projectId on missing projectid", async () => {
+		const repo = await mockRepo()
+
+		const existing = await repo.nodeishFs
+			.readFile("/project.inlang/project_id", {
+				encoding: "utf-8",
+			})
+			.catch((error) => {
+				return { error }
+			})
+
+		// @ts-ignore
+		expect(existing.error.code).toBe("ENOENT")
+
+		const result = await tryCatch(() =>
+			loadProject({
+				projectPath: "/project.inlang",
+				nodeishFs: repo.nodeishFs,
+				repo,
+				_import,
+			})
+		)
+
+		const newId = await repo.nodeishFs
+			.readFile("/project.inlang/project_id", {
+				encoding: "utf-8",
+			})
+			.catch((error) => {
+				return { error }
+			})
+
+		expect(newId).toBe("7cd6c2b7cf12febf99496408917123fdfe158b6bc442914f5fb42aa74346bd50")
+
+		expect(result.error).toBeUndefined()
+		expect(result.data).toBeDefined()
+	})
+
+	it("should reuse projectId on existing projectid", async () => {
+		const repo = await mockRepo()
+
+		repo.nodeishFs.writeFile("/project.inlang/project_id", "testId")
+
+		const result = await tryCatch(() =>
+			loadProject({
+				projectPath: "/project.inlang",
+				nodeishFs: repo.nodeishFs,
+				repo,
+				_import,
+			})
+		)
+
+		const newId = await repo.nodeishFs
+			.readFile("/project.inlang/project_id", {
+				encoding: "utf-8",
+			})
+			.catch((error) => {
+				return { error }
+			})
+
+		expect(newId).toBe("testId")
+
+		expect(result.error).toBeUndefined()
+		expect(result.data).toBeDefined()
+	})
+
 	it("should resolve from a windows path", async () => {
 		const fs = createNodeishMemoryFs()
 		fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true })
@@ -691,7 +757,6 @@ describe("functionality", () => {
 								},
 							],
 						},
-
 						{
 							languageTag: "de",
 							match: [],

package/src/loadProject.ts

@@ -27,6 +27,8 @@ import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
 import { isAbsolutePath } from "./isAbsolutePath.js"
 import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js"
 import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js"
+import type { Repository } from "@lix-js/client"
+import { generateProjectId } from "./generateProjectId.js"
 
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
@@ -42,6 +44,7 @@ const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
  */
 export const loadProject = async (args: {
 	projectPath: string
+	repo?: Repository
 	nodeishFs: NodeishFilesystem
 	_import?: ImportFunction
 	_capture?: (id: string, props: Record<string, unknown>) => void
@@ -70,6 +73,7 @@ export const loadProject = async (args: {
 	}
 
 	// -- load project ------------------------------------------------------
+	let idError: Error | undefined
 	return await createRoot(async () => {
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
 		const nodeishFs = createNodeishFsWithAbsolutePaths({
@@ -77,16 +81,43 @@ export const loadProject = async (args: {
 			nodeishFs: args.nodeishFs,
 		})
 
+		let projectId: string | undefined
+
+		try {
+			projectId = await nodeishFs.readFile(projectPath + "/project_id", {
+				encoding: "utf-8",
+			})
+		} catch (error) {
+			// @ts-ignore
+			if (error.code === "ENOENT") {
+				if (args.repo) {
+					projectId = await generateProjectId(args.repo, projectPath)
+					if (projectId) {
+						await nodeishFs.writeFile(projectPath + "/project_id", projectId)
+					}
+				}
+			} else {
+				idError = error as Error
+			}
+		}
+
 		// -- settings ------------------------------------------------------------
 
 		const [settings, _setSettings] = createSignal<ProjectSettings>()
 		createEffect(() => {
+			// TODO:
+			// if (projectId) {
+			// 	telemetryBrowser.group("project", projectId, {
+			// 		name: projectId,
+			// 	})
+			// }
+
 			loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs })
 				.then((settings) => {
 					setSettings(settings)
 					// rename settings to get a convenient access to the data in Posthog
 					const project_settings = settings
-					args._capture?.("SDK used settings", { project_settings })
+					args._capture?.("SDK used settings", { project_settings, group: projectId })
 				})
 				.catch((err) => {
 					markInitAsFailed(err)
@@ -137,12 +168,11 @@ export const loadProject = async (args: {
 		let settingsValue: ProjectSettings
 		createEffect(() => (settingsValue = settings()!)) // workaround to not run effects twice (e.g. settings change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
 
+		// please don't use this as source of truth, use the query instead
+		// needed for granular linting
 		const [messages, setMessages] = createSignal<Message[]>()
 
 		createEffect(() => {
-			const conf = settings()
-			if (!conf) return
-
 			const _resolvedModules = resolvedModules()
 			if (!_resolvedModules) return
 
@@ -210,12 +240,16 @@ export const loadProject = async (args: {
 
 		const initializeError: Error | undefined = await initialized.catch((error) => error)
 
+		const abortController = new AbortController()
+		const hasWatcher = nodeishFs.watch("/", { signal: abortController.signal }) !== undefined
+
 		const messagesQuery = createMessagesQuery(() => messages() || [])
 		const lintReportsQuery = createMessageLintReportsQuery(
-			messages,
+			messagesQuery,
 			settings as () => ProjectSettings,
 			installedMessageLintRules,
-			resolvedModules
+			resolvedModules,
+			hasWatcher
 		)
 
 		const debouncedSave = skipFirst(
@@ -238,7 +272,7 @@ export const loadProject = async (args: {
 					if (
 						newMessages.length !== 0 &&
 						JSON.stringify(newMessages) !== JSON.stringify(messages()) &&
-						nodeishFs.watch("/", { signal: abortController.signal }) === undefined
+						nodeishFs.watch("/", { signal: abortController.signal }) !== undefined
 					) {
 						setMessages(newMessages)
 					}
@@ -258,6 +292,7 @@ export const loadProject = async (args: {
 			},
 			errors: createSubscribable(() => [
 				...(initializeError ? [initializeError] : []),
+				...(idError ? [idError] : []),
 				...(resolvedModules() ? resolvedModules()!.errors : []),
 				// have a query error exposed
 				//...(lintErrors() ?? []),