@inlang/sdk 0.3.0 → 0.5.0

package/src/{openInlangProject.ts → loadProject.ts}

@@ -7,11 +7,10 @@ import type {
 } from "./api.js"
 import { type ImportFunction, resolveModules } from "./resolve-modules/index.js"
 import { TypeCompiler } from "@sinclair/typebox/compiler"
-import { Value } from "@sinclair/typebox/value"
 import {
-	ProjectFilePathNotFoundError,
-	ProjectFileJSONSyntaxError,
-	InvalidConfigError,
+	ProjectSettingsFileJSONSyntaxError,
+	ProjectSettingsFileNotFoundError,
+	ProjectSettingsInvalidError,
 	PluginLoadMessagesError,
 	PluginSaveMessagesError,
 } from "./errors.js"
@@ -19,10 +18,11 @@ 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, type NodeishFilesystemSubset } from "./versionedInterfaces.js"
+import { ProjectSettings, Message, type NodeishFilesystemSubset } from "./versionedInterfaces.js"
 import { tryCatch, type Result } from "@inlang/result"
+import { migrateIfOutdated } from "@inlang/project-settings/migration"
 
-const ConfigCompiler = TypeCompiler.Compile(ProjectConfig)
+const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
 /**
  * Creates an inlang instance.
@@ -31,8 +31,8 @@ const ConfigCompiler = TypeCompiler.Compile(ProjectConfig)
  *   and supporting legacy resolvedModules such as CJS.
  *
  */
-export const openInlangProject = async (args: {
-	projectFilePath: string
+export const loadProject = async (args: {
+	settingsFilePath: string
 	nodeishFs: NodeishFilesystemSubset
 	_import?: ImportFunction
 	_capture?: (id: string, props: Record<string, unknown>) => void
@@ -40,34 +40,34 @@ export const openInlangProject = async (args: {
 	return await createRoot(async () => {
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
 
-		// -- config ------------------------------------------------------------
+		// -- settings ------------------------------------------------------------
 
-		const [config, _setConfig] = createSignal<ProjectConfig>()
+		const [settings, _setSettings] = createSignal<ProjectSettings>()
 		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
+		// TODO: create FS watcher and update settings on change
 
-		const writeConfigToDisk = skipFirst((config: ProjectConfig) =>
-			_writeConfigToDisk({ nodeishFs: args.nodeishFs, config }),
+		const writeSettingsToDisk = skipFirst((settings: ProjectSettings) =>
+			_writeSettingsToDisk({ nodeishFs: args.nodeishFs, settings }),
 		)
 
-		const setConfig = (config: ProjectConfig): Result<void, InvalidConfigError> => {
+		const setSettings = (settings: ProjectSettings): Result<void, ProjectSettingsInvalidError> => {
 			try {
-				const validatedConfig = validateConfig(config)
-				_setConfig(validatedConfig)
+				const validatedSettings = parseSettings(settings)
+				_setSettings(validatedSettings)
 
-				writeConfigToDisk(validatedConfig)
+				writeSettingsToDisk(validatedSettings)
 				return { data: undefined }
 			} catch (error: unknown) {
-				if (error instanceof InvalidConfigError) {
+				if (error instanceof ProjectSettingsInvalidError) {
 					return { error }
 				}
 
@@ -81,10 +81,10 @@ export const openInlangProject = async (args: {
 			createSignal<Awaited<ReturnType<typeof resolveModules>>>()
 
 		createEffect(() => {
-			const conf = config()
-			if (!conf) return
+			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)
 
@@ -95,12 +95,12 @@ export const openInlangProject = async (args: {
 
 		// -- messages ----------------------------------------------------------
 
-		let configValue: ProjectConfig
-		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: 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)
 
 		const [messages, setMessages] = createSignal<Message[]>()
 		createEffect(() => {
-			const conf = config()
+			const conf = settings()
 			if (!conf) return
 
 			const _resolvedModules = resolvedModules()
@@ -113,8 +113,8 @@ export const openInlangProject = async (args: {
 
 			makeTrulyAsync(
 				_resolvedModules.resolvedPluginApi.loadMessages({
-					languageTags: configValue!.languageTags,
-					sourceLanguageTag: configValue!.sourceLanguageTag,
+					languageTags: settingsValue!.languageTags,
+					sourceLanguageTag: settingsValue!.sourceLanguageTag,
 				}),
 			)
 				.then((messages) => {
@@ -133,14 +133,14 @@ export const openInlangProject = async (args: {
 			return resolvedModules()!.messageLintRules.map(
 				(rule) =>
 					({
-						meta: rule.meta,
+						id: rule.id,
+						displayName: rule.displayName,
+						description: rule.description,
 						module:
-							resolvedModules()?.meta.find((m) => m.id.includes(rule.meta.id))?.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",
 					} satisfies InstalledMessageLintRule),
 			) satisfies Array<InstalledMessageLintRule>
 		}
@@ -148,9 +148,11 @@ export const openInlangProject = async (args: {
 		const installedPlugins = () => {
 			if (!resolvedModules()) return []
 			return resolvedModules()!.plugins.map((plugin) => ({
-				meta: plugin.meta,
+				id: plugin.id,
+				displayName: plugin.displayName,
+				description: plugin.description,
 				module:
-					resolvedModules()?.meta.find((m) => m.id.includes(plugin.meta.id))?.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.",
 			})) satisfies Array<InstalledPlugin>
 		}
@@ -162,7 +164,7 @@ export const openInlangProject = async (args: {
 		const messagesQuery = createMessagesQuery(() => messages() || [])
 		const lintReportsQuery = createMessageLintReportsQuery(
 			messages,
-			config,
+			settings as () => ProjectSettings,
 			installedMessageLintRules,
 			resolvedModules,
 		)
@@ -172,7 +174,7 @@ export const openInlangProject = async (args: {
 				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", {
 							cause: err,
@@ -204,8 +206,8 @@ export const openInlangProject = async (args: {
 				// have a query error exposed
 				//...(lintErrors() ?? []),
 			]),
-			config: createSubscribable(() => config()),
-			setConfig,
+			settings: createSubscribable(() => settings() as ProjectSettings),
+			setSettings,
 			customApi: createSubscribable(() => resolvedModules()?.resolvedPluginApi.customApi || {}),
 			query: {
 				messages: messagesQuery,
@@ -219,70 +221,67 @@ export const openInlangProject = async (args: {
 
 // ------------------------------------------------------------------------------------------------
 
-const loadConfig = async (args: {
-	projectFilePath: string
+const loadSettings = async (args: {
+	settingsFilePath: string
 	nodeishFs: NodeishFilesystemSubset
 }) => {
-	const { data: configFile, error: configFileError } = await tryCatch(
-		async () => await args.nodeishFs.readFile(args.projectFilePath, { encoding: "utf-8" }),
+	const { data: settingsFile, error: settingsFileError } = await tryCatch(
+		async () => await args.nodeishFs.readFile(args.settingsFilePath, { encoding: "utf-8" }),
 	)
-	if (configFileError)
-		throw new ProjectFilePathNotFoundError(
-			`Could not locate config file in (${args.projectFilePath}).`,
+	if (settingsFileError)
+		throw new ProjectSettingsFileNotFoundError(
+			`Could not locate settings file in (${args.settingsFilePath}).`,
 			{
-				cause: configFileError,
+				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,
-		})
-	return validateConfig(parsedConfig)
-}
+	const json = tryCatch(() => JSON.parse(settingsFile!))
 
-const validateConfig = (config: unknown) => {
-	const typeErrors = [...ConfigCompiler.Errors(config)]
-	if (typeErrors.length > 0) {
-		throw new InvalidConfigError(`The config is invalid according to the schema.`, {
-			cause: typeErrors,
+	if (json.error) {
+		throw new ProjectSettingsFileJSONSyntaxError(`The settings is not a valid JSON file.`, {
+			cause: json.error,
 		})
 	}
+	return parseSettings(json.data)
+}
 
-	// @ts-ignore - fix after refactor
-	return Value.Cast(ProjectConfig, config)
+const parseSettings = (settings: unknown) => {
+	const withMigration = migrateIfOutdated(settings as any)
+	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,
+			})
+		}
+	}
+	return withMigration
 }
 
-const _writeConfigToDisk = async (args: {
+const _writeSettingsToDisk = async (args: {
 	nodeishFs: NodeishFilesystemSubset
-	config: ProjectConfig
+	settings: ProjectSettings
 }) => {
-	const { data: serializedConfig, error: serializeConfigError } = tryCatch(() =>
+	const { data: serializedSettings, error: serializeSettingsError } = tryCatch(() =>
 		// TODO: this will probably not match the original formatting
-		JSON.stringify(args.config, undefined, 2),
+		JSON.stringify(args.settings, undefined, 2),
 	)
-	if (serializeConfigError) throw serializeConfigError
+	if (serializeSettingsError) {
+		throw serializeSettingsError
+	}
 
-	const { error: writeConfigError } = await tryCatch(async () =>
-		args.nodeishFs.writeFile("./project.inlang.json", serializedConfig!),
+	const { error: writeSettingsError } = await tryCatch(async () =>
+		args.nodeishFs.writeFile("./project.inlang.json", serializedSettings),
 	)
-	if (writeConfigError) throw writeConfigError
+
+	if (writeSettingsError) {
+		throw writeSettingsError
+	}
 }
 
 // ------------------------------------------------------------------------------------------------
 
-const loadModules = async (args: {
-	config: ProjectConfig
-	nodeishFs: NodeishFilesystemSubset
-	_import?: ImportFunction
-}) =>
-	resolveModules({
-		config: args.config,
-		nodeishFs: args.nodeishFs,
-		_import: args._import,
-	})
-
 const createAwaitable = () => {
 	let resolve: () => void
 	let reject: () => void

package/src/parseConfig.ts

@@ -1,4 +1,4 @@
-import { ProjectConfig } from "./versionedInterfaces.js"
+import { ProjectSettings } from "./versionedInterfaces.js"
 import type { Result } from "@inlang/result"
 import { TypeCompiler } from "@sinclair/typebox/compiler"
 
@@ -13,9 +13,11 @@ export class ParseConfigError extends Error {
 }
 
 // @ts-ignore - fix after refactor
-const ConfigCompiler = TypeCompiler.Compile(ProjectConfig)
+const ConfigCompiler = TypeCompiler.Compile(ProjectSettings)
 
-export const parseConfig = (config: ProjectConfig): Result<ProjectConfig, ParseConfigError> => {
+export const parseSettings = (
+	config: ProjectSettings,
+): Result<ProjectSettings, ParseConfigError> => {
 	if (ConfigCompiler.Check(config)) {
 		return {
 			data: config,

package/src/resolve-modules/import.ts

@@ -1,4 +1,4 @@
-import { dedent } from "ts-dedent"
+import dedent from "dedent"
 import { normalizePath } from "@lix-js/fs"
 import type { NodeishFilesystemSubset } from "@inlang/plugin"
 import { ModuleImportError } from "./errors.js"

package/src/resolve-modules/message-lint-rules/resolveMessageLintRules.ts

@@ -10,7 +10,7 @@ export const resolveMessageLintRules = (args: { messageLintRules: Array<MessageL
 	for (const rule of args.messageLintRules) {
 		if (Value.Check(MessageLintRule, rule) === false) {
 			result.errors.push(
-				new MessageLintRuleIsInvalidError(`Couldn't parse lint rule "${rule.meta.id}"`, {
+				new MessageLintRuleIsInvalidError(`Couldn't parse lint rule "${rule.id}"`, {
 					module: "not implemented",
 				}),
 			)

package/src/resolve-modules/plugins/errors.ts

@@ -1,7 +1,7 @@
 import type { Plugin } from "@inlang/plugin"
 
 type PluginErrorOptions = {
-	plugin: Plugin["meta"]["id"]
+	plugin: Plugin["id"]
 } & Partial<Error>
 
 class PluginError extends Error {

package/src/resolve-modules/plugins/resolvePlugins.test.ts

@@ -15,17 +15,12 @@ import type { Plugin } from "@inlang/plugin"
 describe("generally", () => {
 	it("should return an error if a plugin uses an invalid id", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				// @ts-expect-error - invalid id
-				id: "no-namespace",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			// @ts-expect-error - invalid id
+			id: "no-namespace",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			loadMessages: () => undefined as any,
 			saveMessages: () => undefined as any,
-			addCustomApi() {
-				return {}
-			},
 		}
 
 		const resolved = await resolvePlugins({
@@ -39,11 +34,9 @@ describe("generally", () => {
 
 	it("should return an error if a plugin uses APIs that are not available", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namespace.undefinedApi",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namespace.undefinedApi",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			// @ts-expect-error the key is not available in type
 			nonExistentKey: {
 				nonexistentOptions: "value",
@@ -63,11 +56,9 @@ describe("generally", () => {
 
 	it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.inlang.notWhitelisted",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.inlang.notWhitelisted",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			loadMessages: () => undefined as any,
 		}
 
@@ -84,11 +75,9 @@ describe("generally", () => {
 describe("loadMessages", () => {
 	it("should load messages from a local source", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namespace.placeholder",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namespace.placeholder",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			loadMessages: async () => [{ id: "test", expressions: [], selectors: [], variants: [] }],
 		}
 
@@ -108,19 +97,15 @@ describe("loadMessages", () => {
 
 	it("should collect an error if function is defined twice in multiple plugins", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namepsace.loadMessagesFirst",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.loadMessagesFirst",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			loadMessages: async () => undefined as any,
 		}
 		const mockPlugin2: Plugin = {
-			meta: {
-				id: "plugin.namepsace.loadMessagesSecond",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.loadMessagesSecond",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			loadMessages: async () => undefined as any,
 		}
 
@@ -135,11 +120,9 @@ describe("loadMessages", () => {
 
 	it("should return an error if no plugin defines loadMessages", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namepsace.loadMessagesFirst",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.loadMessagesFirst",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			saveMessages: async () => undefined as any,
 		}
 
@@ -157,11 +140,9 @@ describe("loadMessages", () => {
 describe("saveMessages", () => {
 	it("should save messages to a local source", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namespace.placeholder",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namespace.placeholder",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			loadMessages: async () => undefined as any,
 			saveMessages: async () => undefined as any,
 		}
@@ -177,19 +158,15 @@ describe("saveMessages", () => {
 
 	it("should collect an error if function is defined twice in multiple plugins", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namepsace.saveMessages",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.saveMessages",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			saveMessages: async () => undefined as any,
 		}
 		const mockPlugin2: Plugin = {
-			meta: {
-				id: "plugin.namepsace.saveMessages2",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.saveMessages2",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 
 			saveMessages: async () => undefined as any,
 		}
@@ -205,11 +182,9 @@ describe("saveMessages", () => {
 
 	it("should return an error if no plugin defines saveMessages", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namepsace.loadMessagesFirst",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.loadMessagesFirst",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			loadMessages: async () => undefined as any,
 		}
 
@@ -226,22 +201,18 @@ describe("saveMessages", () => {
 describe("detectedLanguageTags", () => {
 	it("should merge language tags from plugins", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namepsace.detectedLanguageTags",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.detectedLanguageTags",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			detectedLanguageTags: async () => ["de", "en"],
 			addCustomApi: () => {
 				return {}
 			},
 		}
 		const mockPlugin2: Plugin = {
-			meta: {
-				id: "plugin.namepsace.detectedLanguageTags2",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.detectedLanguageTags2",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			addCustomApi: () => {
 				return {}
 			},
@@ -261,11 +232,9 @@ describe("detectedLanguageTags", () => {
 describe("addCustomApi", () => {
 	it("it should resolve app specific api", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namespace.placeholder",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namespace.placeholder",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 
 			addCustomApi: () => ({
 				"my-app": {
@@ -285,11 +254,9 @@ describe("addCustomApi", () => {
 
 	it("it should resolve multiple app specific apis", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namespace.placeholder",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namespace.placeholder",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			addCustomApi: () => ({
 				"my-app-1": {
 					functionOfMyApp1: () => undefined as any,
@@ -300,11 +267,9 @@ describe("addCustomApi", () => {
 			}),
 		}
 		const mockPlugin2: Plugin = {
-			meta: {
-				id: "plugin.namespace.placeholder2",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namespace.placeholder2",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 
 			addCustomApi: () => ({
 				"my-app-3": {
@@ -326,11 +291,9 @@ describe("addCustomApi", () => {
 
 	it("it should throw an error if return value is not an object", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namespace.placeholder",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namespace.placeholder",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			// @ts-expect-error - invalid return type
 			addCustomApi: () => undefined,
 		}
@@ -346,11 +309,9 @@ describe("addCustomApi", () => {
 
 	it("it should throw an error if the passed options are not defined inside customApi", async () => {
 		const mockPlugin: Plugin = {
-			meta: {
-				id: "plugin.namepsace.placeholder",
-				description: { en: "My plugin description" },
-				displayName: { en: "My plugin" },
-			},
+			id: "plugin.namepsace.placeholder",
+			description: { en: "My plugin description" },
+			displayName: { en: "My plugin" },
 			addCustomApi: () => ({
 				"app.inlang.placeholder": {
 					messageReferenceMatcher: () => {