@inlang/sdk 0.4.0 → 0.6.0

package/dist/{openInlangProject.test.js → loadProject.test.js}

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect, vi } from "vitest";
-import { openInlangProject } from "./openInlangProject.js";
-import { ProjectFilePathNotFoundError, ProjectFileJSONSyntaxError, InvalidConfigError, } from "./errors.js";
+import { loadProject } from "./loadProject.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, } from "./errors.js";
 import { createNodeishMemoryFs } from "@lix-js/fs";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
@@ -9,30 +9,26 @@ const getValue = (subscribable) => {
     subscribable.subscribe((v) => void (value = v));
     return value;
 };
-const config = {
+const settings = {
     sourceLanguageTag: "en",
     languageTags: ["en"],
     modules: ["plugin.js", "lintRule.js"],
-    settings: {
-        "project.messageLintRuleLevels": {
-            "messageLintRule.inlang.missingTranslation": "error",
-        },
-        "plugin.inlang.i18next": {
-            pathPattern: "./examples/example01/{languageTag}.json",
-            variableReferencePattern: ["{", "}"],
-        },
+    messageLintRuleLevels: {
+        "messageLintRule.project.missingTranslation": "error",
+    },
+    "plugin.project.i18next": {
+        pathPattern: "./examples/example01/{languageTag}.json",
+        variableReferencePattern: ["{", "}"],
     },
 };
 const mockPlugin = {
-    meta: {
-        id: "plugin.inlang.i18next",
-        description: { en: "Mock plugin description" },
-        displayName: { en: "Mock Plugin" },
-    },
+    id: "plugin.project.i18next",
+    description: { en: "Mock plugin description" },
+    displayName: { en: "Mock Plugin" },
     loadMessages: () => exampleMessages,
     saveMessages: () => undefined,
     addCustomApi: () => ({
-        "app.inlang.ideExtension": {
+        "app.project.ideExtension": {
             messageReferenceMatcher: (text) => text,
         },
     }),
@@ -73,74 +69,72 @@ const exampleMessages = [
     },
 ];
 const mockMessageLintRule = {
-    meta: {
-        id: "messageLintRule.inlang.mock",
-        description: { en: "Mock lint rule description" },
-        displayName: { en: "Mock Lint Rule" },
-    },
-    message: () => undefined,
+    id: "messageLintRule.project.mock",
+    description: { en: "Mock lint rule description" },
+    displayName: { en: "Mock Lint Rule" },
+    run: () => undefined,
 };
 const _import = async (name) => ({
     default: name === "plugin.js" ? mockPlugin : mockMessageLintRule,
 });
 // ------------------------------------------------------------------------------------------------
 describe("initialization", () => {
-    describe("config", () => {
-        it("should return an error if config file is not found", async () => {
+    describe("settings", () => {
+        it("should return an error if settings file is not found", async () => {
             const fs = createNodeishMemoryFs();
-            const inlang = await openInlangProject({
-                projectFilePath: "./test.json",
+            const project = await loadProject({
+                settingsFilePath: "./test.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(inlang.errors()[0]).toBeInstanceOf(ProjectFilePathNotFoundError);
+            expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileNotFoundError);
         });
-        it("should return an error if config file is not a valid JSON", async () => {
+        it("should return an error if settings file is not a valid JSON", async () => {
             const fs = await createNodeishMemoryFs();
             await fs.writeFile("./project.inlang.json", "invalid json");
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(inlang.errors()[0]).toBeInstanceOf(ProjectFileJSONSyntaxError);
+            expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileJSONSyntaxError);
         });
-        it("should return an error if config file is does not match schema", async () => {
+        it("should return an error if settings file is does not match schema", async () => {
             const fs = await createNodeishMemoryFs();
             await fs.writeFile("./project.inlang.json", JSON.stringify({}));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(inlang.errors()[0]).toBeInstanceOf(InvalidConfigError);
+            expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsInvalidError);
         });
-        it("should return the parsed config", async () => {
+        it("should return the parsed settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(inlang.config()).toStrictEqual(config);
+            expect(project.settings()).toStrictEqual(settings);
         });
-        it("should not re-write the config to disk when initializing", async () => {
+        it("should not re-write the settings to disk when initializing", async () => {
             const fs = await createNodeishMemoryFs();
-            const configWithDeifferentFormatting = JSON.stringify(config, undefined, 4);
-            await fs.writeFile("./project.inlang.json", configWithDeifferentFormatting);
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            const settingsWithDeifferentFormatting = JSON.stringify(settings, undefined, 4);
+            await fs.writeFile("./project.inlang.json", settingsWithDeifferentFormatting);
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            const configOnDisk = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
-            expect(configOnDisk).toBe(configWithDeifferentFormatting);
-            inlang.setConfig(inlang.config());
-            // TODO: how can we await `setConfig` correctly
+            const settingsOnDisk = await fs.readFile("./project.inlang.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 newConfigOnDisk = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
-            expect(newConfigOnDisk).not.toBe(configWithDeifferentFormatting);
+            const newsettingsOnDisk = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
+            expect(newsettingsOnDisk).not.toBe(settingsWithDeifferentFormatting);
         });
     });
     describe("modules", () => {
@@ -149,13 +143,13 @@ describe("initialization", () => {
                 default: {},
             });
             const fs = createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import: $badImport,
             });
-            expect(inlang.errors()).not.toHaveLength(0);
+            expect(project.errors()).not.toHaveLength(0);
         });
         // 	it.todo("should throw if lintRules contain errors ???")
         // 	it.todo("should return meta data")
@@ -164,7 +158,7 @@ describe("initialization", () => {
     });
     describe("flow", () => {
         it.todo("should not call functions multiple times");
-        it.todo("should load modules after config");
+        it.todo("should load modules after settings");
         it.todo("should not load messages");
         it.todo("should not call lint");
     });
@@ -173,58 +167,61 @@ describe("initialization", () => {
     });
 });
 describe("functionality", () => {
-    describe("config", () => {
-        it("should return the config", async () => {
+    describe("settings", () => {
+        it("should return the settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(getValue(inlang.config)).toStrictEqual(config);
+            expect(getValue(project.settings)).toStrictEqual(settings);
         });
-        it("should set a new config", async () => {
+        it("should set a new settings", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(inlang.config()).toStrictEqual(config);
-            inlang.setConfig({ ...config, languageTags: ["en", "de"] });
-            expect(getValue(inlang.config)).toStrictEqual({ ...config, languageTags: ["en", "de"] });
-            expect(inlang.config().languageTags).toStrictEqual(["en", "de"]);
-            inlang.setConfig({ ...config, languageTags: ["en", "de", "fr"] });
-            expect(getValue(inlang.config)).toStrictEqual({ ...config, languageTags: ["en", "de", "fr"] });
-            expect(inlang.config().languageTags).toStrictEqual(["en", "de", "fr"]);
+            expect(project.settings()).toStrictEqual(settings);
+            project.setSettings({ ...settings, languageTags: ["en", "de"] });
+            expect(getValue(project.settings)).toStrictEqual({ ...settings, languageTags: ["en", "de"] });
+            expect(project.settings().languageTags).toStrictEqual(["en", "de"]);
+            project.setSettings({ ...settings, languageTags: ["en", "de", "fr"] });
+            expect(getValue(project.settings)).toStrictEqual({
+                ...settings,
+                languageTags: ["en", "de", "fr"],
+            });
+            expect(project.settings().languageTags).toStrictEqual(["en", "de", "fr"]);
         });
     });
-    describe("setConfig", () => {
-        it("should fail if config is not valid", async () => {
+    describe("setSettings", () => {
+        it("should fail if settings is not valid", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            const result = inlang.setConfig({});
+            const result = project.setSettings({});
             expect(result.data).toBeUndefined();
-            expect(result.error).toBeInstanceOf(InvalidConfigError);
+            expect(result.error).toBeInstanceOf(ProjectSettingsInvalidError);
         });
-        it("should write config to disk", async () => {
+        it("should write settings to disk", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
             const before = await fs.readFile("./project.inlang.json", { encoding: "utf-8" });
             expect(before).toBeDefined();
-            const result = inlang.setConfig({ ...config, languageTags: [] });
+            const result = project.setSettings({ ...settings, languageTags: [] });
             expect(result.data).toBeUndefined();
             expect(result.error).toBeUndefined();
             // TODO: how to wait for fs.writeFile to finish?
@@ -237,53 +234,53 @@ describe("functionality", () => {
     describe("installed", () => {
         it("should return the installed items", async () => {
             const fs = createNodeishMemoryFs();
-            const config = {
+            const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
-                settings: {},
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(inlang.installed.plugins()[0]).toStrictEqual({
-                meta: mockPlugin.meta,
-                module: config.modules[0],
+            expect(project.installed.plugins()[0]).toStrictEqual({
+                id: mockPlugin.id,
+                description: mockPlugin.description,
+                displayName: mockPlugin.displayName,
+                module: settings.modules[0],
             });
-            expect(inlang.installed.messageLintRules()[0]).toEqual({
-                meta: mockMessageLintRule.meta,
-                module: config.modules[1],
-                lintLevel: "warning",
+            expect(project.installed.messageLintRules()[0]).toEqual({
+                id: mockMessageLintRule.id,
+                description: mockMessageLintRule.description,
+                displayName: mockMessageLintRule.displayName,
+                module: settings.modules[1],
+                level: "warning",
             });
         });
-        it("should apply 'warning' as default lint level to lint rules that have no lint level defined in the config", async () => {
+        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 config = {
+            const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
-                settings: {},
             };
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(inlang.installed.messageLintRules()[0]?.lintLevel).toBe("warning");
+            expect(project.installed.messageLintRules()[0]?.level).toBe("warning");
         });
         // yep, this is a typical "hm, we have a bug here, let's write a test for it" test
         it("should return lint reports if disabled is not set", async () => {
             const _mockLintRule = {
-                meta: {
-                    id: "messageLintRule.namespace.mock",
-                    description: { en: "Mock lint rule description" },
-                    displayName: { en: "Mock Lint Rule" },
-                },
-                message: ({ report }) => {
+                id: "messageLintRule.namespace.mock",
+                description: { en: "Mock lint rule description" },
+                displayName: { en: "Mock Lint Rule" },
+                run: ({ report }) => {
                     report({
                         messageId: "some-message-1",
                         languageTag: "en",
@@ -292,11 +289,9 @@ describe("functionality", () => {
                 },
             };
             const _mockPlugin = {
-                meta: {
-                    id: "plugin.inlang.i18next",
-                    description: { en: "Mock plugin description" },
-                    displayName: { en: "Mock Plugin" },
-                },
+                id: "plugin.project.i18next",
+                description: { en: "Mock plugin description" },
+                displayName: { en: "Mock Plugin" },
                 loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
                 saveMessages: () => undefined,
             };
@@ -305,31 +300,28 @@ describe("functionality", () => {
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
-                settings: {},
             }));
             const _import = async (name) => {
                 return {
                     default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
                 };
             };
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
             await new Promise((resolve) => setTimeout(resolve, 510));
-            expect(inlang.query.messageLintReports.getAll()).toHaveLength(1);
-            expect(inlang.query.messageLintReports.getAll()?.[0]?.ruleId).toBe(_mockLintRule.meta.id);
-            expect(inlang.installed.messageLintRules()).toHaveLength(1);
+            expect(project.query.messageLintReports.getAll()).toHaveLength(1);
+            expect(project.query.messageLintReports.getAll()?.[0]?.ruleId).toBe(_mockLintRule.id);
+            expect(project.installed.messageLintRules()).toHaveLength(1);
         });
         it("should return lint reports for a single message", async () => {
             const _mockLintRule = {
-                meta: {
-                    id: "messageLintRule.namepsace.mock",
-                    description: { en: "Mock lint rule description" },
-                    displayName: { en: "Mock Lint Rule" },
-                },
-                message: ({ report }) => {
+                id: "messageLintRule.namepsace.mock",
+                description: { en: "Mock lint rule description" },
+                displayName: { en: "Mock Lint Rule" },
+                run: ({ report }) => {
                     report({
                         messageId: "some-message",
                         languageTag: "en",
@@ -338,45 +330,42 @@ describe("functionality", () => {
                 },
             };
             const _mockPlugin = {
-                meta: {
-                    id: "plugin.inlang.i18next",
-                    description: { en: "Mock plugin description" },
-                    displayName: { en: "Mock Plugin" },
-                },
+                id: "plugin.project.i18next",
+                description: { en: "Mock plugin description" },
+                displayName: { en: "Mock Plugin" },
                 loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
                 saveMessages: () => undefined,
             };
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./inlang.config.json", JSON.stringify({
+            await fs.writeFile("./project.settings.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
-                settings: {},
             }));
             const _import = async (name) => {
                 return {
                     default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
                 };
             };
-            const inlang = await openInlangProject({
-                projectFilePath: "./inlang.config.json",
+            const project = await loadProject({
+                settingsFilePath: "./project.settings.json",
                 nodeishFs: fs,
                 _import,
             });
             await new Promise((resolve) => setTimeout(resolve, 510));
-            expect(inlang.query.messageLintReports.get({ where: { messageId: "some-message" } })).toHaveLength(1);
+            expect(project.query.messageLintReports.get({ where: { messageId: "some-message" } })).toHaveLength(1);
         });
     });
     describe("errors", () => {
         it("should return the errors", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            inlang.errors.subscribe((errors) => {
+            project.errors.subscribe((errors) => {
                 expect(errors).toStrictEqual([]);
             });
         });
@@ -384,50 +373,46 @@ describe("functionality", () => {
     describe("customApi", () => {
         it("should return the app specific api", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            inlang.customApi.subscribe((api) => {
-                expect(api["app.inlang.ideExtension"]).toBeDefined();
+            project.customApi.subscribe((api) => {
+                expect(api["app.project.ideExtension"]).toBeDefined();
             });
         });
     });
     describe("messages", () => {
         it("should return the messages", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            expect(Object.values(inlang.query.messages.getAll())).toEqual(exampleMessages);
+            expect(Object.values(project.query.messages.getAll())).toEqual(exampleMessages);
         });
     });
     describe("query", () => {
-        it("updates should trigger the plugin persistence", async () => {
-            const fs = await createNodeishMemoryFs();
+        it("should call saveMessages() on updates", async () => {
+            const fs = createNodeishMemoryFs();
             await fs.writeFile("./project.inlang.json", JSON.stringify({
                 sourceLanguageTag: "en",
                 languageTags: ["en", "de"],
                 modules: ["plugin.js"],
-                settings: {
-                    "plugin.inlang.json": {
-                        pathPattern: "./resources/{languageTag}.json",
-                    },
+                "plugin.project.json": {
+                    pathPattern: "./resources/{languageTag}.json",
                 },
             }));
             await fs.mkdir("./resources");
             const mockSaveFn = vi.fn();
             const _mockPlugin = {
-                meta: {
-                    id: "plugin.inlang.json",
-                    description: { en: "Mock plugin description" },
-                    displayName: { en: "Mock Plugin" },
-                },
+                id: "plugin.project.json",
+                description: { en: "Mock plugin description" },
+                displayName: { en: "Mock Plugin" },
                 loadMessages: () => exampleMessages,
                 saveMessages: mockSaveFn,
             };
@@ -436,12 +421,12 @@ describe("functionality", () => {
                     default: _mockPlugin,
                 };
             };
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
-            await inlang.query.messages.upsert({
+            await project.query.messages.upsert({
                 where: { id: "a" },
                 data: {
                     id: "a",
@@ -470,7 +455,7 @@ describe("functionality", () => {
                     ],
                 },
             });
-            await inlang.query.messages.upsert({
+            await project.query.messages.upsert({
                 where: { id: "b" },
                 data: {
                     id: "b",
@@ -563,15 +548,15 @@ describe("functionality", () => {
     describe("lint", () => {
         it.todo("should throw if lint reports are not initialized yet", async () => {
             const fs = await createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import,
             });
             // TODO: test with real lint rules
             try {
-                inlang.query.messageLintReports.getAll.subscribe((r) => expect(r).toEqual(undefined));
+                project.query.messageLintReports.getAll.subscribe((r) => expect(r).toEqual(undefined));
                 throw new Error("Should not reach this");
             }
             catch (e) {
@@ -579,23 +564,22 @@ describe("functionality", () => {
             }
         });
         it("should return the message lint reports", async () => {
-            const config = {
+            const settings = {
                 sourceLanguageTag: "en",
                 languageTags: ["en"],
                 modules: ["lintRule.js"],
-                settings: {},
             };
             const fs = createNodeishMemoryFs();
-            await fs.writeFile("./project.inlang.json", JSON.stringify(config));
-            const inlang = await openInlangProject({
-                projectFilePath: "./project.inlang.json",
+            await fs.writeFile("./project.inlang.json", JSON.stringify(settings));
+            const project = await loadProject({
+                settingsFilePath: "./project.inlang.json",
                 nodeishFs: fs,
                 _import: async () => ({
                     default: mockMessageLintRule,
                 }),
             });
             // TODO: test with real lint rules
-            inlang.query.messageLintReports.getAll.subscribe((r) => expect(r).toEqual([]));
+            project.query.messageLintReports.getAll.subscribe((r) => expect(r).toEqual([]));
         });
     });
 });

package/dist/parseConfig.d.ts

@@ -1,8 +1,8 @@
-import { ProjectConfig } from "./versionedInterfaces.js";
+import { ProjectSettings } from "./versionedInterfaces.js";
 import type { Result } from "@inlang/result";
 export declare class ParseConfigError extends Error {
     #private;
     constructor(message: string, cause?: string);
 }
-export declare const parseConfig: (config: ProjectConfig) => Result<ProjectConfig, ParseConfigError>;
+export declare const parseSettings: (config: ProjectSettings) => Result<ProjectSettings, ParseConfigError>;
 //# sourceMappingURL=parseConfig.d.ts.map

package/dist/parseConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseConfig.d.ts","sourceRoot":"","sources":["../src/parseConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAG5C,qBAAa,gBAAiB,SAAQ,KAAK;;gBAG9B,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;CAK3C;AAKD,eAAO,MAAM,WAAW,WAAY,aAAa,KAAG,OAAO,aAAa,EAAE,gBAAgB,CAezF,CAAA"}
+{"version":3,"file":"parseConfig.d.ts","sourceRoot":"","sources":["../src/parseConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAA;AAG5C,qBAAa,gBAAiB,SAAQ,KAAK;;gBAG9B,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;CAK3C;AAKD,eAAO,MAAM,aAAa,WACjB,eAAe,KACrB,OAAO,eAAe,EAAE,gBAAgB,CAe1C,CAAA"}

package/dist/parseConfig.js

@@ -1,4 +1,4 @@
-import { ProjectConfig } from "./versionedInterfaces.js";
+import { ProjectSettings } from "./versionedInterfaces.js";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
 export class ParseConfigError extends Error {
     #id = "ParseConfigException";
@@ -9,8 +9,8 @@ export class ParseConfigError extends Error {
     }
 }
 // @ts-ignore - fix after refactor
-const ConfigCompiler = TypeCompiler.Compile(ProjectConfig);
-export const parseConfig = (config) => {
+const ConfigCompiler = TypeCompiler.Compile(ProjectSettings);
+export const parseSettings = (config) => {
     if (ConfigCompiler.Check(config)) {
         return {
             data: config,