@inlang/sdk 0.1.0

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

@@ -0,0 +1,122 @@
+import { beforeEach, describe, expect, test, vi } from "vitest"
+import { lintMessages } from "./lintMessages.js"
+import type { MessageLintReport, MessageLintRule } from "@inlang/message-lint-rule"
+import type { Message } from "@inlang/message"
+
+const lintRule1 = {
+	meta: {
+		id: "messageLintRule.x.1",
+		displayName: { en: "" },
+		description: { en: "" },
+	},
+	message: vi.fn(),
+} satisfies MessageLintRule
+
+const lintRule2 = {
+	meta: {
+		id: "messageLintRule.x.2",
+		displayName: { en: "" },
+		description: { en: "" },
+	},
+	message: vi.fn(),
+} satisfies MessageLintRule
+
+const message1 = { id: "m1" } as Message
+const message2 = { id: "m2" } as Message
+const message3 = { id: "m3" } as Message
+
+const messages = [message1, message2, message3]
+
+describe("lintMessages", async () => {
+	beforeEach(() => {
+		vi.resetAllMocks()
+	})
+
+	test("it should await all messages", async () => {
+		let called = 0
+		lintRule2.message.mockImplementation(async () => {
+			await new Promise((resolve) => setTimeout(resolve, 0))
+			called++
+		})
+
+		await lintMessages({
+			ruleLevels: {
+				[lintRule1.meta.id]: "warning",
+				[lintRule2.meta.id]: "warning",
+			},
+			ruleSettings: {},
+			sourceLanguageTag: "en",
+			languageTags: [],
+			messages,
+			rules: [lintRule1, lintRule2],
+		})
+
+		expect(lintRule1.message).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 }) => {
+			fn("r1", "before", message.id)
+			await new Promise((resolve) => setTimeout(resolve, 0))
+			fn("r1", "after", message.id)
+		})
+		lintRule2.message.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",
+			},
+			ruleSettings: {},
+			rules: [lintRule1, lintRule2],
+			sourceLanguageTag: "en",
+			languageTags: [],
+			messages,
+		})
+
+		expect(fn).toHaveBeenCalledTimes(12)
+		expect(fn).toHaveBeenNthCalledWith(1, "r1", "before", "m1")
+		expect(fn).toHaveBeenNthCalledWith(2, "r2", "before", "m1")
+		expect(fn).toHaveBeenNthCalledWith(3, "r1", "before", "m2")
+		expect(fn).toHaveBeenNthCalledWith(4, "r2", "before", "m2")
+		expect(fn).toHaveBeenNthCalledWith(5, "r1", "before", "m3")
+		expect(fn).toHaveBeenNthCalledWith(6, "r2", "before", "m3")
+		expect(fn).toHaveBeenNthCalledWith(7, "r1", "after", "m1")
+		expect(fn).toHaveBeenNthCalledWith(8, "r2", "after", "m1")
+		expect(fn).toHaveBeenNthCalledWith(9, "r1", "after", "m2")
+		expect(fn).toHaveBeenNthCalledWith(10, "r2", "after", "m2")
+		expect(fn).toHaveBeenNthCalledWith(11, "r1", "after", "m3")
+		expect(fn).toHaveBeenNthCalledWith(12, "r2", "after", "m3")
+	})
+
+	test("it should not abort the linting process when errors occur", async () => {
+		lintRule1.message.mockImplementation(({ report }) => {
+			report({} as MessageLintReport)
+		})
+		lintRule2.message.mockImplementation(() => {
+			throw new Error("error")
+		})
+
+		const { data, errors } = await lintMessages({
+			ruleLevels: {
+				[lintRule1.meta.id]: "warning",
+				[lintRule2.meta.id]: "warning",
+			},
+			ruleSettings: {},
+			sourceLanguageTag: "en",
+			languageTags: [],
+			messages,
+			rules: [lintRule1, lintRule2],
+		})
+
+		expect(data).toHaveLength(3)
+		expect(errors).toHaveLength(3)
+	})
+})

package/src/lint/message/lintMessages.ts

@@ -0,0 +1,33 @@
+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"
+
+export const lintMessages = async (args: {
+	sourceLanguageTag: LanguageTag
+	languageTags: LanguageTag[]
+	ruleSettings: Record<MessageLintRule["meta"]["id"], JSONObject>
+	ruleLevels: Record<MessageLintRule["meta"]["id"], MessageLintLevel>
+	rules: MessageLintRule[]
+	messages: Message[]
+}): Promise<{ data: MessageLintReport[]; errors: MessagedLintRuleThrowedError[] }> => {
+	const promises = args.messages.map((message) =>
+		lintSingleMessage({
+			...args,
+			message,
+		}),
+	)
+
+	const results = await Promise.all(promises)
+
+	return {
+		data: results.flatMap((result) => result.data).filter(Boolean),
+		errors: results.flatMap((result) => result.errors).filter(Boolean),
+	}
+}

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

@@ -0,0 +1,183 @@
+import { beforeEach, describe, expect, test, vi } from "vitest"
+import { lintSingleMessage } from "./lintSingleMessage.js"
+import type { MessageLintReport, MessageLintRule } from "@inlang/message-lint-rule"
+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(),
+} satisfies MessageLintRule
+
+const lintRule2 = {
+	meta: {
+		id: "messageLintRule.r.2",
+		displayName: { en: "" },
+		description: { en: "" },
+	},
+	message: vi.fn(),
+} satisfies MessageLintRule
+
+const message1 = {} as Message
+
+const messages = [message1]
+
+describe("lintSingleMessage", async () => {
+	beforeEach(() => {
+		vi.resetAllMocks()
+	})
+
+	describe("resolve rules and settings", 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))
+
+			const result = await tryCatch(() =>
+				lintSingleMessage({
+					ruleLevels: {},
+					ruleSettings: {},
+					sourceLanguageTag: "en",
+					languageTags: ["en"],
+					messages,
+					message: message1,
+					rules: [lintRule1],
+				}),
+			)
+			expect(result.error).toBeDefined()
+			expect(result.data).toBeUndefined()
+		})
+
+		test("it should override the default lint level", async () => {
+			lintRule1.message.mockImplementation(({ report }) => report({} as MessageLintReport))
+
+			const reports = await lintSingleMessage({
+				ruleLevels: {
+					[lintRule1.meta.id]: "error",
+				},
+				ruleSettings: {},
+				sourceLanguageTag: "en",
+				languageTags: ["en"],
+				messages,
+				message: message1,
+				rules: [lintRule1],
+			})
+			expect(reports.data[0]?.level).toBe("error")
+		})
+
+		test("it should pass the correct settings", async () => {
+			const settings = {}
+
+			const fn = vi.fn()
+			lintRule1.message.mockImplementation(({ settings }) => fn(settings))
+
+			await lintSingleMessage({
+				ruleLevels: {
+					[lintRule1.meta.id]: "warning",
+				},
+				ruleSettings: {
+					[lintRule1.meta.id]: settings,
+				},
+				sourceLanguageTag: "en",
+				languageTags: ["en"],
+				messages,
+				message: message1,
+				rules: [lintRule1],
+			})
+
+			expect(fn).toHaveBeenCalledWith(settings)
+		})
+	})
+
+	test("it should await all rules", async () => {
+		let m1Called = false
+		let m2Called = false
+		lintRule1.message.mockImplementation(() => {
+			m1Called = true
+		})
+		lintRule2.message.mockImplementation(async () => {
+			await new Promise((resolve) => setTimeout(resolve, 0))
+			m2Called = true
+		})
+
+		await lintSingleMessage({
+			ruleLevels: {
+				[lintRule1.meta.id]: "warning",
+				[lintRule2.meta.id]: "warning",
+			},
+			ruleSettings: {},
+			sourceLanguageTag: "en",
+			languageTags: ["en"],
+			messages,
+			message: message1,
+			rules: [lintRule1, lintRule2],
+		})
+
+		expect(m1Called).toBe(true)
+		expect(m2Called).toBe(true)
+	})
+
+	test("it should process all rules in parallel", async () => {
+		const fn = vi.fn()
+
+		lintRule1.message.mockImplementation(async () => {
+			fn(lintRule1.meta.id, "before")
+			await new Promise((resolve) => setTimeout(resolve, 0))
+			fn(lintRule1.meta.id, "after")
+		})
+		lintRule2.message.mockImplementation(async () => {
+			fn(lintRule2.meta.id, "before")
+			await new Promise((resolve) => setTimeout(resolve, 0))
+			fn(lintRule2.meta.id, "after")
+		})
+
+		await lintSingleMessage({
+			ruleLevels: {
+				[lintRule1.meta.id]: "warning",
+				[lintRule2.meta.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")
+	})
+
+	test("it should not abort the linting process when errors occur", async () => {
+		lintRule1.message.mockImplementation(() => {
+			throw new Error("error")
+		})
+
+		lintRule2.message.mockImplementation(({ report }) => {
+			report({} as MessageLintReport)
+		})
+
+		const result = await lintSingleMessage({
+			ruleLevels: {
+				[lintRule1.meta.id]: "warning",
+				[lintRule2.meta.id]: "warning",
+			},
+			ruleSettings: {},
+			sourceLanguageTag: "en",
+			languageTags: ["en"],
+			messages,
+			message: message1,
+			rules: [lintRule1, lintRule2],
+		})
+
+		expect(result.data).length(1)
+		expect(result.errors).length(1)
+	})
+})

package/src/lint/message/lintSingleMessage.ts

@@ -0,0 +1,62 @@
+import type {
+	MessageLintLevel,
+	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"
+
+/**
+ * Lint a single message.
+ *
+ * - 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>
+	rules: MessageLintRule[]
+	messages: Message[]
+	message: Message
+}): Promise<{ data: MessageLintReport[]; errors: MessagedLintRuleThrowedError[] }> => {
+	const reports: MessageLintReport[] = []
+	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]
+
+		if (level === undefined) {
+			throw Error("No lint level provided for lint rule: " + ruleId)
+		}
+
+		try {
+			await rule.message({
+				...args,
+				settings,
+				report: (reportArgs) => {
+					reports.push({
+						ruleId,
+						level,
+						...reportArgs,
+					})
+				},
+			})
+		} catch (error) {
+			errors.push(
+				new MessagedLintRuleThrowedError(
+					`Lint rule '${ruleId}' throwed while linting message "${args.message.id}".`,
+					{ cause: error },
+				),
+			)
+		}
+	})
+
+	await Promise.all(promises)
+
+	return { data: reports, errors }
+}

package/src/messages/errors.ts

@@ -0,0 +1,25 @@
+export class MessageVariantDoesNotExistError extends Error {
+	readonly #id = "MessageVariantDoesNotExistError"
+
+	constructor(messageId: string, languageTag: string) {
+		super(
+			`For message '${messageId}' and '${languageTag}', there doesn't exist a variant for this specific matchers.`,
+		)
+	}
+}
+export class MessageVariantAlreadyExistsError extends Error {
+	readonly #id = "MessageVariantAlreadyExistsError"
+
+	constructor(messageId: string, languageTag: string) {
+		super(
+			`For message '${messageId}' and '${languageTag}', there already exists a variant for this specific matchers.`,
+		)
+	}
+}
+export class MessagePatternsForLanguageTagDoNotExistError extends Error {
+	readonly #id = "MessagePatternsForLanguageTagDoNotExistError"
+
+	constructor(messageId: string, languageTag: string) {
+		super(`For message '${messageId}' there are no patterns with the languageTag '${languageTag}'.`)
+	}
+}

package/src/messages/index.ts

@@ -0,0 +1,2 @@
+export * from "./variant.js"
+export * from "./errors.js"