@inlang/sdk 0.4.0 → 0.5.0

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

@@ -1,14 +1,14 @@
 import { resolveModules } from "./resolve-modules/index.js";
 import { TypeCompiler } from "@sinclair/typebox/compiler";
-import { Value } from "@sinclair/typebox/value";
-import { ProjectFilePathNotFoundError, ProjectFileJSONSyntaxError, InvalidConfigError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
+import { ProjectSettingsFileJSONSyntaxError, ProjectSettingsFileNotFoundError, ProjectSettingsInvalidError, PluginLoadMessagesError, PluginSaveMessagesError, } from "./errors.js";
 import { createRoot, createSignal, createEffect } from "./reactivity/solid.js";
 import { createMessagesQuery } from "./createMessagesQuery.js";
 import { debounce } from "throttle-debounce";
 import { createMessageLintReportsQuery } from "./createMessageLintReportsQuery.js";
-import { ProjectConfig, Message } from "./versionedInterfaces.js";
+import { ProjectSettings, Message } from "./versionedInterfaces.js";
 import { tryCatch } from "@inlang/result";
-const ConfigCompiler = TypeCompiler.Compile(ProjectConfig);
+import { migrateIfOutdated } from "@inlang/project-settings/migration";
+const settingsCompiler = TypeCompiler.Compile(ProjectSettings);
 /**
  * Creates an inlang instance.
  *
@@ -16,32 +16,32 @@ const ConfigCompiler = TypeCompiler.Compile(ProjectConfig);
  *   and supporting legacy resolvedModules such as CJS.
  *
  */
-export const openInlangProject = async (args) => {
+export const loadProject = async (args) => {
     return await createRoot(async () => {
         const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable();
-        // -- config ------------------------------------------------------------
-        const [config, _setConfig] = createSignal();
+        // -- settings ------------------------------------------------------------
+        const [settings, _setSettings] = createSignal();
         createEffect(() => {
-            loadConfig({ projectFilePath: args.projectFilePath, nodeishFs: args.nodeishFs })
-                .then((config) => {
-                setConfig(config);
-                args._capture?.("SDK used config", config);
+            loadSettings({ settingsFilePath: args.settingsFilePath, nodeishFs: args.nodeishFs })
+                .then((settings) => {
+                setSettings(settings);
+                args._capture?.("SDK used settings", settings);
             })
                 .catch((err) => {
                 markInitAsFailed(err);
             });
         });
-        // TODO: create FS watcher and update config on change
-        const writeConfigToDisk = skipFirst((config) => _writeConfigToDisk({ nodeishFs: args.nodeishFs, config }));
-        const setConfig = (config) => {
+        // TODO: create FS watcher and update settings on change
+        const writeSettingsToDisk = skipFirst((settings) => _writeSettingsToDisk({ nodeishFs: args.nodeishFs, settings }));
+        const setSettings = (settings) => {
             try {
-                const validatedConfig = validateConfig(config);
-                _setConfig(validatedConfig);
-                writeConfigToDisk(validatedConfig);
+                const validatedSettings = parseSettings(settings);
+                _setSettings(validatedSettings);
+                writeSettingsToDisk(validatedSettings);
                 return { data: undefined };
             }
             catch (error) {
-                if (error instanceof InvalidConfigError) {
+                if (error instanceof ProjectSettingsInvalidError) {
                     return { error };
                 }
                 throw new Error("unhandled");
@@ -50,10 +50,10 @@ export const openInlangProject = async (args) => {
         // -- resolvedModules -----------------------------------------------------------
         const [resolvedModules, setResolvedModules] = createSignal();
         createEffect(() => {
-            const conf = config();
-            if (!conf)
+            const _settings = settings();
+            if (!_settings)
                 return;
-            loadModules({ config: conf, nodeishFs: args.nodeishFs, _import: args._import })
+            resolveModules({ settings: _settings, nodeishFs: args.nodeishFs, _import: args._import })
                 .then((resolvedModules) => {
                 setResolvedModules(resolvedModules);
                 // TODO: handle `detectedLanguageTags`
@@ -61,11 +61,11 @@ export const openInlangProject = async (args) => {
                 .catch((err) => markInitAsFailed(err));
         });
         // -- messages ----------------------------------------------------------
-        let configValue;
-        createEffect(() => (configValue = config())); // workaround to not run effects twice (e.g. config change + modules change) (I'm sure there exists a solid way of doing this, but I haven't found it yet)
+        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)
         const [messages, setMessages] = createSignal();
         createEffect(() => {
-            const conf = config();
+            const conf = settings();
             if (!conf)
                 return;
             const _resolvedModules = resolvedModules();
@@ -76,8 +76,8 @@ export const openInlangProject = async (args) => {
                 return;
             }
             makeTrulyAsync(_resolvedModules.resolvedPluginApi.loadMessages({
-                languageTags: configValue.languageTags,
-                sourceLanguageTag: configValue.sourceLanguageTag,
+                languageTags: settingsValue.languageTags,
+                sourceLanguageTag: settingsValue.sourceLanguageTag,
             }))
                 .then((messages) => {
                 setMessages(messages);
@@ -90,29 +90,33 @@ export const openInlangProject = async (args) => {
             if (!resolvedModules())
                 return [];
             return resolvedModules().messageLintRules.map((rule) => ({
-                meta: rule.meta,
-                module: resolvedModules()?.meta.find((m) => m.id.includes(rule.meta.id))?.module ??
+                id: rule.id,
+                displayName: rule.displayName,
+                description: rule.description,
+                module: resolvedModules()?.meta.find((m) => m.id.includes(rule.id))?.module ??
                     "Unknown module. You stumbled on a bug in inlang's source code. Please open an issue.",
                 // default to warning, see https://github.com/inlang/monorepo/issues/1254
-                lintLevel: configValue.settings["project.messageLintRuleLevels"]?.[rule.meta.id] ?? "warning",
+                level: settingsValue["messageLintRuleLevels"]?.[rule.id] ?? "warning",
             }));
         };
         const installedPlugins = () => {
             if (!resolvedModules())
                 return [];
             return resolvedModules().plugins.map((plugin) => ({
-                meta: plugin.meta,
-                module: resolvedModules()?.meta.find((m) => m.id.includes(plugin.meta.id))?.module ??
+                id: plugin.id,
+                displayName: plugin.displayName,
+                description: plugin.description,
+                module: resolvedModules()?.meta.find((m) => m.id.includes(plugin.id))?.module ??
                     "Unknown module. You stumbled on a bug in inlang's source code. Please open an issue.",
             }));
         };
         // -- app ---------------------------------------------------------------
         const initializeError = await initialized.catch((error) => error);
         const messagesQuery = createMessagesQuery(() => messages() || []);
-        const lintReportsQuery = createMessageLintReportsQuery(messages, config, installedMessageLintRules, resolvedModules);
+        const lintReportsQuery = createMessageLintReportsQuery(messages, settings, installedMessageLintRules, resolvedModules);
         const debouncedSave = skipFirst(debounce(500, async (newMessages) => {
             try {
-                await resolvedModules().resolvedPluginApi.saveMessages({ messages: newMessages });
+                await resolvedModules()?.resolvedPluginApi.saveMessages({ messages: newMessages });
             }
             catch (err) {
                 throw new PluginSaveMessagesError("Error in saving messages", {
@@ -138,8 +142,8 @@ export const openInlangProject = async (args) => {
                 // have a query error exposed
                 //...(lintErrors() ?? []),
             ]),
-            config: createSubscribable(() => config()),
-            setConfig,
+            settings: createSubscribable(() => settings()),
+            setSettings,
             customApi: createSubscribable(() => resolvedModules()?.resolvedPluginApi.customApi || {}),
             query: {
                 messages: messagesQuery,
@@ -150,45 +154,45 @@ export const openInlangProject = async (args) => {
 };
 //const x = {} as InlangProject
 // ------------------------------------------------------------------------------------------------
-const loadConfig = async (args) => {
-    const { data: configFile, error: configFileError } = await tryCatch(async () => await args.nodeishFs.readFile(args.projectFilePath, { encoding: "utf-8" }));
-    if (configFileError)
-        throw new ProjectFilePathNotFoundError(`Could not locate config file in (${args.projectFilePath}).`, {
-            cause: configFileError,
+const loadSettings = async (args) => {
+    const { data: settingsFile, error: settingsFileError } = await tryCatch(async () => await args.nodeishFs.readFile(args.settingsFilePath, { encoding: "utf-8" }));
+    if (settingsFileError)
+        throw new ProjectSettingsFileNotFoundError(`Could not locate settings file in (${args.settingsFilePath}).`, {
+            cause: settingsFileError,
         });
-    const { data: parsedConfig, error: parseConfigError } = tryCatch(() => JSON.parse(configFile));
-    if (parseConfigError)
-        throw new ProjectFileJSONSyntaxError(`The config is not a valid JSON file.`, {
-            cause: parseConfigError,
+    const json = tryCatch(() => JSON.parse(settingsFile));
+    if (json.error) {
+        throw new ProjectSettingsFileJSONSyntaxError(`The settings is not a valid JSON file.`, {
+            cause: json.error,
         });
-    return validateConfig(parsedConfig);
+    }
+    return parseSettings(json.data);
 };
-const validateConfig = (config) => {
-    const typeErrors = [...ConfigCompiler.Errors(config)];
-    if (typeErrors.length > 0) {
-        throw new InvalidConfigError(`The config is invalid according to the schema.`, {
-            cause: typeErrors,
-        });
+const parseSettings = (settings) => {
+    const withMigration = migrateIfOutdated(settings);
+    if (settingsCompiler.Check(withMigration) === false) {
+        const typeErrors = [...settingsCompiler.Errors(settings)];
+        if (typeErrors.length > 0) {
+            throw new ProjectSettingsInvalidError(`The settings is invalid according to the schema.`, {
+                cause: typeErrors,
+            });
+        }
     }
-    // @ts-ignore - fix after refactor
-    return Value.Cast(ProjectConfig, config);
+    return withMigration;
 };
-const _writeConfigToDisk = async (args) => {
-    const { data: serializedConfig, error: serializeConfigError } = tryCatch(() => 
+const _writeSettingsToDisk = async (args) => {
+    const { data: serializedSettings, error: serializeSettingsError } = tryCatch(() => 
     // TODO: this will probably not match the original formatting
-    JSON.stringify(args.config, undefined, 2));
-    if (serializeConfigError)
-        throw serializeConfigError;
-    const { error: writeConfigError } = await tryCatch(async () => args.nodeishFs.writeFile("./project.inlang.json", serializedConfig));
-    if (writeConfigError)
-        throw writeConfigError;
+    JSON.stringify(args.settings, undefined, 2));
+    if (serializeSettingsError) {
+        throw serializeSettingsError;
+    }
+    const { error: writeSettingsError } = await tryCatch(async () => args.nodeishFs.writeFile("./project.inlang.json", serializedSettings));
+    if (writeSettingsError) {
+        throw writeSettingsError;
+    }
 };
 // ------------------------------------------------------------------------------------------------
-const loadModules = async (args) => resolveModules({
-    config: args.config,
-    nodeishFs: args.nodeishFs,
-    _import: args._import,
-});
 const createAwaitable = () => {
     let resolve;
     let reject;

package/dist/loadProject.test.d.ts

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

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

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