@inlang/sdk 0.36.3 → 2.0.0-beta.1

package/src/messages/variant.ts

@@ -1,247 +0,0 @@
-import type { LanguageTag, Message, Variant } from "../versionedInterfaces.js"
-import type { Result } from "@inlang/result"
-import {
-	MessagePatternsForLanguageTagDoNotExistError,
-	MessageVariantAlreadyExistsError,
-	MessageVariantDoesNotExistError,
-} from "./errors.js"
-
-/**
- * Tries to match the most specific variant of a message.
- *
- * The selectors determine the specificity of a variant. If no selectors are provided,
- * or if the selectors do not match any variant, the catch all variant is returned
- * (if it exists).
- *
- * @example
- * 	const variant = getVariant(message, { where: { languageTag: "en", match: ["male"]}});
- */
-export function getVariant(
-	message: Message,
-	args: {
-		where: {
-			languageTag: LanguageTag
-			match?: Variant["match"]
-		}
-	}
-): Variant | undefined {
-	const variant = matchMostSpecificVariant(message, args.where.languageTag, args.where.match)
-	if (variant) {
-		//! do not return a reference to the message in a resource
-		//! modifications to the returned message will leak into the
-		//! resource which is considered to be immutable.
-		return structuredClone(variant)
-	}
-	return undefined
-}
-
-/**
- * Create a variant for a message
- *
- * All actions are immutable.
- *
- * @example
- *  const message = createVariant(message, { languageTag: "en", data: variant })
- */
-export function createVariant(
-	message: Message,
-	args: {
-		data: Variant
-	}
-): Result<Message, MessageVariantAlreadyExistsError> {
-	const copy = structuredClone(message)
-
-	// check if variant already exists
-	if (matchVariant(copy, args.data.languageTag, args.data.match)) {
-		return { error: new MessageVariantAlreadyExistsError(message.id, args.data.languageTag) }
-	}
-
-	copy.variants.push({
-		...args.data,
-		match: args.data.match,
-	})
-	return { data: copy }
-}
-
-/**
- * Update a variant of a message
- *
- * All actions are immutable.
- *
- * @example
- *  const message = updateVariant(message, { languageTag: "en", match: ["male"], pattern: []})
- */
-export function updateVariantPattern(
-	message: Message,
-	args: {
-		where: {
-			languageTag: LanguageTag
-			match: Variant["match"]
-		}
-		data: Variant["pattern"]
-	}
-): Result<Message, MessageVariantDoesNotExistError | MessagePatternsForLanguageTagDoNotExistError> {
-	const copy = structuredClone(message)
-
-	const containsLanguageTag = message.variants.some(
-		(variant) => variant.languageTag === args.where.languageTag
-	)
-	if (!containsLanguageTag) {
-		return {
-			error: new MessagePatternsForLanguageTagDoNotExistError(message.id, args.where.languageTag),
-		}
-	}
-
-	const variant = matchVariant(copy, args.where.languageTag, args.where.match)
-	if (variant === undefined) {
-		return { error: new MessageVariantDoesNotExistError(message.id, args.where.languageTag) }
-	}
-	if (variant) {
-		variant.pattern = args.data
-		return { data: copy }
-	}
-	return { error: new MessageVariantDoesNotExistError(message.id, args.where.languageTag) }
-}
-
-/**
- * Returns the specific variant defined by selectors or undefined
- *
- * @example
- *  const variant = matchVariant(message, languageTag: "en", match: ["male"])
- */
-const matchVariant = (
-	message: Message,
-	languageTag: LanguageTag,
-	match: Variant["match"]
-): Variant | undefined => {
-	const languageVariants = message.variants.filter((variant) => variant.languageTag === languageTag)
-	if (languageVariants.length === 0) return undefined
-
-	for (const variant of languageVariants) {
-		let isMatch = true
-		//check if vaiant is a match
-		if (variant.match.length > 0) {
-			variant.match.map((value, index) => {
-				if (match && match[index] !== value) {
-					isMatch = false
-				}
-			})
-		}
-
-		if (!message.selectors || !match || match.length !== message.selectors.length) {
-			isMatch = false
-		}
-
-		if (isMatch) {
-			return variant
-		}
-	}
-	return undefined
-}
-
-/**
- * Returns the most specific variant of a message.
- *
- * @example
- *  const variant = matchMostSpecificVariant(message, languageTag: "en", selectors: { gender: "male" })
- */
-const matchMostSpecificVariant = (
-	message: Message,
-	languageTag: LanguageTag,
-	match?: Variant["match"]
-): Variant | undefined => {
-	// resolve preferenceSelectors to match length and order of message selectors
-	const index: Record<string, any> = {}
-
-	for (const variant of message.variants) {
-		if (variant.languageTag !== languageTag) continue
-
-		let isMatch = true
-
-		// if slector and stored match are not the same throw error
-		if (variant.match.length !== message.selectors.length) {
-			return undefined
-		}
-
-		//check if variant is a match
-		if (variant.match.length > 0) {
-			variant.match.map((value, index) => {
-				if (match && match[index] !== value && value !== "*") {
-					isMatch = false
-				}
-			})
-		}
-		if (isMatch && match && match.length > 0) {
-			// eslint-disable-next-line no-inner-declarations
-			function recursiveAddToIndex(
-				currentIndex: Record<string, any>,
-				selectorIndex: number,
-				selectorLength: number,
-				variant: Variant
-			) {
-				const key = variant.match[selectorIndex]
-				if (key) {
-					if (selectorIndex === 1) {
-						currentIndex[key] = variant
-					} else {
-						if (!currentIndex[key]) {
-							currentIndex[key] = {}
-						}
-						recursiveAddToIndex(currentIndex[key], selectorIndex + 1, selectorLength, variant)
-					}
-				}
-			}
-			recursiveAddToIndex(index, 0, message.selectors ? message.selectors.length - 1 : 0, variant)
-		} else if (isMatch && !match) {
-			return variant
-		}
-	}
-
-	// if number of selectors and numver of required match is not the same match catch all
-	if (!message.selectors || !match || match.length !== message.selectors.length) {
-		const catchAllMatcher: Array<string> = []
-		const selectorCount = message.selectors.length
-		catchAllMatcher.push("*")
-		for (let i = 0; i < selectorCount - 1; i++) {
-			catchAllMatcher.push("*")
-		}
-		return message.variants.find(
-			(v) =>
-				v.languageTag === languageTag && JSON.stringify(v.match) === JSON.stringify(catchAllMatcher)
-		)
-	}
-
-	// if selector is empty match empty variant match
-	if (message.selectors && message.selectors.length === 0) {
-		return message.variants.find(
-			(v) => v.languageTag === languageTag && JSON.stringify(v.match) === "[]"
-		)
-	}
-
-	//find the most specific variant
-	const findOptimalMatch = (
-		index: Record<string, any>,
-		selectors: string[]
-	): Variant | undefined => {
-		const keys = Object.keys(index)
-
-		for (const key of keys) {
-			if (key === selectors[0] || key === "*") {
-				const nextOptimal = selectors.slice(1)
-
-				if (nextOptimal.length === 0) {
-					return (index[key] as Variant) || undefined
-				}
-
-				const match = findOptimalMatch(index[key] as Record<string, any>, nextOptimal)
-
-				if (match !== undefined) {
-					return match
-				}
-			}
-		}
-		return undefined
-	}
-
-	return findOptimalMatch(index, match || [])
-}

package/src/migrations/maybeAddModuleCache.ts

@@ -1,68 +0,0 @@
-import type { Repository } from "@lix-js/client"
-import type { NodeishFilesystem } from "@lix-js/fs"
-
-const EXPECTED_IGNORES = ["cache"]
-
-export async function maybeAddModuleCache(args: {
-	projectPath: string
-	repo?: Repository
-}): Promise<void> {
-	if (args.repo === undefined) return
-
-	const projectExists = await directoryExists(args.projectPath, args.repo.nodeishFs)
-	if (!projectExists) return
-
-	const gitignorePath = args.projectPath + "/.gitignore"
-	const moduleCache = args.projectPath + "/cache/modules/"
-
-	const gitignoreExists = await fileExists(gitignorePath, args.repo.nodeishFs)
-	const moduleCacheExists = await directoryExists(moduleCache, args.repo.nodeishFs)
-
-	if (gitignoreExists) {
-		// non-destructively add any missing ignores
-		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 {
-		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) {
-		try {
-			await args.repo.nodeishFs.mkdir(moduleCache, { recursive: true })
-		} catch (e) {
-			throw new Error("[migrate:module-cache] Failed to create cache directory", { cause: e })
-		}
-	}
-}
-
-async function fileExists(path: string, nodeishFs: NodeishFilesystem): Promise<boolean> {
-	try {
-		const stat = await nodeishFs.stat(path)
-		return stat.isFile()
-	} catch {
-		return false
-	}
-}
-
-async function directoryExists(path: string, nodeishFs: NodeishFilesystem): Promise<boolean> {
-	try {
-		const stat = await nodeishFs.stat(path)
-		return stat.isDirectory()
-	} catch {
-		return false
-	}
-}

package/src/migrations/maybeCreateFirstProjectId.test.ts

@@ -1,31 +0,0 @@
-import { generateProjectId } from "./maybeCreateFirstProjectId.js"
-import { it, expect } from "vitest"
-import { mockRepo } from "@lix-js/client"
-import { type Snapshot } from "@lix-js/fs"
-// eslint-disable-next-line no-restricted-imports -- test
-import { readFileSync } from "node:fs"
-
-const ciTestRepo: Snapshot = JSON.parse(
-	readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" })
-)
-const repo = await mockRepo({ fromSnapshot: ciTestRepo as Snapshot })
-
-it("should return if repo is undefined", async () => {
-	const projectId = await generateProjectId({ repo: undefined, projectPath: "mocked_project_path" })
-	expect(projectId).toBeUndefined()
-})
-
-it("should generate a project id", async () => {
-	const projectId = await generateProjectId({ repo, projectPath: "mocked_project_path" })
-	expect(projectId).toBe("432d7ef29c510e99d95e2d14ef57a0797a1603859b5a851b7dff7e77161b8c08")
-})
-
-it("should return undefined if repoMeta contains error", async () => {
-	await repo.nodeishFs.rm("/.git", { recursive: true })
-
-	const projectId = await generateProjectId({
-		repo: repo,
-		projectPath: "mocked_project_path",
-	})
-	expect(projectId).toBeUndefined()
-})

package/src/migrations/maybeCreateFirstProjectId.ts

@@ -1,51 +0,0 @@
-import type { Repository } from "@lix-js/client"
-import { hash } from "@lix-js/client"
-
-/**
- * Creates a project id if it does not exist yet.
- *
- * - this is a migration to ensure that all projects have a project id
- * - new projects are created with a project id (in the future)
- */
-export async function maybeCreateFirstProjectId(args: {
-	projectPath: string
-	repo?: Repository
-}): Promise<void> {
-	// the migration assumes a repository
-	if (args.repo === undefined) {
-		return
-	}
-	try {
-		await args.repo.nodeishFs.readFile(args.projectPath + "/project_id", {
-			encoding: "utf-8",
-		})
-	} catch (error) {
-		// @ts-ignore
-		if (error.code === "ENOENT" && args.repo) {
-			const projectId = await generateProjectId({ repo: args.repo, projectPath: args.projectPath })
-			if (projectId) {
-				await args.repo.nodeishFs
-					.writeFile(args.projectPath + "/project_id", projectId)
-					.catch((error) => {
-						console.error("Failed to write project_id", error)
-					})
-			}
-		}
-	}
-}
-
-export async function generateProjectId(args: { repo?: Repository; projectPath: string }) {
-	if (!args.repo || !args.projectPath) {
-		return undefined
-	}
-	const firstCommitHash = await args.repo.getFirstCommitHash()
-
-	if (firstCommitHash) {
-		try {
-			return await hash(`${firstCommitHash + args.projectPath}`)
-		} catch (error) {
-			console.error("Failed to generate project_id", error)
-		}
-	}
-	return undefined
-}

package/src/migrations/migrateToDirectory.test.ts

@@ -1,54 +0,0 @@
-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

@@ -1,62 +0,0 @@
-import { tryCatch } from "@inlang/result"
-import type { NodeishFilesystem } from "@lix-js/fs"
-
-/**
- * Migrates to the new project directory structure
- * https://github.com/opral/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)
-
-	// eslint-disable-next-line no-console
-	// console.log("🔔 migrated project.inlang to directory")
-}
-
-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/opral/monorepo/issues/1678.
-
-- Monorepo support https://github.com/opral/monorepo/discussions/258. 
-- Required for many other future features like caching, first class offline support, and more. 
-- Stablize the inlang project format.
-`

package/src/parseConfig.ts

@@ -1,35 +0,0 @@
-import { ProjectSettings } from "./versionedInterfaces.js"
-import type { Result } from "@inlang/result"
-import { TypeCompiler } from "@sinclair/typebox/compiler"
-
-export class ParseConfigError extends Error {
-	readonly #id = "ParseConfigException"
-
-	constructor(message: string, cause?: string) {
-		super(message)
-		this.name = this.#id
-		this.cause = cause
-	}
-}
-
-// @ts-ignore - fix after refactor
-const ConfigCompiler = TypeCompiler.Compile(ProjectSettings)
-
-export const parseSettings = (
-	config: ProjectSettings
-): Result<ProjectSettings, ParseConfigError> => {
-	if (ConfigCompiler.Check(config)) {
-		return {
-			data: config,
-			error: undefined as never,
-		}
-	} else {
-		return {
-			error: new ParseConfigError(
-				"The inlang config is not valid.",
-				[...ConfigCompiler.Errors(config)].toString()
-			),
-			data: undefined as never,
-		}
-	}
-}

package/src/persistence/batchedIO.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect, vi } from "vitest"
-import { sleep } from "../test-utilities/sleep.js"
-import { batchedIO } from "./batchedIO.js"
-
-let locked = false
-
-const instrumentAquireLockStart = vi.fn()
-
-async function mockAquireLock() {
-	instrumentAquireLockStart()
-	let pollCount = 0
-	while (locked && pollCount++ < 100) {
-		await sleep(10)
-	}
-	if (locked) {
-		throw new Error("Timeout acquiring lock")
-	}
-	await sleep(10)
-	locked = true
-	return 69
-}
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-async function mockReleaseLock(_: number) {
-	sleep(10)
-	locked = false
-}
-
-const instrumentSaveStart = vi.fn()
-const instrumentSaveEnd = vi.fn()
-
-async function mockSave() {
-	instrumentSaveStart()
-	await sleep(50)
-	instrumentSaveEnd()
-}
-
-describe("batchedIO", () => {
-	it("queues 2 requests while waiting for lock and pushes 2 more to the next batch", async () => {
-		const save = batchedIO(mockAquireLock, mockReleaseLock, mockSave)
-		const p1 = save("1")
-		const p2 = save("2")
-		await sleep(5)
-		expect(instrumentAquireLockStart).toHaveBeenCalledTimes(1)
-		expect(instrumentSaveStart).not.toHaveBeenCalled()
-		await sleep(10)
-		expect(instrumentSaveStart).toHaveBeenCalled()
-		expect(instrumentSaveEnd).not.toHaveBeenCalled()
-		const p3 = save("3")
-		const p4 = save("4")
-		expect(instrumentAquireLockStart).toHaveBeenCalledTimes(2)
-		expect(locked).toBe(true)
-		await sleep(50)
-		expect(instrumentSaveEnd).toHaveBeenCalled()
-		expect(await p1).toBe("1")
-		expect(await p2).toBe("2")
-		expect(instrumentSaveStart).toHaveBeenCalledTimes(1)
-		expect(await p3).toBe("3")
-		expect(await p4).toBe("4")
-		expect(instrumentAquireLockStart).toHaveBeenCalledTimes(2)
-		expect(instrumentSaveStart).toHaveBeenCalledTimes(2)
-	})
-})

package/src/persistence/batchedIO.ts

@@ -1,64 +0,0 @@
-import _debug from "debug"
-const debug = _debug("sdk:batchedIO")
-
-/**
- * State machine to convert async save() into batched async save()
- * states = idle -> acquiring -> saving -> idle
- * idle = nothing queued, ready to acquire lock.
- * aquiring = waiting to acquire a lock: requests go into the queue.
- * saving = lock is acquired, save has begun: new requests go into the next batch.
- * The next batch should not acquire the lock while current save is in progress.
- * Queued requests are only resolved when the save completes.
- */
-export function batchedIO(
-	acquireLock: () => Promise<number>,
-	releaseLock: (lock: number) => Promise<void>,
-	save: () => Promise<void>
-): (id: string) => Promise<string> {
-	// 3-state machine
-	let state: "idle" | "acquiring" | "saving" = "idle"
-
-	// Hold requests while acquiring, resolve after saving
-	// TODO: rejectQueued if save throws (maybe?)
-	// https://github.com/opral/inlang-message-sdk/issues/79
-	type Queued = {
-		id: string
-		resolve: (value: string) => void
-		reject: (reason: any) => void
-	}
-	const queue: Queued[] = []
-
-	// initialize nextBatch lazily, reset after saving
-	let nextBatch: ((id: string) => Promise<string>) | undefined = undefined
-
-	// batched save function
-	return async (id: string) => {
-		if (state === "idle") {
-			state = "acquiring"
-			const lock = await acquireLock()
-			state = "saving"
-			await save()
-			await releaseLock(lock)
-			resolveQueued()
-			nextBatch = undefined
-			state = "idle"
-			return id
-		} else if (state === "acquiring") {
-			return new Promise<string>((resolve, reject) => {
-				queue.push({ id, resolve, reject })
-			})
-		} else {
-			// state === "saving"
-			nextBatch = nextBatch ?? batchedIO(acquireLock, releaseLock, save)
-			return await nextBatch(id)
-		}
-	}
-
-	function resolveQueued() {
-		debug("batched", queue.length + 1)
-		for (const { id, resolve } of queue) {
-			resolve(id)
-		}
-		queue.length = 0
-	}
-}