@inlang/sdk 0.17.0 → 0.19.0

package/src/loadProject.ts

@@ -23,15 +23,17 @@ 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"
 
 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.
@@ -39,29 +41,39 @@ const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
  *
  */
 export const loadProject = async (args: {
-	settingsFilePath: string
-	nodeishFs: NodeishFilesystemSubset
+	projectPath: string
+	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 ------------------------------------------------------
 	return await createRoot(async () => {
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
 		const nodeishFs = createNodeishFsWithAbsolutePaths({
-			settingsFilePath,
+			projectPath,
 			nodeishFs: args.nodeishFs,
 		})
 
@@ -69,7 +81,7 @@ export const loadProject = async (args: {
 
 		const [settings, _setSettings] = createSignal<ProjectSettings>()
 		createEffect(() => {
-			loadSettings({ settingsFilePath, nodeishFs })
+			loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs })
 				.then((settings) => {
 					setSettings(settings)
 					// rename settings to get a convenient access to the data in Posthog
@@ -83,7 +95,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,6 +138,7 @@ export const loadProject = async (args: {
 		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)
 
 		const [messages, setMessages] = createSignal<Message[]>()
+
 		createEffect(() => {
 			const conf = settings()
 			if (!conf) return
@@ -138,16 +151,28 @@ export const loadProject = async (args: {
 				return
 			}
 
-			makeTrulyAsync(
-				_resolvedModules.resolvedPluginApi.loadMessages({
-					settings: settingsValue,
-				})
-			)
-				.then((messages) => {
-					setMessages(messages)
-					markInitAsComplete()
-				})
-				.catch((err) => markInitAsFailed(new PluginLoadMessagesError({ cause: err })))
+			const loadAndSetMessages = async (fs: NodeishFilesystemSubset) => {
+				makeTrulyAsync(
+					_resolvedModules.resolvedPluginApi.loadMessages({
+						settings: settingsValue,
+						nodeishFs: fs,
+					})
+				)
+					.then((messages) => {
+						setMessages(messages)
+						markInitAsComplete()
+					})
+					.catch((err) => markInitAsFailed(new PluginLoadMessagesError({ cause: err })))
+			}
+
+			const fsWithWatcher = createNodeishFsWithWatcher({
+				nodeishFs: nodeishFs,
+				updateMessages: () => {
+					loadAndSetMessages(nodeishFs)
+				},
+			})
+
+			loadAndSetMessages(fsWithWatcher)
 		})
 
 		// -- installed items ----------------------------------------------------
@@ -198,18 +223,22 @@ export const loadProject = async (args: {
 				500,
 				async (newMessages) => {
 					try {
-						await resolvedModules()?.resolvedPluginApi.saveMessages({
-							settings: settingsValue,
-							messages: newMessages,
-						})
+						if (JSON.stringify(newMessages) !== JSON.stringify(messages())) {
+							await resolvedModules()?.resolvedPluginApi.saveMessages({
+								settings: settingsValue,
+								messages: newMessages,
+							})
+						}
 					} catch (err) {
 						throw new PluginSaveMessagesError({
 							cause: err,
 						})
 					}
+					const abortController = new AbortController()
 					if (
 						newMessages.length !== 0 &&
-						JSON.stringify(newMessages) !== JSON.stringify(messages())
+						JSON.stringify(newMessages) !== JSON.stringify(messages()) &&
+						nodeishFs.watch("/", { signal: abortController.signal }) === undefined
 					) {
 						setMessages(newMessages)
 					}
@@ -304,6 +333,7 @@ const parseSettings = (settings: unknown) => {
 }
 
 const _writeSettingsToDisk = async (args: {
+	projectPath: string
 	nodeishFs: NodeishFilesystemSubset
 	settings: ProjectSettings
 }) => {
@@ -316,7 +346,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/plugins/resolvePlugins.test.ts

@@ -60,7 +60,7 @@ it("should expose the project settings including the plugin settings", async ()
 		settings: settings,
 		nodeishFs: {} as any,
 	})
-	await resolved.data.loadMessages!({ settings })
+	await resolved.data.loadMessages!({ settings, nodeishFs: {} as any })
 	await resolved.data.saveMessages!({ settings, messages: [] })
 })
 
@@ -82,6 +82,7 @@ describe("loadMessages", () => {
 		expect(
 			await resolved.data.loadMessages!({
 				settings: {} as any,
+				nodeishFs: {} as any,
 			})
 		).toEqual([{ id: "test", expressions: [], selectors: [], variants: [] }])
 	})

package/src/resolve-modules/plugins/resolvePlugins.ts

@@ -91,7 +91,7 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 			result.data.loadMessages = (_args) =>
 				plugin.loadMessages!({
 					..._args,
-					nodeishFs: args.nodeishFs,
+					// renoved nodeishFs from args because we need to pass custom wrapped fs that establishes a watcher
 				})
 		}
 

package/src/resolve-modules/plugins/types.ts

@@ -18,7 +18,7 @@ import type { ProjectSettings } from "@inlang/project-settings"
  */
 export type NodeishFilesystemSubset = Pick<
 	NodeishFilesystem,
-	"readFile" | "readdir" | "mkdir" | "writeFile"
+	"readFile" | "readdir" | "mkdir" | "writeFile" | "watch"
 >
 
 /**
@@ -44,7 +44,10 @@ export type ResolvePluginsFunction = (args: {
  * The API after resolving the plugins.
  */
 export type ResolvedPluginApi = {
-	loadMessages: (args: { settings: ProjectSettings }) => Promise<Message[]> | Message[]
+	loadMessages: (args: {
+		settings: ProjectSettings
+		nodeishFs: NodeishFilesystemSubset
+	}) => Promise<Message[]> | Message[]
 	saveMessages: (args: { settings: ProjectSettings; messages: Message[] }) => Promise<void> | void
 	/**
 	 * App specific APIs.

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"