@inlang/sdk 0.34.3 → 0.34.5

package/src/persistence/filelock/acquireFileLock.ts

@@ -0,0 +1,124 @@
+import { type NodeishFilesystem } from "@lix-js/fs"
+import type { NodeishStats } from "@lix-js/fs"
+import _debug from "debug"
+const debug = _debug("sdk:acquireFileLock")
+
+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 (5) to acquire lockfile " + tryCount)
+	}
+
+	try {
+		debug(lockOrigin + " tries to acquire a lockfile Retry Nr.: " + tryCount)
+		await fs.mkdir(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") {
+			// we only expect the error that the file exists already (locked by other process)
+			throw error
+		}
+	}
+
+	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

@@ -0,0 +1,28 @@
+import { type NodeishFilesystem } from "@lix-js/fs"
+import _debug from "debug"
+const debug = _debug("sdk:releaseLock")
+
+export async function releaseLock(
+	fs: NodeishFilesystem,
+	lockDirPath: string,
+	lockOrigin: string,
+	lockTime: number
+) {
+	debug(lockOrigin + " releasing the lock ")
+	try {
+		const stats = await fs.stat(lockDirPath)
+		if (stats.mtimeMs === lockTime) {
+			// this can be corrupt as welll since the last getStat and the current a modification could have occured :-/
+			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/v2/index.ts

@@ -0,0 +1 @@
+export type * from "./types.js"

package/src/v2/types.ts

@@ -0,0 +1,142 @@
+import { Type, type Static } from "@sinclair/typebox"
+
+/**
+ * Follows the IETF BCP 47 language tag schema.
+ *
+ * @see https://www.ietf.org/rfc/bcp/bcp47.txt
+ * @see https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
+ */
+export type LanguageTag = Static<typeof LanguageTag>
+/**
+ * Follows the IETF BCP 47 language tag schema with modifications.
+ * @see REAMDE.md file for more information on the validation.
+ */
+
+export const pattern =
+	"^((?<grandfathered>(en-GB-oed|i-ami|i-bnn|i-default|i-enochian|i-hak|i-klingon|i-lux|i-mingo|i-navajo|i-pwn|i-tao|i-tay|i-tsu|sgn-BE-FR|sgn-BE-NL|sgn-CH-DE)|(art-lojban|cel-gaulish|no-bok|no-nyn|zh-guoyu|zh-hakka|zh-min|zh-min-nan|zh-xiang))|((?<language>([A-Za-z]{2,3}(-(?<extlang>[A-Za-z]{3}(-[A-Za-z]{3}){0,2}))?))(-(?<script>[A-Za-z]{4}))?(-(?<region>[A-Za-z]{2}|[0-9]{3}))?(-(?<variant>[A-Za-z0-9]{5,8}|[0-9][A-Za-z0-9]{3}))*))$"
+
+export const LanguageTag = Type.String({
+	pattern: pattern,
+	description: "The language tag must be a valid IETF BCP 47 language tag.",
+	examples: ["en", "de", "en-US", "zh-Hans", "es-419"],
+})
+
+export type Literal = Static<typeof Literal>
+export const Literal = Type.Object({
+	type: Type.Literal("literal"),
+	value: Type.String(),
+})
+
+/**
+ * A (text) element that is translatable and rendered to the UI.
+ */
+export type Text = Static<typeof Text>
+export const Text = Type.Object({
+	type: Type.Literal("text"),
+	value: Type.String(),
+})
+
+export type VariableReference = Static<typeof VariableReference>
+export const VariableReference = Type.Object({
+	type: Type.Literal("variable"),
+	name: Type.String(),
+})
+
+export type Option = Static<typeof Option>
+export const Option = Type.Object({
+	name: Type.String(),
+	value: Type.Union([Literal, VariableReference]),
+})
+
+export type FunctionAnnotation = Static<typeof FunctionAnnotation>
+export const FunctionAnnotation = Type.Object({
+	type: Type.Literal("function"),
+	name: Type.String(),
+	options: Type.Array(Option),
+})
+
+/**
+ * An expression is a reference to a variable or a function.
+ *
+ * Think of expressions as elements that are rendered to a
+ * text value during runtime.
+ */
+export type Expression = Static<typeof Expression>
+export const Expression = Type.Object({
+	type: Type.Literal("expression"),
+	arg: Type.Union([Literal, VariableReference]),
+	annotation: Type.Optional(FunctionAnnotation),
+})
+
+// export type FunctionReference = {
+// 	type: "function"
+// 	name: string
+// 	operand?: Text | VariableReference
+// 	options?: Option[]
+// }
+
+/**
+ * A pattern is a sequence of elements that comprise
+ * a message that is rendered to the UI.
+ */
+export type Pattern = Static<typeof Pattern>
+export const Pattern = Type.Array(Type.Union([Text, Expression]))
+
+/**
+ * A variant contains a pattern that is rendered to the UI.
+ */
+export type Variant = Static<typeof Variant>
+export const Variant = Type.Object({
+	/**
+	 * The number of keys in each variant match MUST equal the number of expressions in the selectors.
+	 *
+	 * Inspired by: https://github.com/unicode-org/message-format-wg/blob/main/spec/formatting.md#pattern-selection
+	 */
+	// a match can always only be string-based because a string is what is rendered to the UI
+	match: Type.Array(Type.String()),
+	pattern: Pattern,
+})
+
+export type InputDeclaration = Static<typeof InputDeclaration>
+export const InputDeclaration = Type.Object({
+	type: Type.Literal("input"),
+	name: Type.String(),
+
+	//TODO make this generic so that only Variable-Ref Expressions are allowed
+	value: Expression,
+})
+
+// local declarations are not supported.
+// Will only add when required. See discussion:
+// https://github.com/opral/monorepo/pull/2700#discussion_r1591070701
+//
+// export type LocalDeclaration = Static<typeof InputDeclaration>
+// export const LocalDeclaration = Type.Object({
+// 	type: Type.Literal("local"),
+// 	name: Type.String(),
+// 	value: Expression,
+// })
+//
+// export type Declaration = Static<typeof Declaration>
+// export const Declaration = Type.Union([LocalDeclaration, InputDeclaration])
+
+export type Declaration = Static<typeof Declaration>
+export const Declaration = Type.Union([InputDeclaration])
+
+export type Message = Static<typeof Message>
+export const Message = Type.Object({
+	locale: LanguageTag,
+	declarations: Type.Array(Declaration),
+	/**
+	 * The order in which the selectors are placed determines the precedence of patterns.
+	 */
+	selectors: Type.Array(Expression),
+	variants: Type.Array(Variant),
+})
+
+export type MessageBundle = Static<typeof MessageBundle>
+export const MessageBundle = Type.Object({
+	id: Type.String(),
+	alias: Type.Record(Type.String(), Type.String()),
+	messages: Type.Array(Message),
+})