@inlang/sdk 0.18.0 → 0.20.0

package/src/loadProject.ts

@@ -23,16 +23,19 @@ import { ProjectSettings, Message, type NodeishFilesystemSubset } from "./versio
 import { tryCatch, type Result } from "@inlang/result"
 import { migrateIfOutdated } from "@inlang/project-settings/migration"
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
-import { normalizePath } from "@lix-js/fs"
+import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
 import { isAbsolutePath } from "./isAbsolutePath.js"
 import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js"
+import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js"
+import type { Repository } from "@lix-js/client"
+import { generateProjectId } from "./generateProjectId.js"
 
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
 /**
  * Creates an inlang instance.
  *
- * @param settingsFilePath - Absolute path to the inlang settings file.
+ * @param projectPath - Absolute path to the inlang settings file.
  * @param nodeishFs - Filesystem that implements the NodeishFilesystemSubset interface.
  * @param _import - Use `_import` to pass a custom import function for testing,
  *   and supporting legacy resolvedModules such as CJS.
@@ -40,42 +43,81 @@ const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
  *
  */
 export const loadProject = async (args: {
-	settingsFilePath: string
-	nodeishFs: NodeishFilesystemSubset
+	projectPath: string
+	repo?: Repository
+	nodeishFs: NodeishFilesystem
 	_import?: ImportFunction
 	_capture?: (id: string, props: Record<string, unknown>) => void
 }): Promise<InlangProject> => {
+	const projectPath = normalizePath(args.projectPath)
+
+	// -- migrate if outdated ------------------------------------------------
+
+	await maybeMigrateToDirectory({ nodeishFs: args.nodeishFs, projectPath })
+
 	// -- validation --------------------------------------------------------
-	//! the only place where throwing is acceptable because the project
-	//! won't even be loaded. do not throw anywhere else. otherwise, apps
-	//! can't handle errors gracefully.
-	if (!isAbsolutePath(args.settingsFilePath)) {
+	// the only place where throwing is acceptable because the project
+	// won't even be loaded. do not throw anywhere else. otherwise, apps
+	// can't handle errors gracefully.
+
+	if (!isAbsolutePath(args.projectPath)) {
+		throw new LoadProjectInvalidArgument(
+			`Expected an absolute path but received "${args.projectPath}".`,
+			{ argument: "projectPath" }
+		)
+	} else if (/[^\\/]+\.inlang$/.test(projectPath) === false) {
 		throw new LoadProjectInvalidArgument(
-			`Expected an absolute path but received "${args.settingsFilePath}".`,
-			{ argument: "settingsFilePath" }
+			`Expected a path ending in "{name}.inlang" but received "${projectPath}".\n\nValid examples: \n- "/path/to/micky-mouse.inlang"\n- "/path/to/green-elephant.inlang\n`,
+			{ argument: "projectPath" }
 		)
 	}
 
-	const settingsFilePath = normalizePath(args.settingsFilePath)
-
 	// -- load project ------------------------------------------------------
+	let idError: Error | undefined
 	return await createRoot(async () => {
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
 		const nodeishFs = createNodeishFsWithAbsolutePaths({
-			settingsFilePath,
+			projectPath,
 			nodeishFs: args.nodeishFs,
 		})
 
+		let projectId: string | undefined
+
+		try {
+			projectId = await nodeishFs.readFile(projectPath + "/project_id", {
+				encoding: "utf-8",
+			})
+		} catch (error) {
+			// @ts-ignore
+			if (error.code === "ENOENT") {
+				if (args.repo) {
+					projectId = await generateProjectId(args.repo, projectPath)
+					if (projectId) {
+						await nodeishFs.writeFile(projectPath + "/project_id", projectId)
+					}
+				}
+			} else {
+				idError = error as Error
+			}
+		}
+
 		// -- settings ------------------------------------------------------------
 
 		const [settings, _setSettings] = createSignal<ProjectSettings>()
 		createEffect(() => {
-			loadSettings({ settingsFilePath, nodeishFs })
+			// TODO:
+			// if (projectId) {
+			// 	telemetryBrowser.group("project", projectId, {
+			// 		name: projectId,
+			// 	})
+			// }
+
+			loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs })
 				.then((settings) => {
 					setSettings(settings)
 					// rename settings to get a convenient access to the data in Posthog
 					const project_settings = settings
-					args._capture?.("SDK used settings", { project_settings })
+					args._capture?.("SDK used settings", { project_settings, group: projectId })
 				})
 				.catch((err) => {
 					markInitAsFailed(err)
@@ -84,7 +126,7 @@ export const loadProject = async (args: {
 		// TODO: create FS watcher and update settings on change
 
 		const writeSettingsToDisk = skipFirst((settings: ProjectSettings) =>
-			_writeSettingsToDisk({ nodeishFs, settings })
+			_writeSettingsToDisk({ nodeishFs, settings, projectPath })
 		)
 
 		const setSettings = (settings: ProjectSettings): Result<void, ProjectSettingsInvalidError> => {
@@ -126,12 +168,11 @@ export const loadProject = async (args: {
 		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)
 
+		// please don't use this as source of truth, use the query instead
+		// needed for granular linting
 		const [messages, setMessages] = createSignal<Message[]>()
 
 		createEffect(() => {
-			const conf = settings()
-			if (!conf) return
-
 			const _resolvedModules = resolvedModules()
 			if (!_resolvedModules) return
 
@@ -199,12 +240,16 @@ export const loadProject = async (args: {
 
 		const initializeError: Error | undefined = await initialized.catch((error) => error)
 
+		const abortController = new AbortController()
+		const hasWatcher = nodeishFs.watch("/", { signal: abortController.signal }) !== undefined
+
 		const messagesQuery = createMessagesQuery(() => messages() || [])
 		const lintReportsQuery = createMessageLintReportsQuery(
-			messages,
+			messagesQuery,
 			settings as () => ProjectSettings,
 			installedMessageLintRules,
-			resolvedModules
+			resolvedModules,
+			hasWatcher
 		)
 
 		const debouncedSave = skipFirst(
@@ -223,12 +268,14 @@ export const loadProject = async (args: {
 							cause: err,
 						})
 					}
-					// if (
-					// 	newMessages.length !== 0 &&
-					// 	JSON.stringify(newMessages) !== JSON.stringify(messages())
-					// ) {
-					// 	setMessages(newMessages)
-					// }
+					const abortController = new AbortController()
+					if (
+						newMessages.length !== 0 &&
+						JSON.stringify(newMessages) !== JSON.stringify(messages()) &&
+						nodeishFs.watch("/", { signal: abortController.signal }) !== undefined
+					) {
+						setMessages(newMessages)
+					}
 				},
 				{ atBegin: false }
 			)
@@ -245,6 +292,7 @@ export const loadProject = async (args: {
 			},
 			errors: createSubscribable(() => [
 				...(initializeError ? [initializeError] : []),
+				...(idError ? [idError] : []),
 				...(resolvedModules() ? resolvedModules()!.errors : []),
 				// have a query error exposed
 				//...(lintErrors() ?? []),
@@ -320,6 +368,7 @@ const parseSettings = (settings: unknown) => {
 }
 
 const _writeSettingsToDisk = async (args: {
+	projectPath: string
 	nodeishFs: NodeishFilesystemSubset
 	settings: ProjectSettings
 }) => {
@@ -332,7 +381,7 @@ const _writeSettingsToDisk = async (args: {
 	}
 
 	const { error: writeSettingsError } = await tryCatch(async () =>
-		args.nodeishFs.writeFile("./project.inlang.json", serializedSettings)
+		args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings)
 	)
 
 	if (writeSettingsError) {

package/src/migrations/migrateToDirectory.test.ts

@@ -0,0 +1,54 @@
+import { test, expect, vi } from "vitest"
+import { maybeMigrateToDirectory } from "./migrateToDirectory.js"
+import { createNodeishMemoryFs } from "@lix-js/fs"
+import type { ProjectSettings } from "@inlang/project-settings"
+
+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 as any, 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 as any, 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: ProjectSettings = {
+		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/src/migrations/migrateToDirectory.ts

@@ -0,0 +1,59 @@
+import { tryCatch } from "@inlang/result"
+import type { NodeishFilesystem } from "@lix-js/fs"
+
+/**
+ * Migrates to the new project directory structure
+ * https://github.com/inlang/monorepo/issues/1678
+ */
+export const maybeMigrateToDirectory = async (args: {
+	nodeishFs: NodeishFilesystem
+	projectPath: string
+}) => {
+	// 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/src/resolve-modules/validateModuleSettings.test.ts

@@ -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"