@inlang/sdk 0.36.3 → 2.0.0-prerelease.0

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

@@ -1,126 +0,0 @@
-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 = {
-	id: "messageLintRule.x.1",
-	displayName: { en: "" },
-	description: { en: "" },
-
-	run: vi.fn(),
-} satisfies MessageLintRule
-
-const lintRule2 = {
-	id: "messageLintRule.x.2",
-	displayName: { en: "" },
-	description: { en: "" },
-
-	run: 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.run.mockImplementation(async () => {
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			called++
-		})
-
-		await lintMessages({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: [],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			messages,
-			rules: [lintRule1, lintRule2],
-		})
-
-		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.run.mockImplementation(async ({ message }) => {
-			fn("r1", "before", message.id)
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn("r1", "after", message.id)
-		})
-		lintRule2.run.mockImplementation(async ({ message }) => {
-			fn("r2", "before", message.id)
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn("r2", "after", message.id)
-		})
-
-		await lintMessages({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: [],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			rules: [lintRule1, lintRule2],
-			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.run.mockImplementation(({ report }) => {
-			report({} as MessageLintReport)
-		})
-		lintRule2.run.mockImplementation(() => {
-			throw new Error("error")
-		})
-
-		const { data, errors } = await lintMessages({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: [],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			messages,
-			rules: [lintRule1, lintRule2],
-		})
-
-		expect(data).toHaveLength(3)
-		expect(errors).toHaveLength(3)
-	})
-})

package/src/lint/message/lintMessages.ts

@@ -1,25 +0,0 @@
-import type { Message } from "@inlang/message"
-import { lintSingleMessage } from "./lintSingleMessage.js"
-import type { MessagedLintRuleThrowedError } from "./errors.js"
-import type { MessageLintReport, MessageLintRule } from "@inlang/message-lint-rule"
-import type { ProjectSettings } from "@inlang/project-settings"
-
-export const lintMessages = async (args: {
-	settings: ProjectSettings & Required<Pick<ProjectSettings, "messageLintRuleLevels">>
-	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

@@ -1,191 +0,0 @@
-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 = {
-	id: "messageLintRule.r.1",
-	displayName: "",
-	description: "",
-
-	run: vi.fn(),
-} satisfies MessageLintRule
-
-const lintRule2 = {
-	id: "messageLintRule.r.2",
-	displayName: "",
-	description: "",
-
-	run: 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.run.mockImplementation(({ report }) => report({} as MessageLintReport))
-
-			const result = await tryCatch(() =>
-				lintSingleMessage({
-					settings: {
-						sourceLanguageTag: "en",
-						languageTags: ["en"],
-						messageLintRuleLevels: {},
-						modules: [],
-					},
-					messages,
-					message: message1,
-					rules: [lintRule1],
-				})
-			)
-			expect(result.error).toBeDefined()
-			expect(result.data).toBeUndefined()
-		})
-
-		test("it should override the default lint level", async () => {
-			lintRule1.run.mockImplementation(({ report }) => report({} as MessageLintReport))
-
-			const reports = await lintSingleMessage({
-				settings: {
-					sourceLanguageTag: "en",
-					languageTags: ["en"],
-					modules: [],
-					messageLintRuleLevels: {
-						[lintRule1.id]: "error",
-					},
-				},
-				messages,
-				message: message1,
-				rules: [lintRule1],
-			})
-			expect(reports.data[0]?.level).toBe("error")
-		})
-
-		test("it should pass the correct settings", async () => {
-			const settings = {
-				sourceLanguageTag: "en",
-				languageTags: ["en"],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id as any]: "warning",
-				},
-			}
-
-			const fn = vi.fn()
-			lintRule1.run.mockImplementation(({ settings }) => fn(settings))
-
-			await lintSingleMessage({
-				settings,
-				messages,
-				message: message1,
-				rules: [lintRule1],
-			})
-
-			expect(fn).toHaveBeenCalledWith(settings)
-		})
-	})
-
-	test("it should await all rules", async () => {
-		let m1Called = false
-		let m2Called = false
-		lintRule1.run.mockImplementation(() => {
-			m1Called = true
-		})
-		lintRule2.run.mockImplementation(async () => {
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			m2Called = true
-		})
-
-		await lintSingleMessage({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: ["en"],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			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.run.mockImplementation(async () => {
-			fn(lintRule1.id, "before")
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn(lintRule1.id, "after")
-		})
-		lintRule2.run.mockImplementation(async () => {
-			fn(lintRule2.id, "before")
-			await new Promise((resolve) => setTimeout(resolve, 0))
-			fn(lintRule2.id, "after")
-		})
-
-		await lintSingleMessage({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: ["en"],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			messages,
-			message: message1,
-			rules: [lintRule1, lintRule2],
-		})
-
-		expect(fn).toHaveBeenCalledTimes(4)
-		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.run.mockImplementation(() => {
-			throw new Error("error")
-		})
-
-		lintRule2.run.mockImplementation(({ report }) => {
-			report({} as MessageLintReport)
-		})
-
-		const result = await lintSingleMessage({
-			settings: {
-				sourceLanguageTag: "en",
-				languageTags: ["en"],
-				modules: [],
-				messageLintRuleLevels: {
-					[lintRule1.id]: "warning",
-					[lintRule2.id]: "warning",
-				},
-			},
-			messages,
-			message: message1,
-			rules: [lintRule1, lintRule2],
-		})
-
-		expect(result.data).length(1)
-		expect(result.errors).length(1)
-	})
-})

package/src/lint/message/lintSingleMessage.ts

@@ -1,57 +0,0 @@
-import type { MessageLintRule, MessageLintReport } from "@inlang/message-lint-rule"
-import type { Message } from "@inlang/message"
-import { MessagedLintRuleThrowedError } from "./errors.js"
-import type { ProjectSettings } from "@inlang/project-settings"
-
-/**
- * Lint a single message.
- *
- * - the lint rule levels defaults to `warning`.
- */
-export const lintSingleMessage = async (args: {
-	settings: ProjectSettings & Required<Pick<ProjectSettings, "messageLintRuleLevels">>
-	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 level = args.settings.messageLintRuleLevels?.[rule.id]
-
-		if (level === undefined) {
-			throw Error("No lint level provided for lint rule: " + rule.id)
-		}
-
-		try {
-			await rule.run({
-				message: args.message,
-				settings: args.settings,
-				report: (reportArgs) => {
-					reports.push({
-						ruleId: rule.id,
-						level,
-						messageId: reportArgs.messageId,
-						languageTag: reportArgs.languageTag,
-						body: reportArgs.body,
-					})
-				},
-			})
-		} catch (error) {
-			errors.push(
-				new MessagedLintRuleThrowedError(
-					`Lint rule '${rule.id}' throwed while linting message "${args.message.id}".`,
-					{ cause: error }
-				)
-			)
-		}
-	})
-
-	await Promise.all(promises)
-
-	// we sort the reports by rule id to allow us to easyly compare both
-	const sortedReports = reports.sort((r1, r2) => r1.ruleId.localeCompare(r2.ruleId))
-
-	return { data: sortedReports, errors }
-}

package/src/listProjects.test.ts

@@ -1,91 +0,0 @@
-import { assert, describe, it, expect } from "vitest"
-import { listProjects } from "./listProjects.js"
-import { createNodeishMemoryFs, type Snapshot } from "@lix-js/fs"
-import type { ProjectSettings } from "@inlang/project-settings"
-import { mockRepo } from "@lix-js/client"
-// eslint-disable-next-line no-restricted-imports -- test
-import { readFileSync } from "node:fs"
-
-const settings: ProjectSettings = {
-	sourceLanguageTag: "en",
-	languageTags: ["en"],
-	modules: ["plugin.js", "lintRule.js"],
-	messageLintRuleLevels: {
-		"messageLintRule.project.missingTranslation": "error",
-	},
-	"plugin.project.i18next": {
-		pathPattern: "./examples/example01/{languageTag}.json",
-		variableReferencePattern: ["{", "}"],
-	},
-}
-
-describe("listProjects", () => {
-	it("should find all projects a given path", async () => {
-		const fs = createNodeishMemoryFs()
-		await fs.mkdir("/user/dir1/project.inlang", { recursive: true })
-		await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings))
-		await fs.mkdir("/user/dir2/project.inlang", { recursive: true })
-		await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings))
-
-		await listProjects(fs, "/user").then((projects) => {
-			assert(projects.length === 2)
-		})
-	})
-
-	it("should return objects inside of an array with the projectPath", async () => {
-		const fs = createNodeishMemoryFs()
-		await fs.mkdir("/user/dir1/project.inlang", { recursive: true })
-		await fs.writeFile("/user/dir1/project.inlang/settings.json", JSON.stringify(settings))
-		await fs.mkdir("/user/dir2/project.inlang", { recursive: true })
-		await fs.writeFile("/user/dir2/project.inlang/settings.json", JSON.stringify(settings))
-
-		await listProjects(fs, "/user").then((projects) => {
-			assert.isTrue(typeof projects[0] === "object")
-			assert.isTrue(typeof projects[0]?.projectPath === "string")
-		})
-	})
-
-	it("should limit the recursion depth to 5", async () => {
-		const fs = createNodeishMemoryFs()
-		await fs.mkdir("/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang", { recursive: true })
-		await fs.writeFile(
-			"/user/dir1/dir2/dir3/dir4/dir5/dir6/project.inlang/settings.json",
-			JSON.stringify(settings)
-		)
-
-		await listProjects(fs, "/user").then((projects) => {
-			assert(projects.length === 0)
-		})
-	})
-
-	it("should not crash on broken symlinks as cal.com has", async () => {
-		const ciTestRepo: Snapshot = JSON.parse(
-			readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" })
-		)
-		const repo = await mockRepo({
-			fromSnapshot: ciTestRepo,
-			repoOptions: { experimentalFeatures: { lixCommit: true, lazyClone: false } },
-		})
-		repo.checkout({ branch: "test-symlink" })
-
-		const link = await repo.nodeishFs.readlink("test-symlink-not-existing-target")
-
-		expect(link).toBe("/test-symlink-not-existing-target//.././no-exist")
-
-		await listProjects(repo.nodeishFs, "/").then((projects) => {
-			assert(projects.length === 1)
-		})
-	})
-
-	it("should also find files inside of a dir that ends with *.inlang", async () => {
-		const fs = createNodeishMemoryFs()
-		await fs.mkdir("/user/dir1/go.inlang", { recursive: true })
-		await fs.writeFile("/user/dir1/go.inlang/settings.json", JSON.stringify(settings))
-		await fs.mkdir("/user/dir2/flutter.inlang", { recursive: true })
-		await fs.writeFile("/user/dir2/flutter.inlang/settings.json", JSON.stringify(settings))
-
-		await listProjects(fs, "/user").then((projects) => {
-			assert(projects.length === 2)
-		})
-	})
-})

package/src/listProjects.ts

@@ -1,48 +0,0 @@
-import type { NodeishFilesystem } from "@lix-js/fs"
-
-const ignores = ["node_modules", ".git"]
-
-export const listProjects = async (
-	nodeishFs: NodeishFilesystem,
-	from: string
-): Promise<Array<{ projectPath: string }>> => {
-	// !TODO: Remove this limit once we introduce caching
-	const recursionLimit = 5
-
-	const projects: Array<{ projectPath: string }> = []
-
-	async function searchDir(path: string, depth: number) {
-		if (depth > recursionLimit) {
-			return
-		}
-
-		const files = await nodeishFs.readdir(path)
-		for (const file of files) {
-			const filePath = `${path}/${file}`
-			try {
-				const stats = await nodeishFs.stat(filePath)
-				if (stats.isDirectory()) {
-					if (ignores.includes(file)) {
-						continue
-					}
-
-					if (file.endsWith(".inlang")) {
-						projects.push({ projectPath: filePath })
-					} else {
-						await searchDir(filePath, depth + 1)
-					}
-				}
-			} catch {
-				continue
-			}
-		}
-	}
-
-	await searchDir(from, 0)
-
-	// remove double slashes
-	for (const project of projects) {
-		project.projectPath = project.projectPath.replace(/\/\//g, "/")
-	}
-	return projects
-}