@inlang/sdk 0.4.0 → 0.6.0

package/src/api.ts

@@ -6,13 +6,15 @@ import type {
 	MessageLintRule,
 	Message,
 	Plugin,
-	ProjectConfig,
+	ProjectSettings,
 	MessageLintReport,
 } from "./versionedInterfaces.js"
 import type { ResolvedPluginApi } from "./resolve-modules/plugins/types.js"
 
 export type InstalledPlugin = {
-	meta: Plugin["meta"]
+	id: Plugin["id"]
+	displayName: Plugin["displayName"]
+	description: Plugin["description"]
 	/**
 	 * The module which the plugin is installed from.
 	 */
@@ -21,12 +23,14 @@ export type InstalledPlugin = {
 }
 
 export type InstalledMessageLintRule = {
-	meta: MessageLintRule["meta"]
+	id: MessageLintRule["id"]
+	displayName: MessageLintRule["displayName"]
+	description: MessageLintRule["description"]
 	/**
 	 * The module which the lint rule is installed from.
 	 */
 	module: string
-	lintLevel: MessageLintLevel
+	level: MessageLintLevel
 }
 
 export type InlangProject = {
@@ -38,8 +42,8 @@ export type InlangProject = {
 		((typeof ModuleResolutionError)[keyof typeof ModuleResolutionError] | Error)[]
 	>
 	customApi: Subscribable<ResolvedPluginApi["customApi"]>
-	config: Subscribable<ProjectConfig | undefined>
-	setConfig: (config: ProjectConfig) => Result<void, RuntimeError.InvalidConfigError>
+	settings: Subscribable<ProjectSettings>
+	setSettings: (config: ProjectSettings) => Result<void, RuntimeError.ProjectSettingsInvalidError>
 	query: {
 		messages: MessageQueryApi
 		messageLintReports: MessageLintReportsQueryApi

package/src/createMessageLintReportsQuery.ts

@@ -1,14 +1,9 @@
 import { createEffect } from "./reactivity/solid.js"
-import { createSubscribable } from "./openInlangProject.js"
+import { createSubscribable } from "./loadProject.js"
 import type { InlangProject, InstalledMessageLintRule, MessageLintReportsQueryApi } from "./api.js"
-import type { ProjectConfig } from "@inlang/project-config"
+import type { ProjectSettings } from "@inlang/project-settings"
 import type { resolveModules } from "./resolve-modules/index.js"
-import type {
-	JSONObject,
-	MessageLintReport,
-	MessageLintRule,
-	Message,
-} from "./versionedInterfaces.js"
+import type { MessageLintReport, Message } from "./versionedInterfaces.js"
 import { lintSingleMessage } from "./lint/index.js"
 import { ReactiveMap } from "./reactivity/map.js"
 
@@ -17,7 +12,7 @@ import { ReactiveMap } from "./reactivity/map.js"
  */
 export function createMessageLintReportsQuery(
 	messages: () => Array<Message> | undefined,
-	config: () => ProjectConfig | undefined,
+	settings: () => ProjectSettings,
 	installedMessageLintRules: () => Array<InstalledMessageLintRule>,
 	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined,
 ): InlangProject["query"]["messageLintReports"] {
@@ -25,25 +20,25 @@ export function createMessageLintReportsQuery(
 	const index = new ReactiveMap<MessageLintReport["messageId"], MessageLintReport[]>()
 
 	createEffect(() => {
-		const msgs = messages()
-		const conf = config()
 		const modules = resolvedModules()
+		const _messages = messages()
+		const _settings = settings()
 
-		if (msgs && conf && modules) {
+		if (_messages && _settings && modules) {
 			// console.log("new calculation")
 			// index.clear()
-			for (const message of msgs) {
+			for (const message of _messages) {
 				// TODO: only lint changed messages and update arrays selectively
 
 				lintSingleMessage({
 					rules: modules.messageLintRules,
-					ruleSettings: conf.settings as Record<MessageLintRule["meta"]["id"], JSONObject>,
-					ruleLevels: Object.fromEntries(
-						installedMessageLintRules().map((rule) => [rule.meta.id, rule.lintLevel]),
-					),
-					sourceLanguageTag: conf.sourceLanguageTag,
-					languageTags: conf.languageTags,
-					messages: msgs,
+					settings: {
+						..._settings,
+						messageLintRuleLevels: Object.fromEntries(
+							installedMessageLintRules().map((rule) => [rule.id, rule.level]),
+						),
+					},
+					messages: _messages,
 					message: message,
 				}).then((report) => {
 					if (

package/src/createMessagesQuery.ts

@@ -1,7 +1,7 @@
 import type { Message } from "@inlang/message"
 import { ReactiveMap } from "./reactivity/map.js"
 import { createEffect } from "./reactivity/solid.js"
-import { createSubscribable } from "./openInlangProject.js"
+import { createSubscribable } from "./loadProject.js"
 import type { InlangProject, MessageQueryApi } from "./api.js"
 
 /**

package/src/errors.ts

@@ -1,21 +1,21 @@
-export class InvalidConfigError extends Error {
+export class ProjectSettingsInvalidError extends Error {
 	constructor(message: string, options: ErrorOptions) {
 		super(message, options)
-		this.name = "InvalidConfigError"
+		this.name = "ProjectSettingsInvalidError"
 	}
 }
 
-export class ProjectFileJSONSyntaxError extends Error {
+export class ProjectSettingsFileJSONSyntaxError extends Error {
 	constructor(message: string, options: ErrorOptions) {
 		super(message, options)
-		this.name = "ProjectFileJSONSyntaxError"
+		this.name = "ProjectSettingsFileJSONSyntaxError"
 	}
 }
 
-export class ProjectFilePathNotFoundError extends Error {
+export class ProjectSettingsFileNotFoundError extends Error {
 	constructor(message: string, options: ErrorOptions) {
 		super(message, options)
-		this.name = "ProjectFilePathNotFoundError"
+		this.name = "ProjectSettingsFileNotFoundError"
 	}
 }
 

package/src/index.ts

@@ -12,13 +12,13 @@ export type {
 	Subscribable,
 } from "./api.js"
 export { type ImportFunction, createImport } from "./resolve-modules/index.js"
-export { openInlangProject } from "./openInlangProject.js"
+export { loadProject } from "./loadProject.js"
 export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js"
 export { createMessagesQuery } from "./createMessagesQuery.js"
 export {
-	ProjectFilePathNotFoundError,
-	ProjectFileJSONSyntaxError,
-	InvalidConfigError,
+	ProjectSettingsFileJSONSyntaxError,
+	ProjectSettingsFileNotFoundError,
+	ProjectSettingsInvalidError,
 	PluginLoadMessagesError,
 	PluginSaveMessagesError,
 } from "./errors.js"

package/src/lint/message/lintMessages.test.ts

@@ -4,21 +4,17 @@ import type { MessageLintReport, MessageLintRule } from "@inlang/message-lint-ru
 import type { Message } from "@inlang/message"
 
 const lintRule1 = {
-	meta: {
-		id: "messageLintRule.x.1",
-		displayName: { en: "" },
-		description: { en: "" },
-	},
-	message: vi.fn(),
+	id: "messageLintRule.x.1",
+	displayName: { en: "" },
+	description: { en: "" },
+	run: vi.fn(),
 } satisfies MessageLintRule
 
 const lintRule2 = {
-	meta: {
-		id: "messageLintRule.x.2",
-		displayName: { en: "" },
-		description: { en: "" },
-	},
-	message: vi.fn(),
+	id: "messageLintRule.x.2",
+	displayName: { en: "" },
+	description: { en: "" },
+	run: vi.fn(),
 } satisfies MessageLintRule
 
 const message1 = { id: "m1" } as Message
@@ -34,50 +30,54 @@ describe("lintMessages", async () => {
 
 	test("it should await all messages", async () => {
 		let called = 0
-		lintRule2.message.mockImplementation(async () => {
+		lintRule2.run.mockImplementation(async () => {
 			await new Promise((resolve) => setTimeout(resolve, 0))
 			called++
 		})
 
 		await lintMessages({
-			ruleLevels: {
-				[lintRule1.meta.id]: "warning",
-				[lintRule2.meta.id]: "warning",
+			settings: {
+				sourceLanguageTag: "en",
+				languageTags: [],
+				modules: [],
+				messageLintRuleLevels: {
+					[lintRule1.id]: "warning",
+					[lintRule2.id]: "warning",
+				},
 			},
-			ruleSettings: {},
-			sourceLanguageTag: "en",
-			languageTags: [],
 			messages,
 			rules: [lintRule1, lintRule2],
 		})
 
-		expect(lintRule1.message).toHaveBeenCalledTimes(3)
+		expect(lintRule1.run).toHaveBeenCalledTimes(3)
 		expect(called).toBe(3)
 	})
 
 	test("it should process all messages and rules in parallel", async () => {
 		const fn = vi.fn()
 
-		lintRule1.message.mockImplementation(async ({ message }) => {
+		lintRule1.run.mockImplementation(async ({ message }) => {
 			fn("r1", "before", message.id)
 			await new Promise((resolve) => setTimeout(resolve, 0))
 			fn("r1", "after", message.id)
 		})
-		lintRule2.message.mockImplementation(async ({ message }) => {
+		lintRule2.run.mockImplementation(async ({ message }) => {
 			fn("r2", "before", message.id)
 			await new Promise((resolve) => setTimeout(resolve, 0))
 			fn("r2", "after", message.id)
 		})
 
 		await lintMessages({
-			ruleLevels: {
-				[lintRule1.meta.id]: "warning",
-				[lintRule2.meta.id]: "warning",
+			settings: {
+				sourceLanguageTag: "en",
+				languageTags: [],
+				modules: [],
+				messageLintRuleLevels: {
+					[lintRule1.id]: "warning",
+					[lintRule2.id]: "warning",
+				},
 			},
-			ruleSettings: {},
 			rules: [lintRule1, lintRule2],
-			sourceLanguageTag: "en",
-			languageTags: [],
 			messages,
 		})
 
@@ -97,21 +97,23 @@ describe("lintMessages", async () => {
 	})
 
 	test("it should not abort the linting process when errors occur", async () => {
-		lintRule1.message.mockImplementation(({ report }) => {
+		lintRule1.run.mockImplementation(({ report }) => {
 			report({} as MessageLintReport)
 		})
-		lintRule2.message.mockImplementation(() => {
+		lintRule2.run.mockImplementation(() => {
 			throw new Error("error")
 		})
 
 		const { data, errors } = await lintMessages({
-			ruleLevels: {
-				[lintRule1.meta.id]: "warning",
-				[lintRule2.meta.id]: "warning",
+			settings: {
+				sourceLanguageTag: "en",
+				languageTags: [],
+				modules: [],
+				messageLintRuleLevels: {
+					[lintRule1.id]: "warning",
+					[lintRule2.id]: "warning",
+				},
 			},
-			ruleSettings: {},
-			sourceLanguageTag: "en",
-			languageTags: [],
 			messages,
 			rules: [lintRule1, lintRule2],
 		})

package/src/lint/message/lintMessages.ts

@@ -1,19 +1,11 @@
 import type { Message } from "@inlang/message"
 import { lintSingleMessage } from "./lintSingleMessage.js"
 import type { MessagedLintRuleThrowedError } from "./errors.js"
-import type { LanguageTag } from "@inlang/language-tag"
-import type { JSONObject } from "@inlang/json-types"
-import type {
-	MessageLintLevel,
-	MessageLintReport,
-	MessageLintRule,
-} from "@inlang/message-lint-rule"
+import type { MessageLintReport, MessageLintRule } from "@inlang/message-lint-rule"
+import type { ProjectSettings } from "@inlang/project-settings"
 
 export const lintMessages = async (args: {
-	sourceLanguageTag: LanguageTag
-	languageTags: LanguageTag[]
-	ruleSettings: Record<MessageLintRule["meta"]["id"], JSONObject>
-	ruleLevels: Record<MessageLintRule["meta"]["id"], MessageLintLevel>
+	settings: ProjectSettings & Required<Pick<ProjectSettings, "messageLintRuleLevels">>
 	rules: MessageLintRule[]
 	messages: Message[]
 }): Promise<{ data: MessageLintReport[]; errors: MessagedLintRuleThrowedError[] }> => {

package/src/lint/message/lintSingleMessage.test.ts

@@ -5,21 +5,17 @@ import type { Message } from "@inlang/message"
 import { tryCatch } from "@inlang/result"
 
 const lintRule1 = {
-	meta: {
-		id: "messageLintRule.r.1",
-		displayName: { en: "" },
-		description: { en: "" },
-	},
-	message: vi.fn(),
+	id: "messageLintRule.r.1",
+	displayName: "",
+	description: "",
+	run: vi.fn(),
 } satisfies MessageLintRule
 
 const lintRule2 = {
-	meta: {
-		id: "messageLintRule.r.2",
-		displayName: { en: "" },
-		description: { en: "" },
-	},
-	message: vi.fn(),
+	id: "messageLintRule.r.2",
+	displayName: "",
+	description: "",
+	run: vi.fn(),
 } satisfies MessageLintRule
 
 const message1 = {} as Message
@@ -35,14 +31,16 @@ describe("lintSingleMessage", async () => {
 		// the lint function is un-opinionated and does not set a default level.
 		// opinionated users like the inlang instance can very well set a default level (separation of concerns)
 		test("it should throw if a lint level is not provided for a given lint rule", async () => {
-			lintRule1.message.mockImplementation(({ report }) => report({} as MessageLintReport))
+			lintRule1.run.mockImplementation(({ report }) => report({} as MessageLintReport))
 
 			const result = await tryCatch(() =>
 				lintSingleMessage({
-					ruleLevels: {},
-					ruleSettings: {},
-					sourceLanguageTag: "en",
-					languageTags: ["en"],
+					settings: {
+						sourceLanguageTag: "en",
+						languageTags: ["en"],
+						messageLintRuleLevels: {},
+						modules: [],
+					},
 					messages,
 					message: message1,
 					rules: [lintRule1],
@@ -53,15 +51,17 @@ describe("lintSingleMessage", async () => {
 		})
 
 		test("it should override the default lint level", async () => {
-			lintRule1.message.mockImplementation(({ report }) => report({} as MessageLintReport))
+			lintRule1.run.mockImplementation(({ report }) => report({} as MessageLintReport))
 
 			const reports = await lintSingleMessage({
-				ruleLevels: {
-					[lintRule1.meta.id]: "error",
+				settings: {
+					sourceLanguageTag: "en",
+					languageTags: ["en"],
+					modules: [],
+					messageLintRuleLevels: {
+						[lintRule1.id]: "error",
+					},
 				},
-				ruleSettings: {},
-				sourceLanguageTag: "en",
-				languageTags: ["en"],
 				messages,
 				message: message1,
 				rules: [lintRule1],
@@ -70,20 +70,20 @@ describe("lintSingleMessage", async () => {
 		})
 
 		test("it should pass the correct settings", async () => {
-			const settings = {}
+			const settings = {
+				sourceLanguageTag: "en",
+				languageTags: ["en"],
+				modules: [],
+				messageLintRuleLevels: {
+					[lintRule1.id as any]: "warning",
+				},
+			}
 
 			const fn = vi.fn()
-			lintRule1.message.mockImplementation(({ settings }) => fn(settings))
+			lintRule1.run.mockImplementation(({ settings }) => fn(settings))
 
 			await lintSingleMessage({
-				ruleLevels: {
-					[lintRule1.meta.id]: "warning",
-				},
-				ruleSettings: {
-					[lintRule1.meta.id]: settings,
-				},
-				sourceLanguageTag: "en",
-				languageTags: ["en"],
+				settings,
 				messages,
 				message: message1,
 				rules: [lintRule1],
@@ -96,22 +96,24 @@ describe("lintSingleMessage", async () => {
 	test("it should await all rules", async () => {
 		let m1Called = false
 		let m2Called = false
-		lintRule1.message.mockImplementation(() => {
+		lintRule1.run.mockImplementation(() => {
 			m1Called = true
 		})
-		lintRule2.message.mockImplementation(async () => {
+		lintRule2.run.mockImplementation(async () => {
 			await new Promise((resolve) => setTimeout(resolve, 0))
 			m2Called = true
 		})
 
 		await lintSingleMessage({
-			ruleLevels: {
-				[lintRule1.meta.id]: "warning",
-				[lintRule2.meta.id]: "warning",
+			settings: {
+				sourceLanguageTag: "en",
+				languageTags: ["en"],
+				modules: [],
+				messageLintRuleLevels: {
+					[lintRule1.id]: "warning",
+					[lintRule2.id]: "warning",
+				},
 			},
-			ruleSettings: {},
-			sourceLanguageTag: "en",
-			languageTags: ["en"],
 			messages,
 			message: message1,
 			rules: [lintRule1, lintRule2],
@@ -124,54 +126,58 @@ describe("lintSingleMessage", async () => {
 	test("it should process all rules in parallel", async () => {
 		const fn = vi.fn()
 
-		lintRule1.message.mockImplementation(async () => {
-			fn(lintRule1.meta.id, "before")
+		lintRule1.run.mockImplementation(async () => {
+			fn(lintRule1.id, "before")
 			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn(lintRule1.meta.id, "after")
+			fn(lintRule1.id, "after")
 		})
-		lintRule2.message.mockImplementation(async () => {
-			fn(lintRule2.meta.id, "before")
+		lintRule2.run.mockImplementation(async () => {
+			fn(lintRule2.id, "before")
 			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn(lintRule2.meta.id, "after")
+			fn(lintRule2.id, "after")
 		})
 
 		await lintSingleMessage({
-			ruleLevels: {
-				[lintRule1.meta.id]: "warning",
-				[lintRule2.meta.id]: "warning",
+			settings: {
+				sourceLanguageTag: "en",
+				languageTags: ["en"],
+				modules: [],
+				messageLintRuleLevels: {
+					[lintRule1.id]: "warning",
+					[lintRule2.id]: "warning",
+				},
 			},
-			ruleSettings: {},
-			sourceLanguageTag: "en",
-			languageTags: ["en"],
 			messages,
 			message: message1,
 			rules: [lintRule1, lintRule2],
 		})
 
 		expect(fn).toHaveBeenCalledTimes(4)
-		expect(fn).toHaveBeenNthCalledWith(1, lintRule1.meta.id, "before")
-		expect(fn).toHaveBeenNthCalledWith(2, lintRule2.meta.id, "before")
-		expect(fn).toHaveBeenNthCalledWith(3, lintRule1.meta.id, "after")
-		expect(fn).toHaveBeenNthCalledWith(4, lintRule2.meta.id, "after")
+		expect(fn).toHaveBeenNthCalledWith(1, lintRule1.id, "before")
+		expect(fn).toHaveBeenNthCalledWith(2, lintRule2.id, "before")
+		expect(fn).toHaveBeenNthCalledWith(3, lintRule1.id, "after")
+		expect(fn).toHaveBeenNthCalledWith(4, lintRule2.id, "after")
 	})
 
 	test("it should not abort the linting process when errors occur", async () => {
-		lintRule1.message.mockImplementation(() => {
+		lintRule1.run.mockImplementation(() => {
 			throw new Error("error")
 		})
 
-		lintRule2.message.mockImplementation(({ report }) => {
+		lintRule2.run.mockImplementation(({ report }) => {
 			report({} as MessageLintReport)
 		})
 
 		const result = await lintSingleMessage({
-			ruleLevels: {
-				[lintRule1.meta.id]: "warning",
-				[lintRule2.meta.id]: "warning",
+			settings: {
+				sourceLanguageTag: "en",
+				languageTags: ["en"],
+				modules: [],
+				messageLintRuleLevels: {
+					[lintRule1.id]: "warning",
+					[lintRule2.id]: "warning",
+				},
 			},
-			ruleSettings: {},
-			sourceLanguageTag: "en",
-			languageTags: ["en"],
 			messages,
 			message: message1,
 			rules: [lintRule1, lintRule2],

package/src/lint/message/lintSingleMessage.ts

@@ -1,12 +1,7 @@
-import type {
-	MessageLintLevel,
-	MessageLintRule,
-	MessageLintReport,
-} from "@inlang/message-lint-rule"
+import type { MessageLintRule, MessageLintReport } from "@inlang/message-lint-rule"
 import type { Message } from "@inlang/message"
 import { MessagedLintRuleThrowedError } from "./errors.js"
-import type { LanguageTag } from "@inlang/language-tag"
-import type { JSONObject } from "@inlang/json-types"
+import type { ProjectSettings } from "@inlang/project-settings"
 
 /**
  * Lint a single message.
@@ -14,10 +9,7 @@ import type { JSONObject } from "@inlang/json-types"
  * - the lint rule levels defaults to `warning`.
  */
 export const lintSingleMessage = async (args: {
-	sourceLanguageTag: LanguageTag
-	languageTags: LanguageTag[]
-	ruleSettings: Record<MessageLintRule["meta"]["id"], JSONObject>
-	ruleLevels: Record<MessageLintRule["meta"]["id"], MessageLintLevel>
+	settings: ProjectSettings & Required<Pick<ProjectSettings, "messageLintRuleLevels">>
 	rules: MessageLintRule[]
 	messages: Message[]
 	message: Message
@@ -26,30 +18,30 @@ export const lintSingleMessage = async (args: {
 	const errors: MessagedLintRuleThrowedError[] = []
 
 	const promises = args.rules.map(async (rule) => {
-		const ruleId = rule.meta.id
-		const settings = args.ruleSettings?.[ruleId] ?? {}
-		const level = args.ruleLevels?.[ruleId]
+		const level = args.settings.messageLintRuleLevels?.[rule.id]
 
 		if (level === undefined) {
-			throw Error("No lint level provided for lint rule: " + ruleId)
+			throw Error("No lint level provided for lint rule: " + rule.id)
 		}
 
 		try {
-			await rule.message({
-				...args,
-				settings,
+			await rule.run({
+				message: args.message,
+				settings: args.settings,
 				report: (reportArgs) => {
 					reports.push({
-						ruleId,
+						ruleId: rule.id,
 						level,
-						...reportArgs,
+						messageId: reportArgs.messageId,
+						languageTag: reportArgs.languageTag,
+						body: reportArgs.body,
 					})
 				},
 			})
 		} catch (error) {
 			errors.push(
 				new MessagedLintRuleThrowedError(
-					`Lint rule '${ruleId}' throwed while linting message "${args.message.id}".`,
+					`Lint rule '${rule.id}' throwed while linting message "${args.message.id}".`,
 					{ cause: error },
 				),
 			)