@inlang/sdk 0.36.1 → 0.36.2

package/src/loadProject.ts

@@ -21,6 +21,7 @@ import { ProjectSettings, type NodeishFilesystemSubset } from "./versionedInterf
 import { tryCatch, type Result } from "@inlang/result"
 import { migrateIfOutdated } from "@inlang/project-settings/migration"
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
+import { createNodeishFsWithWatcher } from "./createNodeishFsWithWatcher.js"
 import { normalizePath } from "@lix-js/fs"
 import { assertValidProjectPath } from "./validateProjectPath.js"
 
@@ -90,43 +91,27 @@ export async function loadProject(args: {
 
 		const [initialized, markInitAsComplete, markInitAsFailed] = createAwaitable()
 		const [loadedSettings, markSettingsAsLoaded, markSettingsAsFailed] = createAwaitable()
+
+		const [resolvedModules, setResolvedModules] =
+			createSignal<Awaited<ReturnType<typeof resolveModules>>>()
 		// -- settings ------------------------------------------------------------
 
 		const [settings, _setSettings] = createSignal<ProjectSettings>()
 		let v2Persistence = false
 		let locales: string[] = []
 
-		// This effect currently has no signals
-		// TODO: replace createEffect with await loadSettings
-		// https://github.com/opral/inlang-message-sdk/issues/77
-		createEffect(() => {
-			// TODO:
-			// if (projectId) {
-			// 	telemetryBrowser.group("project", projectId, {
-			// 		name: projectId,
-			// 	})
-			// }
-
-			loadSettings({ settingsFilePath: projectPath + "/settings.json", nodeishFs })
-				.then((settings) => {
-					setSettings(settings)
-					markSettingsAsLoaded()
-				})
-				.catch((err) => {
-					markInitAsFailed(err)
-					markSettingsAsFailed(err)
-				})
-		})
-		// TODO: create FS watcher and update settings on change
-		// https://github.com/opral/inlang-message-sdk/issues/35
-
-		const writeSettingsToDisk = skipFirst((settings: ProjectSettings) =>
-			_writeSettingsToDisk({ nodeishFs, settings, projectPath })
-		)
+		// TODO:
+		// if (projectId) {
+		// 	telemetryBrowser.group("project", projectId, {
+		// 		name: projectId,
+		// 	})
+		// }
 
-		const setSettings = (settings: ProjectSettings): Result<void, ProjectSettingsInvalidError> => {
+		const setSettings = (
+			newSettings: ProjectSettings
+		): Result<ProjectSettings, ProjectSettingsInvalidError> => {
 			try {
-				const validatedSettings = parseSettings(settings)
+				const validatedSettings = parseSettings(newSettings)
 				v2Persistence = !!validatedSettings.experimental?.persistence
 				locales = validatedSettings.languageTags
 
@@ -136,23 +121,56 @@ export async function loadProject(args: {
 					_setSettings(validatedSettings)
 				})
 
-				writeSettingsToDisk(validatedSettings)
-				return { data: undefined }
+				return { data: validatedSettings }
 			} catch (error: unknown) {
 				if (error instanceof ProjectSettingsInvalidError) {
 					return { error }
 				}
 
 				throw new Error(
-					"Unhandled error in setSettings. This is an internal bug. Please file an issue."
+					"Unhandled error in setSettings. This is an internal bug. Please file an issue.",
+					{ cause: error }
 				)
 			}
 		}
 
-		// -- resolvedModules -----------------------------------------------------------
+		const nodeishFsWithWatchersForSettings = createNodeishFsWithWatcher({
+			nodeishFs: nodeishFs,
+			onChange: async () => {
+				const readSettingsResult = await tryCatch(
+					async () =>
+						await loadSettings({
+							settingsFilePath: projectPath + "/settings.json",
+							nodeishFs: nodeishFs,
+						})
+				)
 
-		const [resolvedModules, setResolvedModules] =
-			createSignal<Awaited<ReturnType<typeof resolveModules>>>()
+				if (readSettingsResult.error) return
+				const newSettings = readSettingsResult.data
+
+				if (JSON.stringify(newSettings) !== JSON.stringify(settings())) {
+					setSettings(newSettings)
+				}
+			},
+		})
+
+		const settingsResult = await tryCatch(
+			async () =>
+				await loadSettings({
+					settingsFilePath: projectPath + "/settings.json",
+					nodeishFs: nodeishFsWithWatchersForSettings,
+				})
+		)
+
+		if (settingsResult.error) {
+			markInitAsFailed(settingsResult.error)
+			markSettingsAsFailed(settingsResult.error)
+		} else {
+			setSettings(settingsResult.data)
+			markSettingsAsLoaded()
+		}
+
+		// -- resolvedModules -----------------------------------------------------------
 
 		createEffect(() => {
 			const _settings = settings()
@@ -318,7 +336,11 @@ export async function loadProject(args: {
 				//...(lintErrors() ?? []),
 			]),
 			settings: createSubscribable(() => settings() as ProjectSettings),
-			setSettings,
+			setSettings: (newSettings: ProjectSettings): Result<void, ProjectSettingsInvalidError> => {
+				const result = setSettings(newSettings)
+				if (!result.error) writeSettingsToDisk({ nodeishFs, settings: result.data, projectPath })
+				return result.error ? result : { data: undefined }
+			},
 			customApi: createSubscribable(() => resolvedModules()?.resolvedPluginApi.customApi || {}),
 			query: {
 				messages: messagesQuery,
@@ -355,6 +377,9 @@ const loadSettings = async (args: {
 	return parseSettings(json.data)
 }
 
+/**
+ * @throws If the settings are not valid
+ */
 const parseSettings = (settings: unknown) => {
 	const withMigration = migrateIfOutdated(settings as any)
 	if (settingsCompiler.Check(withMigration) === false) {
@@ -386,26 +411,24 @@ const parseSettings = (settings: unknown) => {
 	return withMigration
 }
 
-const _writeSettingsToDisk = async (args: {
+const writeSettingsToDisk = async (args: {
 	projectPath: string
 	nodeishFs: NodeishFilesystemSubset
 	settings: ProjectSettings
 }) => {
-	const { data: serializedSettings, error: serializeSettingsError } = tryCatch(() =>
+	const serializeResult = tryCatch(() =>
 		// TODO: this will probably not match the original formatting
 		JSON.stringify(args.settings, undefined, 2)
 	)
-	if (serializeSettingsError) {
-		throw serializeSettingsError
-	}
+	if (serializeResult.error) throw serializeResult.error
+	const serializedSettings = serializeResult.data
 
-	const { error: writeSettingsError } = await tryCatch(async () =>
-		args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings)
+	const writeResult = await tryCatch(
+		async () =>
+			await args.nodeishFs.writeFile(args.projectPath + "/settings.json", serializedSettings)
 	)
 
-	if (writeSettingsError) {
-		throw writeSettingsError
-	}
+	if (writeResult.error) throw writeResult.error
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -426,18 +449,6 @@ const createAwaitable = () => {
 	]
 }
 
-// Skip initial call, eg. to skip setup of a createEffect
-function skipFirst(func: (args: any) => any) {
-	let initial = false
-	return function (...args: any) {
-		if (initial) {
-			// @ts-ignore
-			return func.apply(this, args)
-		}
-		initial = true
-	}
-}
-
 export function createSubscribable<T>(signal: () => T): Subscribable<T> {
 	return Object.assign(signal, {
 		subscribe: (callback: (value: T) => void) => {

package/src/migrations/maybeAddModuleCache.ts

@@ -20,17 +20,32 @@ export async function maybeAddModuleCache(args: {
 
 	if (gitignoreExists) {
 		// non-destructively add any missing ignores
-		const gitignore = await args.repo.nodeishFs.readFile(gitignorePath, { encoding: "utf-8" })
-		const missingIgnores = EXPECTED_IGNORES.filter((ignore) => !gitignore.includes(ignore))
-		if (missingIgnores.length > 0) {
-			await args.repo.nodeishFs.appendFile(gitignorePath, "\n" + missingIgnores.join("\n"))
+		try {
+			const gitignore = await args.repo.nodeishFs.readFile(gitignorePath, { encoding: "utf-8" })
+			const missingIgnores = EXPECTED_IGNORES.filter((ignore) => !gitignore.includes(ignore))
+			if (missingIgnores.length > 0) {
+				await args.repo.nodeishFs.appendFile(gitignorePath, "\n" + missingIgnores.join("\n"))
+			}
+		} catch (error) {
+			throw new Error("[migrate:module-cache] Failed to update .gitignore", { cause: error })
 		}
 	} else {
-		await args.repo.nodeishFs.writeFile(gitignorePath, EXPECTED_IGNORES.join("\n"))
+		try {
+			await args.repo.nodeishFs.writeFile(gitignorePath, EXPECTED_IGNORES.join("\n"))
+		} catch (e) {
+			// @ts-ignore
+			if (e.code && e.code !== "EISDIR" && e.code !== "EEXIST") {
+				throw new Error("[migrate:module-cache] Failed to create .gitignore", { cause: e })
+			}
+		}
 	}
 
 	if (!moduleCacheExists) {
-		await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true })
+		try {
+			await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true })
+		} catch (e) {
+			throw new Error("[migrate:module-cache] Failed to create cache directory", { cause: e })
+		}
 	}
 }
 

package/src/persistence/filelock/acquireFileLock.ts

@@ -22,13 +22,13 @@ export async function acquireFileLock(
 		debug(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount)
 		await fs.mkdir(lockDirPath)
 		// NOTE: fs.stat does not need to be atomic since mkdir would crash atomically - if we are here its save to consider the lock held by this process
-		const stats = await fs.stat(lockDirPath) 
+		const stats = await fs.stat(lockDirPath)
 		debug(lockOrigin + " acquired a lockfile Retry Nr.: " + tryCount)
 
 		return stats.mtimeMs
 	} catch (error: any) {
 		if (error.code !== "EEXIST") {
-		// NOTE in case we have an EEXIST - this is an expected error: the folder existed - another process already acquired the lock. Rethrow all other errors
+			// NOTE in case we have an EEXIST - this is an expected error: the folder existed - another process already acquired the lock. Rethrow all other errors
 			throw error
 		}
 	}

package/src/persistence/filelock/releaseLock.ts

@@ -13,7 +13,7 @@ export async function releaseLock(
 		const stats = await fs.stat(lockDirPath)
 		// I believe this check associates the lock with the aquirer
 		if (stats.mtimeMs === lockTime) {
-		// NOTE: since we have to use a timeout for stale detection (uTimes is not exposed via mermoryfs) the check for the locktime is not sufficient and can fail in rare cases when another process accuires a lock that was identifiert as tale between call to fs.state and rmDir
+			// NOTE: since we have to use a timeout for stale detection (uTimes is not exposed via mermoryfs) the check for the locktime is not sufficient and can fail in rare cases when another process accuires a lock that was identifiert as tale between call to fs.state and rmDir
 			await fs.rmdir(lockDirPath)
 		}
 	} catch (statError: any) {

package/src/resolve-modules/cache.ts

@@ -2,7 +2,6 @@ import type { NodeishFilesystemSubset } from "@inlang/plugin"
 import { type Result, tryCatch } from "@inlang/result"
 
 function escape(url: string) {
-	// collect the bytes of the UTF-8 representation
 	const bytes = new TextEncoder().encode(url)
 
 	// 64-bit FNV1a hash to make the file-names shorter
@@ -36,15 +35,22 @@ async function writeModuleToCache(
 	const moduleHash = escape(moduleURI)
 	const filePath = projectPath + `/cache/modules/${moduleHash}`
 
-	try {
-		await writeFile(filePath, moduleContent)
-	} catch (e) {
-		// if ENONET -> likely means the parent directory does not exist yet
-		if (!(e instanceof Error) || !e.message.includes("ENONET")) return
+	const writeFileResult = await tryCatch(() => writeFile(filePath, moduleContent))
+	if (writeFileResult.error) {
+		const dirPath = projectPath + `/cache/modules`
+		const createDirResult = await tryCatch(() => mkdir(dirPath, { recursive: true }))
 
-		// create the parent directory & retry
-		await mkdir(projectPath + `/cache/modules`, { recursive: true })
-		await writeFile(filePath, moduleContent)
+		// @ts-ignore - If the directory exists we can ignore this error
+		if (createDirResult.error && createDirResult.error.code !== "EEXIST")
+			throw new Error("[sdk:module-cacke] failed to create cache-directory. Path: " + dirPath, {
+				cause: createDirResult.error,
+			})
+
+		const writeFileResult = await tryCatch(() => writeFile(filePath, moduleContent))
+		if (writeFileResult.error)
+			throw new Error("[sdk:module-cacke] failed to write cache-file. Path: " + filePath, {
+				cause: writeFileResult.error,
+			})
 	}
 }
 
@@ -58,15 +64,25 @@ export function withCache(
 ): (uri: string) => Promise<string> {
 	return async (uri: string) => {
 		const cachePromise = readModuleFromCache(uri, projectPath, nodeishFs.readFile)
-		const networkResult = await tryCatch(async () => await moduleLoader(uri))
+		const loaderResult = await tryCatch(async () => await moduleLoader(uri))
 
-		if (networkResult.error) {
+		if (loaderResult.error) {
 			const cacheResult = await cachePromise
 			if (!cacheResult.error) return cacheResult.data
-			else throw networkResult.error
+			else throw loaderResult.error
 		} else {
-			const moduleAsText = networkResult.data
-			await writeModuleToCache(uri, moduleAsText, projectPath, nodeishFs.writeFile, nodeishFs.mkdir)
+			const moduleAsText = loaderResult.data
+			try {
+				await writeModuleToCache(
+					uri,
+					moduleAsText,
+					projectPath,
+					nodeishFs.writeFile,
+					nodeishFs.mkdir
+				)
+			} catch (error) {
+				// TODO trigger a warning
+			}
 			return moduleAsText
 		}
 	}

package/src/resolve-modules/message-lint-rules/resolveMessageLintRules.ts

@@ -12,6 +12,7 @@ export const resolveMessageLintRules = (args: { messageLintRules: Array<MessageL
 			const errors = [...Value.Errors(MessageLintRule, rule)]
 			result.errors.push(
 				new MessageLintRuleIsInvalidError({
+					// @ts-ignore
 					id: rule.id,
 					errors,
 				})

package/src/validateProjectPath.test.ts

@@ -1,11 +1,9 @@
-import { assert, describe, expect, it } from "vitest"
+import { assert, describe, it } from "vitest"
 import {
 	assertValidProjectPath,
 	isAbsolutePath,
 	isInlangProjectPath,
-	pathExists,
 } from "./validateProjectPath.js"
-import { mockRepo } from "@lix-js/client"
 
 describe("isAbsolutePath", () => {
 	it("should correctly identify Unix absolute paths", () => {
@@ -50,19 +48,3 @@ describe("assertValidProjectPath", () => {
 		assert.throws(() => assertValidProjectPath("/path/to/green-elephant.inlang/settings.json"))
 	})
 })
-
-// moar tests in paraglide-js/src/services/file-handling/exists.test.ts
-describe("pathExists", () => {
-	it("should work for files", async () => {
-		const repo = await mockRepo()
-		await repo.nodeishFs.writeFile("/test.txt", "hello")
-		expect(await pathExists("/test.txt", repo.nodeishFs)).toBe(true)
-		expect(await pathExists("/does-not-exist.txt", repo.nodeishFs)).toBe(false)
-	})
-	it("should work for directories", async () => {
-		const repo = await mockRepo()
-		await repo.nodeishFs.mkdir("/test/project.inlang", { recursive: true })
-		expect(await pathExists("/test/project.inlang", repo.nodeishFs)).toBe(true)
-		expect(await pathExists("/test/white-gorilla.inlang", repo.nodeishFs)).toBe(false)
-	})
-})

package/src/validateProjectPath.ts

@@ -1,11 +1,11 @@
-import type { NodeishFilesystem } from "@lix-js/fs"
-
 /**
  * validate that a project path is absolute and ends with {name}.inlang.
  *
  * @throws if the path is not valid.
  */
-export function assertValidProjectPath(projectPath: string) {
+export function assertValidProjectPath(
+	projectPath: string
+): asserts projectPath is `${string}.inlang` {
 	if (!isAbsolutePath(projectPath)) {
 		throw new Error(`Expected an absolute path but received "${projectPath}".`)
 	}
@@ -20,7 +20,7 @@ export function assertValidProjectPath(projectPath: string) {
  * tests whether a path ends with {name}.inlang
  * (does not remove trailing slash)
  */
-export function isInlangProjectPath(path: string) {
+export function isInlangProjectPath(path: string): path is `${string}.inlang` {
 	return /[^\\/]+\.inlang$/.test(path)
 }
 
@@ -36,23 +36,3 @@ export function isAbsolutePath(path: string) {
 	// 	/^(?:[A-Za-z]:\\(?:[^\\]+\\)*[^\\]+|[A-Za-z]:\/(?:[^/]+\/)*[^/]+|\/(?:[^/]+\/)*[^/]+)$/
 	// return matchPosixAndWindowsAbsolutePaths.test(path)
 }
-
-/**
- * Returns true if the path exists (file or directory), false otherwise.
- *
- */
-export async function pathExists(filePath: string, nodeishFs: NodeishFilesystem) {
-	// from paraglide-js/src/services/file-handling/exists.ts
-	// TODO: add fs.exists to @lix-js/fs
-	try {
-		await nodeishFs.stat(filePath)
-		return true
-	} catch (error) {
-		//@ts-ignore
-		if (error.code === "ENOENT") {
-			return false
-		} else {
-			throw new Error(`Failed to check if path exists: ${error}`, { cause: error })
-		}
-	}
-}