@inlang/sdk 0.36.3 → 2.0.0-beta.1

package/src/persistence/filelock/acquireFileLock.ts

@@ -1,129 +0,0 @@
-import { type NodeishFilesystem } from "@lix-js/fs"
-import type { NodeishStats } from "@lix-js/fs"
-import _debug from "debug"
-const debug = _debug("sdk:fileLock")
-
-const maxRetries = 10
-const nProbes = 50
-const probeInterval = 100
-export async function acquireFileLock(
-	fs: NodeishFilesystem,
-	lockDirPath: string,
-	lockOrigin: string,
-	tryCount: number = 0
-): Promise<number> {
-	if (tryCount > maxRetries) {
-		throw new Error(
-			`${lockOrigin} exceeded maximum retries (${maxRetries}) to acquire lockfile ${tryCount}`
-		)
-	}
-
-	try {
-		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)
-		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
-			throw error
-		}
-	}
-
-	// land here if the lockDirPath already exists => lock is held by other process
-	let currentLockTime: number
-
-	try {
-		const stats = await fs.stat(lockDirPath)
-		currentLockTime = stats.mtimeMs
-	} catch (fstatError: any) {
-		if (fstatError.code === "ENOENT") {
-			// lock file seems to be gone :) - lets try again
-			debug(lockOrigin + " tryCount++ lock file seems to be gone :) - lets try again " + tryCount)
-			return acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1)
-		}
-		throw fstatError
-	}
-	debug(
-		lockOrigin +
-			" tries to acquire a lockfile  - lock currently in use... starting probe phase " +
-			tryCount
-	)
-
-	return new Promise((resolve, reject) => {
-		let probeCounts = 0
-		const scheduleProbationTimeout = () => {
-			setTimeout(async () => {
-				probeCounts += 1
-				let lockFileStats: undefined | NodeishStats = undefined
-				try {
-					debug(
-						lockOrigin + " tries to acquire a lockfile - check if the lock is free now " + tryCount
-					)
-
-					// alright lets give it another try
-					lockFileStats = await fs.stat(lockDirPath)
-				} catch (fstatError: any) {
-					if (fstatError.code === "ENOENT") {
-						debug(
-							lockOrigin +
-								" tryCount++ in Promise - tries to acquire a lockfile - lock file seems to be free now - try to acquire " +
-								tryCount
-						)
-						const lock = acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1)
-						return resolve(lock)
-					}
-					return reject(fstatError)
-				}
-
-				// still the same locker! -
-				if (lockFileStats.mtimeMs === currentLockTime) {
-					if (probeCounts >= nProbes) {
-						// ok maximum lock time ran up (we waitetd nProbes * probeInterval) - we consider the lock to be stale
-						debug(
-							lockOrigin +
-								" tries to acquire a lockfile  - lock not free - but stale lets drop it" +
-								tryCount
-						)
-						try {
-							await fs.rmdir(lockDirPath)
-						} catch (rmLockError: any) {
-							if (rmLockError.code === "ENOENT") {
-								// lock already gone?
-								// Option 1: The "stale process" decided to get rid of it
-								// Option 2: Another process acquiring the lock and detected a stale one as well
-							}
-							return reject(rmLockError)
-						}
-						try {
-							debug(
-								lockOrigin +
-									" tryCount++ same locker - try to acquire again after removing stale lock " +
-									tryCount
-							)
-							const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1)
-							return resolve(lock)
-						} catch (lockAquireException) {
-							return reject(lockAquireException)
-						}
-					} else {
-						// lets schedule a new probation
-						return scheduleProbationTimeout()
-					}
-				} else {
-					try {
-						debug(lockOrigin + " tryCount++ different locker - try to acquire again " + tryCount)
-						const lock = await acquireFileLock(fs, lockDirPath, lockOrigin, tryCount + 1)
-						return resolve(lock)
-					} catch (error) {
-						return reject(error)
-					}
-				}
-			}, probeInterval)
-		}
-		scheduleProbationTimeout()
-	})
-}

package/src/persistence/filelock/releaseLock.ts

@@ -1,29 +0,0 @@
-import { type NodeishFilesystem } from "@lix-js/fs"
-import _debug from "debug"
-const debug = _debug("sdk:fileLock")
-
-export async function releaseLock(
-	fs: NodeishFilesystem,
-	lockDirPath: string,
-	lockOrigin: string,
-	lockTime: number
-) {
-	debug(lockOrigin + " releasing the lock ")
-	try {
-		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
-			await fs.rmdir(lockDirPath)
-		}
-	} catch (statError: any) {
-		debug(lockOrigin + " couldn't release the lock")
-		if (statError.code === "ENOENT") {
-			// ok seeks like the log was released by someone else
-			debug(lockOrigin + " WARNING - the lock was released by a different process")
-			return
-		}
-		debug(statError)
-		throw statError
-	}
-}

package/src/persistence/store.test.ts

@@ -1,102 +0,0 @@
-import { test, expect } from "vitest"
-import { createNodeishMemoryFs } from "../test-utilities/index.js"
-import type { MessageBundle } from "../v2/types.js"
-import { createMessageBundle, createMessage, injectJSONNewlines, addSlots } from "../v2/helper.js"
-import { openStore, readJSON, writeJSON } from "./store.js"
-
-const locales = ["en", "de"]
-
-const mockMessages: MessageBundle[] = [
-	createMessageBundle({
-		id: "first_message",
-		messages: [
-			createMessage({
-				locale: "en",
-				text: "If this fails I will be sad",
-			}),
-		],
-	}),
-	createMessageBundle({
-		id: "second_message",
-		messages: [
-			createMessage({ locale: "en", text: "Let's see if this works" }),
-			createMessage({ locale: "de", text: "Mal sehen ob das funktioniert" }),
-		],
-	}),
-]
-
-test("roundtrip readJSON/writeJSON", async () => {
-	const nodeishFs = createNodeishMemoryFs()
-	const projectPath = "/test/project.inlang"
-	const filePath = projectPath + "/messages.json"
-	const persistedMessages = injectJSONNewlines(
-		JSON.stringify(mockMessages.map((bundle) => addSlots(bundle, locales)))
-	)
-
-	await nodeishFs.mkdir(projectPath, { recursive: true })
-	await nodeishFs.writeFile(filePath, persistedMessages)
-
-	const firstMessageLoad = await readJSON({
-		filePath,
-		nodeishFs: nodeishFs,
-	})
-
-	expect(firstMessageLoad).toStrictEqual(mockMessages)
-
-	await writeJSON({
-		filePath,
-		nodeishFs,
-		messages: firstMessageLoad,
-		locales,
-	})
-
-	const afterRoundtrip = await nodeishFs.readFile(filePath, { encoding: "utf-8" })
-
-	expect(afterRoundtrip).toStrictEqual(persistedMessages)
-
-	const messagesAfterRoundtrip = await readJSON({
-		filePath,
-		nodeishFs,
-	})
-
-	expect(messagesAfterRoundtrip).toStrictEqual(firstMessageLoad)
-})
-
-test("openStore does minimal CRUD on messageBundles", async () => {
-	const nodeishFs = createNodeishMemoryFs()
-	const projectPath = "/test/project.inlang"
-	const filePath = projectPath + "/messages.json"
-	const persistedMessages = JSON.stringify(mockMessages)
-
-	await nodeishFs.mkdir(projectPath, { recursive: true })
-	await nodeishFs.writeFile(filePath, persistedMessages)
-
-	const store = await openStore({ projectPath, nodeishFs, locales })
-
-	const messages = await store.messageBundles.getAll()
-	expect(messages).toStrictEqual(mockMessages)
-
-	const firstMessageBundle = await store.messageBundles.get({ id: "first_message" })
-	expect(firstMessageBundle).toStrictEqual(mockMessages[0])
-
-	const modifedMessageBundle = structuredClone(firstMessageBundle) as MessageBundle
-	const newMessage = createMessage({ locale: "de", text: "Wenn dies schiefläuft, bin ich sauer" })
-	modifedMessageBundle.messages.push(newMessage)
-	await store.messageBundles.set({ data: modifedMessageBundle })
-
-	const setMessageBundle = await store.messageBundles.get({ id: "first_message" })
-	expect(setMessageBundle).toStrictEqual(modifedMessageBundle)
-
-	// no need to sleep here
-	// with batchedIO, the set should await until the write is done
-	const messagesAfterRoundtrip = await readJSON({
-		filePath,
-		nodeishFs,
-	})
-	const expected = [setMessageBundle, ...mockMessages.slice(1)]
-	expect(messagesAfterRoundtrip).toStrictEqual(expected)
-
-	await store.messageBundles.delete({ id: "first_message" })
-	const messagesAfterDelete = await store.messageBundles.getAll()
-	expect(messagesAfterDelete).toStrictEqual(mockMessages.slice(1))
-})

package/src/persistence/store.ts

@@ -1,119 +0,0 @@
-import type { MessageBundle } from "../v2/types.js"
-import { addSlots, removeSlots, injectJSONNewlines } from "../v2/helper.js"
-import { getDirname, type NodeishFilesystem } from "@lix-js/fs"
-import { acquireFileLock } from "./filelock/acquireFileLock.js"
-import { releaseLock } from "./filelock/releaseLock.js"
-import { batchedIO } from "./batchedIO.js"
-import type { StoreApi } from "./storeApi.js"
-
-import _debug from "debug"
-const debug = _debug("sdk:store")
-
-export async function openStore(args: {
-	projectPath: string
-	nodeishFs: NodeishFilesystem
-	locales: string[]
-}): Promise<StoreApi> {
-	const nodeishFs = args.nodeishFs
-	const filePath = args.projectPath + "/messages.json"
-	const lockDirPath = args.projectPath + "/messagelock"
-
-	// the index holds the in-memory state
-	// TODO: reload when file changes on disk
-	// https://github.com/opral/inlang-message-sdk/issues/80
-	let index = await load()
-
-	const batchedSave = batchedIO(acquireSaveLock, releaseSaveLock, save)
-
-	return {
-		messageBundles: {
-			reload: async () => {
-				index.clear()
-				index = await load()
-			},
-			get: async (args: { id: string }) => {
-				return index.get(args.id)
-			},
-			set: async (args: { data: MessageBundle }) => {
-				index.set(args.data.id, args.data)
-				await batchedSave(args.data.id)
-			},
-			delete: async (args: { id: string }) => {
-				index.delete(args.id)
-				await batchedSave(args.id)
-			},
-			getAll: async () => {
-				return [...index.values()]
-			},
-		},
-	}
-
-	// load and save messages from file system atomically
-	// using a lock file to prevent partial reads and writes
-	async function load() {
-		const lockTime = await acquireFileLock(nodeishFs, lockDirPath, "load")
-		const messages = await readJSON({ filePath, nodeishFs: nodeishFs })
-		const index = new Map<string, MessageBundle>(messages.map((message) => [message.id, message]))
-		await releaseLock(nodeishFs, lockDirPath, "load", lockTime)
-		return index
-	}
-	async function acquireSaveLock() {
-		return await acquireFileLock(nodeishFs, lockDirPath, "save")
-	}
-	async function releaseSaveLock(lock: number) {
-		return await releaseLock(nodeishFs, lockDirPath, "save", lock)
-	}
-	async function save() {
-		await writeJSON({
-			filePath,
-			nodeishFs: nodeishFs,
-			messages: [...index.values()],
-			locales: args.locales,
-		})
-	}
-}
-
-export async function readJSON(args: { filePath: string; nodeishFs: NodeishFilesystem }) {
-	let result: MessageBundle[] = []
-
-	debug("loadAll", args.filePath)
-	try {
-		const file = await args.nodeishFs.readFile(args.filePath, { encoding: "utf-8" })
-		result = JSON.parse(file)
-	} catch (error) {
-		if ((error as any)?.code !== "ENOENT") {
-			debug("loadMessages", error)
-			throw error
-		}
-	}
-	return result.map(removeSlots)
-}
-
-export async function writeJSON(args: {
-	filePath: string
-	nodeishFs: NodeishFilesystem
-	messages: MessageBundle[]
-	locales: string[]
-}) {
-	debug("saveall", args.filePath)
-	try {
-		await createDirectoryIfNotExits(getDirname(args.filePath), args.nodeishFs)
-		const output = injectJSONNewlines(
-			JSON.stringify(args.messages.map((bundle) => addSlots(bundle, args.locales)))
-		)
-		await args.nodeishFs.writeFile(args.filePath, output)
-	} catch (error) {
-		debug("saveMessages", error)
-		throw error
-	}
-}
-
-async function createDirectoryIfNotExits(path: string, nodeishFs: NodeishFilesystem) {
-	try {
-		await nodeishFs.mkdir(path, { recursive: true })
-	} catch (error: any) {
-		if (error.code !== "EEXIST") {
-			throw error
-		}
-	}
-}

package/src/persistence/storeApi.ts

@@ -1,19 +0,0 @@
-import type * as V2 from "../v2/types.js"
-
-/**
- * WIP async V2 store interface
- * E.g. `await project.store.messageBundles.get({ id: "..." })`
- **/
-export type StoreApi = {
-	messageBundles: Store<V2.MessageBundle>
-}
-
-export interface Store<T> {
-	// TODO: remove reload when fs.watch can trigger auto-invalidation
-	reload: () => Promise<void>
-
-	get: (args: { id: string }) => Promise<T | undefined>
-	set: (args: { data: T }) => Promise<void>
-	delete: (args: { id: string }) => Promise<void>
-	getAll: () => Promise<T[]>
-}

package/src/reactivity/map.ts

@@ -1,135 +0,0 @@
-// @ts-nocheck
-/* eslint-disable */
-
-import { batch } from "./solid.js"
-import { TriggerCache } from "./trigger.js"
-
-// src/index.ts
-var $KEYS = Symbol("track-keys")
-var ReactiveMap = class extends Map {
-	#keyTriggers = new TriggerCache()
-	#valueTriggers = new TriggerCache()
-	constructor(initial) {
-		super()
-		if (initial) for (const v of initial) super.set(v[0], v[1])
-	}
-	// reads
-	has(key) {
-		this.#keyTriggers.track(key)
-		return super.has(key)
-	}
-	get(key) {
-		this.#valueTriggers.track(key)
-		return super.get(key)
-	}
-	get size() {
-		this.#keyTriggers.track($KEYS)
-		return super.size
-	}
-	keys() {
-		this.#keyTriggers.track($KEYS)
-		return super.keys()
-	}
-	values() {
-		this.#keyTriggers.track($KEYS)
-		for (const v of super.keys()) this.#valueTriggers.track(v)
-		return super.values()
-	}
-	entries() {
-		this.#keyTriggers.track($KEYS)
-		for (const v of super.keys()) this.#valueTriggers.track(v)
-		return super.entries()
-	}
-	// writes
-	set(key, value) {
-		batch(() => {
-			if (super.has(key)) {
-				if (super.get(key) === value) return
-			} else {
-				this.#keyTriggers.dirty(key)
-				this.#keyTriggers.dirty($KEYS)
-			}
-			this.#valueTriggers.dirty(key)
-			super.set(key, value)
-		})
-		return this
-	}
-	delete(key) {
-		const r = super.delete(key)
-		if (r) {
-			batch(() => {
-				this.#keyTriggers.dirty(key)
-				this.#keyTriggers.dirty($KEYS)
-				this.#valueTriggers.dirty(key)
-			})
-		}
-		return r
-	}
-	clear() {
-		if (super.size) {
-			batch(() => {
-				for (const v of super.keys()) {
-					this.#keyTriggers.dirty(v)
-					this.#valueTriggers.dirty(v)
-				}
-				super.clear()
-				this.#keyTriggers.dirty($KEYS)
-			})
-		}
-	}
-	// callback
-	forEach(callbackfn) {
-		this.#keyTriggers.track($KEYS)
-		super.forEach((value, key) => callbackfn(value, key, this))
-	}
-	[Symbol.iterator]() {
-		return this.entries()
-	}
-}
-var ReactiveWeakMap = class extends WeakMap {
-	#keyTriggers = new TriggerCache(WeakMap)
-	#valueTriggers = new TriggerCache(WeakMap)
-	constructor(initial) {
-		super()
-		if (initial) for (const v of initial) super.set(v[0], v[1])
-	}
-	has(key) {
-		this.#keyTriggers.track(key)
-		return super.has(key)
-	}
-	get(key) {
-		this.#valueTriggers.track(key)
-		return super.get(key)
-	}
-	set(key, value) {
-		batch(() => {
-			if (super.has(key)) {
-				if (super.get(key) === value) return
-			} else this.#keyTriggers.dirty(key)
-			this.#valueTriggers.dirty(key)
-			super.set(key, value)
-		})
-		return this
-	}
-	delete(key) {
-		const r = super.delete(key)
-		if (r) {
-			batch(() => {
-				this.#keyTriggers.dirty(key)
-				this.#valueTriggers.dirty(key)
-			})
-		}
-		return r
-	}
-}
-function createMap(initial) {
-	const map = new ReactiveMap(initial)
-	return new Proxy(() => [...map], {
-		get: (_, b) => map[b],
-	})
-}
-function createWeakMap(initial) {
-	return new ReactiveWeakMap(initial)
-}
-
-export { ReactiveMap, ReactiveWeakMap, createMap, createWeakMap }