@inlang/sdk 0.18.0 → 0.20.0

package/dist/migrations/migrateToDirectory.js

@@ -0,0 +1,46 @@
+import { tryCatch } from "@inlang/result";
+/**
+ * Migrates to the new project directory structure
+ * https://github.com/inlang/monorepo/issues/1678
+ */
+export const maybeMigrateToDirectory = async (args) => {
+    // the migration assumes that the projectPath ends with project.inlang
+    if (args.projectPath.endsWith("project.inlang") === false) {
+        return;
+    }
+    // we assume that stat will throw when the directory does not exist
+    const projectDirectory = await tryCatch(() => args.nodeishFs.stat(args.projectPath));
+    // the migration has already been conducted.
+    if (projectDirectory.data) {
+        return;
+    }
+    const settingsFile = await tryCatch(() => args.nodeishFs.readFile(args.projectPath + ".json", { encoding: "utf-8" }));
+    // the settings file does not exist or something else is wrong, let loadProject handle it
+    if (settingsFile.error) {
+        return;
+    }
+    await args.nodeishFs.mkdir(args.projectPath);
+    await args.nodeishFs.writeFile(`${args.projectPath}/settings.json`, settingsFile.data);
+    await args.nodeishFs.writeFile(args.projectPath + ".README.md", readme);
+};
+const readme = `
+# DELETE THE \`project.inlang.json\` FILE
+
+The \`project.inlang.json\` file is now contained in a project directory e.g. \`project.inlang/settings.json\`.
+
+
+## What you need to do
+
+1. Update the inlang CLI (if you use it) to use the new path \`project.inlang\` instead of \`project.inlang.json\`.
+2. Delete the \`project.inlang.json\` file.
+
+
+## Why is this happening?
+
+See this RFC https://docs.google.com/document/d/1OYyA1wYfQRbIJOIBDliYoWjiUlkFBNxH_U2R4WpVRZ4/edit#heading=h.pecv6xb7ial6 
+and the following GitHub issue for more information https://github.com/inlang/monorepo/issues/1678.
+
+- Monorepo support https://github.com/inlang/monorepo/discussions/258. 
+- Required for many other future features like caching, first class offline support, and more. 
+- Stablize the inlang project format.
+`;

package/dist/migrations/migrateToDirectory.test.d.ts

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

package/dist/migrations/migrateToDirectory.test.d.ts.map

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

package/dist/migrations/migrateToDirectory.test.js

@@ -0,0 +1,48 @@
+import { test, expect, vi } from "vitest";
+import { maybeMigrateToDirectory } from "./migrateToDirectory.js";
+import { createNodeishMemoryFs } from "@lix-js/fs";
+test("it should return if the settings file has an error (let loadProject handle it)", async () => {
+    const projectPath = "./project.inlang";
+    const mockFs = {
+        stat: vi.fn(() => { }),
+        readFile: vi.fn(() => {
+            throw Error();
+        }),
+    };
+    await maybeMigrateToDirectory({ nodeishFs: mockFs, projectPath });
+    // something goes wrong in readFile
+    expect(mockFs.readFile).toHaveBeenCalled();
+});
+test("it should create the project directory if it does not exist and a project settings file exists", async () => {
+    const projectPath = "./project.inlang";
+    const mockFs = {
+        readFile: vi.fn(() => `{
+			"sourceLanguageTag": "en",
+			"languageTags": ["en", "de"],
+			"modules": []
+		}`),
+        stat: vi.fn(() => {
+            throw Error();
+        }),
+        mkdir: vi.fn(),
+        writeFile: vi.fn(),
+    };
+    await maybeMigrateToDirectory({ nodeishFs: mockFs, projectPath });
+    expect(mockFs.mkdir).toHaveBeenCalled();
+    expect(mockFs.writeFile).toHaveBeenCalled();
+});
+test("it should write the settings file to the new path", async () => {
+    const fs = createNodeishMemoryFs();
+    const mockSettings = {
+        sourceLanguageTag: "en",
+        languageTags: ["en", "de"],
+        modules: [],
+    };
+    await fs.writeFile("./project.inlang.json", JSON.stringify(mockSettings));
+    await maybeMigrateToDirectory({ nodeishFs: fs, projectPath: "./project.inlang" });
+    const migratedSettingsFile = await fs.readFile("./project.inlang/settings.json", {
+        encoding: "utf-8",
+    });
+    expect(migratedSettingsFile).toEqual(JSON.stringify(mockSettings));
+    expect(await fs.stat("./project.inlang.README.md")).toBeDefined();
+});

package/dist/resolve-modules/validateModuleSettings.test.js

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { expect, test } from "vitest";
-import { Plugin, MessageLintRule } from "@inlang/sdk";
+import { Plugin, MessageLintRule } from "../index.js";
 // import { createNodeishMemoryFs } from "@lix-js/fs"
 import { Type } from "@sinclair/typebox";
 import { validatedModuleSettings } from "./validatedModuleSettings.js";

package/package.json

@@ -1,57 +1,58 @@
 {
-	"name": "@inlang/sdk",
-	"type": "module",
-	"version": "0.18.0",
-	"license": "Apache-2.0",
-	"publishConfig": {
-		"access": "public"
-	},
-	"exports": {
-		".": "./dist/index.js",
-		"./test-utilities": "./dist/test-utilities/index.js",
-		"./lint": "./dist/lint/index.js",
-		"./messages": "./dist/messages/index.js"
-	},
-	"files": [
-		"./dist",
-		"./src"
-	],
-	"scripts": {
-		"build": "tsc --build",
-		"dev": "tsc --watch",
-		"test": "tsc --noEmit && vitest run --passWithNoTests --coverage",
-		"lint": "eslint ./src --fix",
-		"format": "prettier ./src --write",
-		"clean": "rm -rf ./dist ./node_modules"
-	},
-	"engines": {
-		"node": ">=18.0.0"
-	},
-	"dependencies": {
-		"@inlang/json-types": "*",
-		"@inlang/translatable": "*",
-		"@inlang/message-lint-rule": "*",
-		"@inlang/module": "*",
-		"@inlang/language-tag": "*",
-		"@inlang/message": "*",
-		"@inlang/plugin": "*",
-		"@inlang/project-settings": "*",
-		"@inlang/result": "*",
-		"@lix-js/fs": "*",
-		"@sinclair/typebox": "^0.31.17",
-		"deepmerge-ts": "^5.1.0",
-		"solid-js": "1.6.12",
-		"throttle-debounce": "5.0.0",
-		"dedent": "1.5.1"
-	},
-	"devDependencies": {
-		"@lix-js/fs": "*",
-		"@types/throttle-debounce": "5.0.0",
-		"@vitest/coverage-v8": "^0.33.0",
-		"jsdom": "22.1.0",
-		"patch-package": "6.5.1",
-		"tsd": "^0.25.0",
-		"typescript": "5.2.2",
-		"vitest": "^0.33.0"
-	}
-}
+  "name": "@inlang/sdk",
+  "type": "module",
+  "version": "0.20.0",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./test-utilities": "./dist/test-utilities/index.js",
+    "./lint": "./dist/lint/index.js",
+    "./messages": "./dist/messages/index.js"
+  },
+  "files": [
+    "./dist",
+    "./src"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.31.17",
+    "dedent": "1.5.1",
+    "deepmerge-ts": "^5.1.0",
+    "solid-js": "1.6.12",
+    "throttle-debounce": "^5.0.0",
+    "@inlang/json-types": "1.1.0",
+    "@inlang/message": "2.0.0",
+    "@inlang/language-tag": "1.2.0",
+    "@inlang/message-lint-rule": "1.4.0",
+    "@inlang/plugin": "2.4.0",
+    "@inlang/module": "1.2.0",
+    "@inlang/project-settings": "2.2.0",
+    "@inlang/result": "1.1.0",
+    "@lix-js/fs": "0.4.0",
+    "@lix-js/client": "0.2.0",
+    "@inlang/translatable": "1.2.0"
+  },
+  "devDependencies": {
+    "@types/throttle-debounce": "5.0.0",
+    "@vitest/coverage-v8": "^0.33.0",
+    "jsdom": "22.1.0",
+    "patch-package": "6.5.1",
+    "tsd": "^0.25.0",
+    "typescript": "5.2.2",
+    "vitest": "^0.33.0",
+    "@lix-js/fs": "0.4.0"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "dev": "tsc --watch",
+    "test": "tsc --noEmit && vitest run --passWithNoTests --coverage",
+    "lint": "eslint ./src --fix",
+    "format": "prettier ./src --write",
+    "clean": "rm -rf ./dist ./node_modules"
+  }
+}

package/src/adapter/solidAdapter.test.ts

@@ -90,11 +90,11 @@ const $import: ImportFunction = async (name) => ({
 describe("config", () => {
 	it("should react to changes in config", async () => {
 		const fs = createNodeishMemoryFs()
-		await fs.mkdir("/user/project", { recursive: true })
-		await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config))
+		await fs.mkdir("/user/project.inlang", { recursive: true })
+		await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
 		const project = solidAdapter(
 			await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import: $import,
 			}),
@@ -123,11 +123,11 @@ describe("config", () => {
 describe("installed", () => {
 	it("react to changes that are unrelated to installed items", async () => {
 		const fs = createNodeishMemoryFs()
-		await fs.mkdir("/user/project", { recursive: true })
-		await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config))
+		await fs.mkdir("/user/project.inlang", { recursive: true })
+		await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
 		const project = solidAdapter(
 			await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang",
 				nodeishFs: fs,
 				_import: $import,
 			}),
@@ -188,11 +188,11 @@ describe("messages", () => {
 
 		const mockImport: ImportFunction = async () => ({ default: mockPlugin })
 
-		await fs.mkdir("/user/project", { recursive: true })
-		await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(mockConfig))
+		await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
+		await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(mockConfig))
 		const project = solidAdapter(
 			await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang.inlang",
 				nodeishFs: fs,
 				_import: mockImport,
 			}),
@@ -218,11 +218,11 @@ describe("messages", () => {
 
 	it("should react to changes in messages", async () => {
 		const fs = createNodeishMemoryFs()
-		await fs.mkdir("/user/project", { recursive: true })
-		await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(config))
+		await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
+		await fs.writeFile("/user/project.inlang.inlang/settings.json", JSON.stringify(config))
 		const project = solidAdapter(
 			await loadProject({
-				settingsFilePath: "/user/project/project.inlang.json",
+				projectPath: "/user/project.inlang.inlang",
 				nodeishFs: fs,
 				_import: $import,
 			}),
@@ -280,10 +280,11 @@ describe("lint", () => {
 	it.todo("should react to changes in config", async () => {
 		await createRoot(async () => {
 			const fs = createNodeishMemoryFs()
-			await fs.writeFile("./project.config.json", JSON.stringify(config))
+			await fs.mkdir("./project.inlang", { recursive: true })
+			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(config))
 			const project = solidAdapter(
 				await loadProject({
-					settingsFilePath: "./project.config.json",
+					projectPath: "./project.inlang",
 					nodeishFs: fs,
 					_import: $import,
 				}),
@@ -321,7 +322,7 @@ describe("lint", () => {
 			await fs.writeFile("./project.config.json", JSON.stringify(config))
 			const project = solidAdapter(
 				await loadProject({
-					settingsFilePath: "./project.config.json",
+					projectPath: "./project.config.json",
 					nodeishFs: fs,
 					_import: $import,
 				}),

package/src/createMessageLintReportsQuery.ts

@@ -1,50 +1,79 @@
-import { createEffect } from "./reactivity/solid.js"
 import { createSubscribable } from "./loadProject.js"
-import type { InlangProject, InstalledMessageLintRule, MessageLintReportsQueryApi } from "./api.js"
+import type {
+	InlangProject,
+	InstalledMessageLintRule,
+	MessageLintReportsQueryApi,
+	MessageQueryApi,
+} from "./api.js"
 import type { ProjectSettings } from "@inlang/project-settings"
 import type { resolveModules } from "./resolve-modules/index.js"
 import type { MessageLintReport, Message } from "./versionedInterfaces.js"
 import { lintSingleMessage } from "./lint/index.js"
 import { ReactiveMap } from "./reactivity/map.js"
+import { debounce } from "throttle-debounce"
+import { createEffect } from "./reactivity/solid.js"
 
 /**
  * Creates a reactive query API for messages.
  */
 export function createMessageLintReportsQuery(
-	messages: () => Array<Message> | undefined,
+	messagesQuery: MessageQueryApi,
 	settings: () => ProjectSettings,
 	installedMessageLintRules: () => Array<InstalledMessageLintRule>,
-	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined
+	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined,
+	hasWatcher: boolean
 ): InlangProject["query"]["messageLintReports"] {
 	// @ts-expect-error
 	const index = new ReactiveMap<MessageLintReport["messageId"], MessageLintReport[]>()
 
-	createEffect(() => {
-		const modules = resolvedModules()
-		const _messages = messages()
-		const _settings = settings()
+	const modules = resolvedModules()
 
-		if (_messages && _settings && modules) {
-			// index.clear()
-			for (const message of _messages) {
-				// TODO: only lint changed messages and update arrays selectively
+	const rulesArray = modules?.messageLintRules
+	const messageLintRuleLevels = Object.fromEntries(
+		installedMessageLintRules().map((rule) => [rule.id, rule.level])
+	)
+	const settingsObject = () => {
+		return {
+			...settings(),
+			messageLintRuleLevels,
+		}
+	}
+
+	const messages = messagesQuery.getAll() as Message[]
 
-				lintSingleMessage({
-					rules: modules.messageLintRules,
-					settings: {
-						..._settings,
-						messageLintRuleLevels: Object.fromEntries(
-							installedMessageLintRules().map((rule) => [rule.id, rule.level])
-						),
-					},
-					messages: _messages,
-					message: message,
-				}).then((report) => {
-					if (
-						report.errors.length === 0 &&
-						JSON.stringify(index.get(message.id)) !== JSON.stringify(report.data)
-					) {
-						index.set(message.id, report.data || [])
+	createEffect(() => {
+		if (rulesArray) {
+			for (const messageId of messagesQuery.includedMessageIds()) {
+				createEffect(() => {
+					const message = messagesQuery.get({ where: { id: messageId } })
+					if (hasWatcher) {
+						lintSingleMessage({
+							rules: rulesArray,
+							settings: settingsObject(),
+							messages: messages,
+							message: message,
+						}).then((report) => {
+							if (report.errors.length === 0 && index.get(messageId) !== report.data) {
+								index.set(messageId, report.data)
+							}
+						})
+					} else {
+						debounce(
+							500,
+							(message) => {
+								lintSingleMessage({
+									rules: rulesArray,
+									settings: settingsObject(),
+									messages: messages,
+									message: message,
+								}).then((report) => {
+									if (report.errors.length === 0 && index.get(messageId) !== report.data) {
+										index.set(messageId, report.data)
+									}
+								})
+							},
+							{ atBegin: false }
+						)(message)
 					}
 				})
 			}

package/src/createNodeishFsWithAbsolutePaths.test.ts

@@ -2,16 +2,16 @@ import { it, expect, vi } from "vitest"
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
 import type { NodeishFilesystemSubset } from "./versionedInterfaces.js"
 
-it("throws an error if settingsFilePath is not an absolute path", () => {
+it("throws an error if projectPath is not an absolute path", () => {
 	const relativePath = "relative/path"
 
 	expect(() =>
-		createNodeishFsWithAbsolutePaths({ settingsFilePath: relativePath, nodeishFs: {} as any })
+		createNodeishFsWithAbsolutePaths({ projectPath: relativePath, nodeishFs: {} as any })
 	).toThrow()
 })
 
 it("intercepts paths correctly for readFile", async () => {
-	const settingsFilePath = `/Users/samuel/Documents/paraglide/example/project.inlang.json`
+	const projectPath = `/Users/samuel/Documents/paraglide/example/project.inlang`
 
 	const filePaths = [
 		["file.txt", `/Users/samuel/Documents/paraglide/example/file.txt`],
@@ -32,7 +32,7 @@ it("intercepts paths correctly for readFile", async () => {
 	} satisfies Record<keyof NodeishFilesystemSubset, any>
 
 	const interceptedFs = createNodeishFsWithAbsolutePaths({
-		settingsFilePath,
+		projectPath,
 		nodeishFs: mockNodeishFs,
 	})
 

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -6,19 +6,19 @@ import { isAbsolutePath } from "./isAbsolutePath.js"
  * Wraps the nodeish filesystem subset with a function that intercepts paths
  * and prepends the base path.
  *
- * The paths are resolved from the `settingsFilePath` argument.
+ * The paths are resolved from the `projectPath` argument.
  */
 export const createNodeishFsWithAbsolutePaths = (args: {
-	settingsFilePath: string
+	projectPath: string
 	nodeishFs: NodeishFilesystemSubset
 }): NodeishFilesystemSubset => {
-	if (!isAbsolutePath(args.settingsFilePath)) {
-		throw new Error(`Expected an absolute path but received "${args.settingsFilePath}".`)
+	if (!isAbsolutePath(args.projectPath)) {
+		throw new Error(`Expected an absolute path but received "${args.projectPath}".`)
 	}
 
 	// get the base path of the settings file by
 	// removing the file name from the path
-	const basePath = normalizePath(args.settingsFilePath).split("/").slice(0, -1).join("/")
+	const basePath = normalizePath(args.projectPath).split("/").slice(0, -1).join("/")
 
 	const makeAbsolute = (path: string) => {
 		if (isAbsolutePath(path)) {

package/src/createNodeishFsWithWatcher.ts

@@ -4,7 +4,7 @@ import type { NodeishFilesystemSubset } from "@inlang/plugin"
  * Wraps the nodeish filesystem subset with a function that intercepts paths
  * and prepends the base path.
  *
- * The paths are resolved from the `settingsFilePath` argument.
+ * The paths are resolved from the `projectPath` argument.
  */
 export const createNodeishFsWithWatcher = (args: {
 	nodeishFs: NodeishFilesystemSubset
@@ -20,9 +20,11 @@ export const createNodeishFsWithWatcher = (args: {
 					signal: abortController.signal,
 					persistent: false,
 				})
-				//eslint-disable-next-line @typescript-eslint/no-unused-vars
-				for await (const event of watcher) {
-					args.updateMessages()
+				if (watcher) {
+					//eslint-disable-next-line @typescript-eslint/no-unused-vars
+					for await (const event of watcher) {
+						args.updateMessages()
+					}
 				}
 			} catch (err: any) {
 				if (err.name === "AbortError") return

package/src/generateProjectId.test.ts

@@ -0,0 +1,22 @@
+import { generateProjectId } from "./generateProjectId.js"
+import { describe, it, expect } from "vitest"
+import { openRepository } from "@lix-js/client/src/openRepository.ts"
+import { mockRepo, createNodeishMemoryFs } from "@lix-js/client"
+
+describe("generateProjectId", async () => {
+	const repo = await mockRepo()
+
+	it("should generate a project id", async () => {
+		const projectId = await generateProjectId(repo, "mocked_project_path")
+		expect(projectId).toBe("0c83325bf9068eb01091c522d4b8e3765aff42e36fc781c041b44439bbe3e734")
+	})
+
+	it("should return undefined if repoMeta contains error", async () => {
+		const errorRepo = await openRepository("https://github.com/inlang/no-exist", {
+			nodeishFs: createNodeishMemoryFs(),
+		})
+
+		const projectId = await generateProjectId(errorRepo, "mocked_project_path")
+		expect(projectId).toBeUndefined()
+	})
+})

package/src/generateProjectId.ts

@@ -0,0 +1,14 @@
+import type { Repository } from "@lix-js/client"
+import { hash } from "@lix-js/client"
+
+export async function generateProjectId(repo: Repository, projectPath: string) {
+	if (!repo || !projectPath) {
+		return undefined
+	}
+	const repoMeta = await repo.getMeta()
+
+	if (repoMeta && !("error" in repoMeta)) {
+		return hash(`${repoMeta.id + projectPath}`)
+	}
+	return undefined
+}

package/src/index.ts

@@ -13,6 +13,7 @@ export type {
 } from "./api.js"
 export { type ImportFunction, createImport } from "./resolve-modules/index.js"
 export { loadProject } from "./loadProject.js"
+export { listProjects } from "./listProjects.js"
 export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js"
 export { createMessagesQuery } from "./createMessagesQuery.js"
 export {

package/src/isAbsolutePath.test.ts

@@ -10,7 +10,7 @@ describe("isAbsolutePath", () => {
 
 	it("should correctly identify Windows absolute paths", () => {
 		assert.isTrue(isAbsolutePath("C:\\Users\\User\\Documents\\File.txt"))
-		assert.isTrue(isAbsolutePath("C:/Users/user/project/project.inlang.json"))
+		assert.isTrue(isAbsolutePath("C:/Users/user/project.inlang/settings.json"))
 		assert.isFalse(isAbsolutePath("Projects\\Project1\\source\\file.txt"))
 	})
 

package/src/listProjects.test.ts

@@ -0,0 +1,69 @@
+import { assert, describe, it } from "vitest"
+import { listProjects } from "./listProjects.js"
+import { createNodeishMemoryFs } from "@lix-js/fs"
+import type { ProjectSettings } from "@inlang/project-settings"
+
+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 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)
+		})
+	})
+})