@inlang/sdk 0.18.0 → 0.20.0

package/dist/loadProject.js

@@ -12,11 +12,13 @@ import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsoluteP
 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.
  *
- * @param settingsFilePath - Absolute path to the inlang settings file.
+ * @param projectPath - Absolute path to the inlang settings file.
  * @param nodeishFs - Filesystem that implements the NodeishFilesystemSubset interface.
  * @param _import - Use `_import` to pass a custom import function for testing,
  *   and supporting legacy resolvedModules such as CJS.
@@ -24,37 +26,69 @@ const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
  *
  */
 export const loadProject = async (args) => {
+    const projectPath = normalizePath(args.projectPath);
+    // -- migrate if outdated ------------------------------------------------
+    await maybeMigrateToDirectory({ nodeishFs: args.nodeishFs, projectPath });
     // -- validation --------------------------------------------------------
-    //! the only place where throwing is acceptable because the project
-    //! won't even be loaded. do not throw anywhere else. otherwise, apps
-    //! can't handle errors gracefully.
-    if (!isAbsolutePath(args.settingsFilePath)) {
-        throw new LoadProjectInvalidArgument(`Expected an absolute path but received "${args.settingsFilePath}".`, { argument: "settingsFilePath" });
+    // the only place where throwing is acceptable because the project
+    // won't even be loaded. do not throw anywhere else. otherwise, apps
+    // can't handle errors gracefully.
+    if (!isAbsolutePath(args.projectPath)) {
+        throw new LoadProjectInvalidArgument(`Expected an absolute path but received "${args.projectPath}".`, { argument: "projectPath" });
+    }
+    else if (/[^\\/]+\.inlang$/.test(projectPath) === false) {
+        throw new LoadProjectInvalidArgument(`Expected a path ending in "{name}.inlang" but received "${projectPath}".\n\nValid examples: \n- "/path/to/micky-mouse.inlang"\n- "/path/to/green-elephant.inlang\n`, { argument: "projectPath" });
     }
-    const settingsFilePath = normalizePath(args.settingsFilePath);
     // -- load project ------------------------------------------------------
+    let idError;
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
         const nodeishFs = createNodeishFsWithAbsolutePaths({
-            settingsFilePath,
+            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(() => {
-            loadSettings({ settingsFilePath, nodeishFs })
+            // 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);
             });
         });
         // TODO: create FS watcher and update settings on change
-        const writeSettingsToDisk = skipFirst((settings) => _writeSettingsToDisk({ nodeishFs, settings }));
+        const writeSettingsToDisk = skipFirst((settings) => _writeSettingsToDisk({ nodeishFs, settings, projectPath }));
         const setSettings = (settings) => {
             try {
                 const validatedSettings = parseSettings(settings);
@@ -84,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;
@@ -142,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())) {
@@ -158,12 +193,12 @@ export const loadProject = async (args) => {
                     cause: err,
                 });
             }
-            // if (
-            // 	newMessages.length !== 0 &&
-            // 	JSON.stringify(newMessages) !== JSON.stringify(messages())
-            // ) {
-            // 	setMessages(newMessages)
-            // }
+            const abortController = new AbortController();
+            if (newMessages.length !== 0 &&
+                JSON.stringify(newMessages) !== JSON.stringify(messages()) &&
+                nodeishFs.watch("/", { signal: abortController.signal }) !== undefined) {
+                setMessages(newMessages);
+            }
         }, { atBegin: false }));
         createEffect(() => {
             debouncedSave(messagesQuery.getAll());
@@ -175,6 +210,7 @@ export const loadProject = async (args) => {
             },
             errors: createSubscribable(() => [
                 ...(initializeError ? [initializeError] : []),
+                ...(idError ? [idError] : []),
                 ...(resolvedModules() ? resolvedModules().errors : []),
                 // have a query error exposed
                 //...(lintErrors() ?? []),
@@ -240,7 +276,7 @@ const _writeSettingsToDisk = async (args) => {
     if (serializeSettingsError) {
         throw serializeSettingsError;
     }
-    const { error: writeSettingsError } = await tryCatch(async () => args.nodeishFs.writeFile("./project.inlang.json", serializedSettings));
+    const { error: writeSettingsError } = await tryCatch(async () => args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings));
     if (writeSettingsError) {
         throw writeSettingsError;
     }

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;
@@ -80,23 +81,102 @@ const _import = async (name) => ({
     default: name === "plugin.js" ? mockPlugin : mockMessageLintRule,
 });
 // ------------------------------------------------------------------------------------------------
+/**
+ * Dear Developers,
+ *
+ * Inlang projects (folders) are not like .vscode, .git, or .github folders. Treat em
+ * 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 project = await tryCatch(() => loadProject({
+        projectPath: "/source-code/.inlang",
+        nodeishFs: fs,
+        _import,
+    }));
+    expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
+});
+it("should throw if a project path does not end with .inlang", async () => {
+    const fs = createNodeishMemoryFs();
+    const invalidPaths = [
+        "/source-code/frontend.inlang/settings",
+        "/source-code/frontend.inlang/settings.json",
+        "/source-code/frontend.inlang.md",
+    ];
+    for (const invalidPath of invalidPaths) {
+        const project = await tryCatch(() => loadProject({
+            projectPath: invalidPath,
+            nodeishFs: fs,
+            _import,
+        }));
+        expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
+    }
+});
 describe("initialization", () => {
-    it("should throw if settingsFilePath is not an absolute path", async () => {
+    it("should throw if projectPath is not an absolute path", async () => {
         const fs = createNodeishMemoryFs();
         const result = await tryCatch(() => loadProject({
-            settingsFilePath: "relative/path",
+            projectPath: "relative/path",
             nodeishFs: fs,
             _import,
         }));
         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", { recursive: true });
-        fs.writeFile("C:\\Users\\user\\project\\project.inlang.json", JSON.stringify(settings));
+        fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true });
+        fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings));
         const result = await tryCatch(() => loadProject({
-            settingsFilePath: "C:\\Users\\user\\project\\project.inlang.json",
+            projectPath: "C:\\Users\\user\\project.inlang",
             nodeishFs: fs,
             _import,
         }));
@@ -108,7 +188,7 @@ describe("initialization", () => {
             const fs = createNodeishMemoryFs();
             fs.mkdir("/user/project", { recursive: true });
             const project = await loadProject({
-                settingsFilePath: "/user/project/test.json",
+                projectPath: "/user/non-existend-project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -116,10 +196,10 @@ describe("initialization", () => {
         });
         it("should return an error if settings file is not a valid JSON", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", "invalid json");
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", "invalid json");
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -127,10 +207,10 @@ describe("initialization", () => {
         });
         it("should return an error if settings file is does not match schema", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({}));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify({}));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -138,10 +218,10 @@ describe("initialization", () => {
         });
         it("should return the parsed settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -150,21 +230,21 @@ describe("initialization", () => {
         it("should not re-write the settings to disk when initializing", async () => {
             const fs = await createNodeishMemoryFs();
             const settingsWithDeifferentFormatting = JSON.stringify(settings, undefined, 4);
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", settingsWithDeifferentFormatting);
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", settingsWithDeifferentFormatting);
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
-            const settingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+            const settingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
                 encoding: "utf-8",
             });
             expect(settingsOnDisk).toBe(settingsWithDeifferentFormatting);
             project.setSettings(project.settings());
             // TODO: how can we await `setsettings` correctly
             await new Promise((resolve) => setTimeout(resolve, 0));
-            const newsettingsOnDisk = await fs.readFile("/user/project/project.inlang.json", {
+            const newsettingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
                 encoding: "utf-8",
             });
             expect(newsettingsOnDisk).not.toBe(settingsWithDeifferentFormatting);
@@ -176,10 +256,10 @@ describe("initialization", () => {
                 default: {},
             });
             const fs = createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import: $badImport,
             });
@@ -204,10 +284,10 @@ describe("functionality", () => {
     describe("settings", () => {
         it("should return the settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -215,10 +295,10 @@ describe("functionality", () => {
         });
         it("should set a new settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -235,12 +315,12 @@ describe("functionality", () => {
         });
     });
     describe("setSettings", () => {
-        it("should fail if settings is not valid", async () => {
+        it("should fail if settings are not valid", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -250,15 +330,15 @@ describe("functionality", () => {
         });
         it("should throw an error if sourceLanguageTag is not in languageTags", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
+            await fs.mkdir("/user/project.inlang", { recursive: true });
             const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["de"],
                 modules: [],
             };
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -267,21 +347,21 @@ describe("functionality", () => {
         });
         it("should write settings to disk", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
-            const before = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" });
+            const before = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" });
             expect(before).toBeDefined();
-            const result = project.setSettings({ ...settings, languageTags: ["en"] });
+            const result = project.setSettings({ ...settings, languageTags: ["en", "nl", "de"] });
             expect(result.data).toBeUndefined();
             expect(result.error).toBeUndefined();
             // TODO: how to wait for fs.writeFile to finish?
-            await new Promise((resolve) => setTimeout(resolve, 0));
-            const after = await fs.readFile("/user/project/project.inlang.json", { encoding: "utf-8" });
+            await new Promise((resolve) => setTimeout(resolve, 50));
+            const after = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" });
             expect(after).toBeDefined();
             expect(after).not.toBe(before);
         });
@@ -294,10 +374,10 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             };
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -322,10 +402,10 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             };
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -353,8 +433,8 @@ describe("functionality", () => {
                 saveMessages: () => undefined,
             };
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({
+            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"],
@@ -365,7 +445,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -395,8 +475,8 @@ describe("functionality", () => {
                 saveMessages: () => undefined,
             };
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify({
+            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"],
@@ -407,7 +487,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -418,10 +498,10 @@ describe("functionality", () => {
     describe("errors", () => {
         it("should return the errors", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -433,10 +513,10 @@ describe("functionality", () => {
     describe("customApi", () => {
         it("should return the app specific api", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -448,10 +528,10 @@ describe("functionality", () => {
     describe("messages", () => {
         it("should return the messages", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -469,8 +549,8 @@ describe("functionality", () => {
                     pathPattern: "./resources/{languageTag}.json",
                 },
             };
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             await fs.mkdir("./resources");
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
@@ -486,7 +566,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -631,7 +711,8 @@ describe("functionality", () => {
                     pathPattern: "./resources/{languageTag}.json",
                 },
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("./project.inlang", { recursive: true });
+            await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings));
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
                 id: "plugin.placeholder.name",
@@ -650,7 +731,7 @@ describe("functionality", () => {
                 };
             };
             const project = await loadProject({
-                settingsFilePath: "/project.inlang.json",
+                projectPath: "/project.inlang",
                 nodeishFs: fs,
                 _import,
             });
@@ -666,7 +747,7 @@ describe("functionality", () => {
             await fs.mkdir("/user/project", { recursive: true });
             await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project/project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
@@ -686,10 +767,10 @@ describe("functionality", () => {
                 modules: ["lintRule.js"],
             };
             const fs = createNodeishMemoryFs();
-            await fs.mkdir("/user/project", { recursive: true });
-            await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("/user/project.inlang", { recursive: true });
+            await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings));
             const project = await loadProject({
-                settingsFilePath: "/user/project/project.inlang.json",
+                projectPath: "/user/project.inlang",
                 nodeishFs: fs,
                 _import: async () => ({
                     default: mockMessageLintRule,
@@ -743,10 +824,11 @@ describe("functionality", () => {
                     filePath: "./messages.json",
                 },
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            await fs.mkdir("./project.inlang", { recursive: true });
+            await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings));
             // establish watcher
             const project = await loadProject({
-                settingsFilePath: normalizePath("/project.inlang.json"),
+                projectPath: normalizePath("/project.inlang"),
                 nodeishFs: fs,
                 _import: async () => ({
                     default: mockMessageFormatPlugin,

package/dist/migrations/migrateToDirectory.d.ts

@@ -0,0 +1,10 @@
+import type { NodeishFilesystem } from "@lix-js/fs";
+/**
+ * Migrates to the new project directory structure
+ * https://github.com/inlang/monorepo/issues/1678
+ */
+export declare const maybeMigrateToDirectory: (args: {
+    nodeishFs: NodeishFilesystem;
+    projectPath: string;
+}) => Promise<void>;
+//# sourceMappingURL=migrateToDirectory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migrateToDirectory.d.ts","sourceRoot":"","sources":["../../src/migrations/migrateToDirectory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAEnD;;;GAGG;AACH,eAAO,MAAM,uBAAuB,SAAgB;IACnD,SAAS,EAAE,iBAAiB,CAAA;IAC5B,WAAW,EAAE,MAAM,CAAA;CACnB,kBA0BA,CAAA"}