@inlang/sdk 0.36.4 → 2.0.0-beta.1

package/src/resolve-modules/resolveModules.test.ts

@@ -1,224 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import type { MessageLintRule } from "@inlang/message-lint-rule"
-import type { Plugin } from "@inlang/plugin"
-import { expect, it } from "vitest"
-import {
-	ModuleError,
-	ModuleExportIsInvalidError,
-	ModuleHasNoExportsError,
-	ModuleImportError,
-	ModuleSettingsAreInvalidError,
-} from "./errors.js"
-import { resolveModules } from "./resolveModules.js"
-import type { ProjectSettings } from "@inlang/project-settings"
-import type { InlangModule } from "@inlang/module"
-import { Type } from "@sinclair/typebox"
-
-it("should return an error if a plugin cannot be imported", async () => {
-	const settings: ProjectSettings = {
-		sourceLanguageTag: "en",
-		languageTags: ["de", "en"],
-		modules: ["https://myplugin.com/index.js"],
-	}
-
-	const resolved = await resolveModules({
-		projectPath: "/project.inlang",
-		settings,
-		nodeishFs: {} as any,
-		_import: () => {
-			throw new ModuleImportError({
-				module: settings.modules[0]!,
-				cause: new Error("Could not import"),
-			})
-		},
-	})
-
-	expect(resolved.errors[0]).toBeInstanceOf(ModuleImportError)
-})
-
-it("should resolve plugins and message lint rules successfully", async () => {
-	// Define mock data
-	const mockPlugin: Plugin = {
-		id: "plugin.namespace.mock",
-		description: { en: "Mock plugin description" },
-		displayName: { en: "Mock Plugin" },
-
-		loadMessages: () => undefined as any,
-		saveMessages: () => undefined as any,
-		addCustomApi: () => ({
-			"app.inlang.ideExtension": {
-				messageReferenceMatcher: () => undefined as any,
-			},
-		}),
-	}
-
-	const mockMessageLintRule: MessageLintRule = {
-		id: "messageLintRule.namespace.mock",
-		description: { en: "Mock lint rule description" },
-		displayName: { en: "Mock Lint Rule" },
-
-		run: () => undefined,
-	}
-
-	const settings: ProjectSettings = {
-		sourceLanguageTag: "en",
-		languageTags: ["de", "en"],
-		modules: ["lint-rule.js", "plugin.js"],
-	}
-
-	const _import = async (name: string) => {
-		if (name === "lint-rule.js") {
-			return {
-				default: mockMessageLintRule,
-			}
-		} else {
-			return {
-				default: mockPlugin,
-			}
-		}
-	}
-
-	// Call the function
-	const resolved = await resolveModules({
-		projectPath: "/project.inlang",
-		settings,
-		_import,
-		nodeishFs: {} as any,
-	})
-
-	// Assert results
-	expect(resolved.errors).toHaveLength(0)
-	// Check for the meta data of the plugin
-	expect(resolved.plugins.some((module) => module.id === mockPlugin.id)).toBeDefined()
-	// Check for the app specific api
-	expect(resolved.resolvedPluginApi["customApi"]?.["app.inlang.ideExtension"]).toBeDefined()
-	// Check for the lint rule
-	expect(resolved.messageLintRules[0]?.id).toBe(mockMessageLintRule.id)
-})
-
-it("should return an error if a module cannot be imported", async () => {
-	const settings: ProjectSettings = {
-		sourceLanguageTag: "en",
-		languageTags: ["de", "en"],
-		modules: ["https://myplugin.com/index.js"],
-	}
-
-	const _import = async () => {
-		throw new ModuleImportError({
-			module: settings.modules[0]!,
-			cause: new Error(),
-		})
-	}
-
-	// Call the function
-	const resolved = await resolveModules({
-		projectPath: "/project.inlang",
-		settings,
-		_import,
-		nodeishFs: {} as any,
-	})
-
-	// Assert results
-	expect(resolved.errors[0]).toBeInstanceOf(ModuleImportError)
-})
-
-it("should return an error if a module does not export anything", async () => {
-	const settings: ProjectSettings = {
-		sourceLanguageTag: "en",
-		languageTags: ["de", "en"],
-		modules: ["https://myplugin.com/index.js"],
-	}
-
-	const _import = async () => ({})
-
-	// Call the function
-	const resolved = await resolveModules({
-		projectPath: "/project.inlang",
-		settings,
-		_import,
-		nodeishFs: {} as any,
-	})
-
-	// Assert results
-	expect(resolved.errors[0]).toBeInstanceOf(ModuleHasNoExportsError)
-})
-
-it("should return an error if a module exports an invalid plugin or lint rule", async () => {
-	const settings: ProjectSettings = {
-		sourceLanguageTag: "en",
-		languageTags: ["de", "en"],
-		modules: ["https://myplugin.com/index.js"],
-	}
-	const _import = async () =>
-		({
-			// @ts-expect-error - invalid meta of a plugin
-			default: {
-				id: "plugin.namespace.mock",
-				description: { en: "Mock plugin description" },
-			},
-		} satisfies InlangModule)
-
-	const resolved = await resolveModules({
-		projectPath: "/project.inlang",
-		settings,
-		_import,
-		nodeishFs: {} as any,
-	})
-	expect(resolved.errors[0]).toBeInstanceOf(ModuleExportIsInvalidError)
-})
-
-it("should handle other unhandled errors during plugin resolution", async () => {
-	const errorMessage = "Unhandled error during plugin resolution"
-	const settings: ProjectSettings = {
-		sourceLanguageTag: "en",
-		languageTags: ["de", "en"],
-		modules: ["https://myplugin.com/index.js"],
-	}
-
-	const _import = async () => {
-		throw new Error(errorMessage)
-	}
-
-	// Call the function
-	const resolved = await resolveModules({
-		projectPath: "/project.inlang",
-		settings,
-		_import,
-		nodeishFs: {} as any,
-	})
-
-	// Assert results
-	expect(resolved.errors[0]).toBeInstanceOf(ModuleError)
-})
-it("should return an error if a moduleSettings are invalid", async () => {
-	const settings: ProjectSettings = {
-		sourceLanguageTag: "en",
-		languageTags: ["de", "en"],
-		modules: ["plugin.js"],
-		"plugin.namespace.mock": {
-			ignore: ["invalid"],
-		},
-	}
-
-	const _import = async () => ({
-		default: {
-			id: "plugin.namespace.mock",
-			description: { en: "Mock plugin description" },
-			displayName: { en: "Mock Plugin" },
-			settingsSchema: Type.Object({
-				ignore: Type.String(),
-			}),
-		},
-	})
-
-	// Call the function
-	const resolved = await resolveModules({
-		projectPath: "/project.inlang",
-		settings,
-		_import,
-		nodeishFs: {} as any,
-	})
-
-	// Assert results
-	expect(resolved.errors[0]).toBeInstanceOf(ModuleSettingsAreInvalidError)
-})

package/src/resolve-modules/resolveModules.ts

@@ -1,113 +0,0 @@
-import type { ResolveModuleFunction } from "./types.js"
-import { InlangModule } from "@inlang/module"
-import {
-	ModuleError,
-	ModuleImportError,
-	ModuleHasNoExportsError,
-	ModuleExportIsInvalidError,
-	ModuleSettingsAreInvalidError,
-} from "./errors.js"
-import { tryCatch } from "@inlang/result"
-import { resolveMessageLintRules } from "./message-lint-rules/resolveMessageLintRules.js"
-import { createImport } from "./import.js"
-import { resolvePlugins } from "./plugins/resolvePlugins.js"
-import { TypeCompiler } from "@sinclair/typebox/compiler"
-import { validatedModuleSettings } from "./validatedModuleSettings.js"
-import type { Plugin } from "@inlang/plugin"
-import type { MessageLintRule } from "@inlang/message-lint-rule"
-
-const ModuleCompiler = TypeCompiler.Compile(InlangModule)
-
-export const resolveModules: ResolveModuleFunction = async (args) => {
-	const _import = args._import ?? createImport(args.projectPath, args.nodeishFs)
-
-	const allPlugins: Array<Plugin> = []
-	const allMessageLintRules: Array<MessageLintRule> = []
-	const meta: Awaited<ReturnType<ResolveModuleFunction>>["meta"] = []
-	const moduleErrors: Array<ModuleError> = []
-
-	async function resolveModule(module: string) {
-		const importedModule = await tryCatch<InlangModule>(() => _import(module))
-
-		// -- FAILED TO IMPORT --
-		if (importedModule.error) {
-			moduleErrors.push(
-				new ModuleImportError({
-					module: module,
-					cause: importedModule.error as Error,
-				})
-			)
-			return
-		}
-
-		// -- MODULE DOES NOT EXPORT ANYTHING --
-		if (importedModule.data?.default === undefined) {
-			moduleErrors.push(
-				new ModuleHasNoExportsError({
-					module: module,
-				})
-			)
-			return
-		}
-
-		// -- CHECK IF MODULE IS SYNTACTIALLY VALID
-		const isValidModule = ModuleCompiler.Check(importedModule.data)
-		if (isValidModule === false) {
-			const errors = [...ModuleCompiler.Errors(importedModule.data)]
-			moduleErrors.push(
-				new ModuleExportIsInvalidError({
-					module: module,
-					errors,
-				})
-			)
-
-			return
-		}
-
-		// -- VALIDATE MODULE SETTINGS
-
-		const result = validatedModuleSettings({
-			settingsSchema: importedModule.data.default.settingsSchema,
-			moduleSettings: args.settings[importedModule.data.default.id],
-		})
-		if (result !== "isValid") {
-			moduleErrors.push(new ModuleSettingsAreInvalidError({ module: module, errors: result }))
-			return
-		}
-
-		meta.push({
-			module: module,
-			id: importedModule.data.default.id,
-		})
-
-		if (importedModule.data.default.id.startsWith("plugin.")) {
-			allPlugins.push(importedModule.data.default as Plugin)
-		} else if (importedModule.data.default.id.startsWith("messageLintRule.")) {
-			allMessageLintRules.push(importedModule.data.default as MessageLintRule)
-		} else {
-			moduleErrors.push(
-				new ModuleError(
-					`Unimplemented module type ${importedModule.data.default.id}.The module has not been installed.`,
-					{ module: module }
-				)
-			)
-		}
-	}
-
-	await Promise.all(args.settings.modules.map(resolveModule))
-	const resolvedPlugins = await resolvePlugins({
-		plugins: allPlugins,
-		settings: args.settings,
-		nodeishFs: args.nodeishFs,
-	})
-
-	const resolvedLintRules = resolveMessageLintRules({ messageLintRules: allMessageLintRules })
-
-	return {
-		meta,
-		messageLintRules: allMessageLintRules,
-		plugins: allPlugins,
-		resolvedPluginApi: resolvedPlugins.data,
-		errors: [...moduleErrors, ...resolvedLintRules.errors, ...resolvedPlugins.errors],
-	}
-}

package/src/resolve-modules/types.ts

@@ -1,72 +0,0 @@
-import type { ProjectSettings } from "@inlang/project-settings"
-import type { MessageLintRule } from "@inlang/message-lint-rule"
-import type { Plugin } from "@inlang/plugin"
-import type {
-	NodeishFilesystemSubset,
-	ResolvePluginsFunction,
-	ResolvedPluginApi,
-} from "./plugins/types.js"
-import type { ModuleHasNoExportsError, ModuleImportError } from "./errors.js"
-import type { ImportFunction } from "./import.js"
-import type { resolveMessageLintRules } from "./message-lint-rules/resolveMessageLintRules.js"
-
-/**
- * Function that resolves modules from the config.
- *
- * Pass a custom `_import` function to override the default import function.
- */
-export type ResolveModuleFunction = (args: {
-	projectPath: string
-	settings: ProjectSettings
-	nodeishFs: NodeishFilesystemSubset
-	_import?: ImportFunction
-}) => Promise<{
-	/**
-	 * Metadata about the resolved module.
-	 *
-	 * @example
-	 * [{
-	 * 	  id: "plugin.inlang.json",
-	 * 	  module: "https://myplugin.com/index.js"
-	 * }]
-	 */
-	meta: Array<{
-		/**
-		 * The module link.
-		 *
-		 * @example "https://myplugin.com/index.js"
-		 */
-		module: string
-		/**
-		 * The resolved item id of the module.
-		 */
-		id: Plugin["id"] | MessageLintRule["id"]
-	}>
-	/**
-	 * The resolved plugins.
-	 */
-	plugins: Array<Plugin>
-	/**
-	 * The resolved message lint rules.
-	 */
-	messageLintRules: Array<MessageLintRule>
-	/**
-	 * The resolved api provided by plugins.
-	 */
-	resolvedPluginApi: ResolvedPluginApi
-	/**
-	 * Errors during the resolution process.
-	 *
-	 * This includes errors from:
-	 * - importing module
-	 * - resolving plugins
-	 * - resolving lint rules
-	 * - resolving the runtime plugin api
-	 */
-	errors: Array<
-		| ModuleHasNoExportsError
-		| ModuleImportError
-		| Awaited<ReturnType<ResolvePluginsFunction>>["errors"][number]
-		| Awaited<ReturnType<typeof resolveMessageLintRules>>["errors"][number]
-	>
-}>

package/src/resolve-modules/validateModuleSettings.test.ts

@@ -1,85 +0,0 @@
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-import { expect, test } from "vitest"
-import { Plugin, MessageLintRule } from "../index.js"
-// import { createNodeishMemoryFs } from "@lix-js/fs"
-import { Type } from "@sinclair/typebox"
-import { validatedModuleSettings } from "./validatedModuleSettings.js"
-
-const mockPluginSchema: Plugin["settingsSchema"] = Type.Object({
-	pathPattern: Type.Union([
-		Type.String({
-			pattern: "^(\\./|\\../|/)[^*]*\\{languageTag\\}[^*]*\\.json",
-			description: "The pathPattern must contain `{languageTag}` and end with `.json`.",
-		}),
-		Type.Record(
-			Type.String({
-				pattern: "^[^.]+$",
-				description: "Dots are not allowd ",
-				examples: ["website", "app", "homepage"],
-			}),
-			Type.String({
-				pattern: "^(\\./|\\../|/)[^*]*\\{languageTag\\}[^*]*\\.json",
-				description: "The pathPattern must contain `{languageTag}` and end with `.json`.",
-			})
-		),
-	]),
-	variableReferencePattern: Type.Array(Type.String()),
-})
-
-const mockMessageLintRuleSchema: MessageLintRule["settingsSchema"] = Type.Object({
-	ignore: Type.Array(
-		Type.String({
-			pattern: '([^"]*)',
-			description: "All items in the array need quotaion marks at the end and beginning",
-		})
-	),
-})
-
-test("if PluginSchema does match with the moduleSettings", async () => {
-	const isValid = await validatedModuleSettings({
-		settingsSchema: mockPluginSchema,
-		moduleSettings: {
-			pathPattern: "./examples/example01/{languageTag}.json",
-			variableReferencePattern: ["{", "}"],
-		},
-	})
-
-	expect(isValid).toBe("isValid")
-})
-
-test("if namespace settings are valide", async () => {
-	const isValid = validatedModuleSettings({
-		settingsSchema: mockPluginSchema,
-		moduleSettings: {
-			pathPattern: {
-				website: "./{languageTag}examplerFolder/ExampleFile.json",
-				app: "../{languageTag}examplerFolder/ExampleFile.json",
-				footer: "./{languageTag}examplerFolder/ExampleFile.json",
-			},
-			variableReferencePattern: ["{", "}"],
-		},
-	})
-	expect(isValid).toBe("isValid")
-})
-
-test(" if MessageLintRuleSchema  match with the settings", async () => {
-	const isValid = await validatedModuleSettings({
-		settingsSchema: mockMessageLintRuleSchema,
-		moduleSettings: {
-			ignore: ["example", "warning"],
-		},
-	})
-
-	expect(isValid).toBe("isValid")
-})
-
-test("if  messageLintRule settings are not matching to the settingsSchema would pass ", async () => {
-	const isValid = validatedModuleSettings({
-		settingsSchema: mockMessageLintRuleSchema,
-		moduleSettings: {
-			ignore: "example",
-		},
-	})
-
-	expect(isValid).not.toBe("isValid")
-})

package/src/resolve-modules/validatedModuleSettings.ts

@@ -1,19 +0,0 @@
-import type { InlangModule } from "@inlang/module"
-import type { TSchema } from "@sinclair/typebox"
-import { Value, type ValueError } from "@sinclair/typebox/value"
-
-export const validatedModuleSettings = (args: {
-	settingsSchema: InlangModule["default"]["settingsSchema"]
-	moduleSettings: unknown
-}): "isValid" | ValueError[] => {
-	if (args.settingsSchema && args.moduleSettings) {
-		const hasValidSettings = Value.Check(args.settingsSchema as TSchema, args.moduleSettings)
-
-		if (hasValidSettings === false) {
-			const errors = [...Value.Errors(args.settingsSchema as TSchema, args.moduleSettings)]
-
-			return errors
-		}
-	}
-	return "isValid"
-}

package/src/storage/helper.ts

@@ -1,74 +0,0 @@
-import { Message, Variant } from "../versionedInterfaces.js"
-
-const fileExtension = ".json"
-
-export function getMessageIdFromPath(path: string) {
-	if (!path.endsWith(fileExtension)) {
-		return
-	}
-
-	const cleanedPath = path.replace(/\/$/, "") // This regex matches a trailing slash and replaces it with an empty string
-	const messageFileName = cleanedPath.split("/").join("_") // we split by the first leading namespace or _ separator - make sure slashes don't exit in the id
-	// const messageFileName = pathParts.at(-1)!
-
-	const lastDotIndex = messageFileName.lastIndexOf(".")
-
-	// Extract until the last dot (excluding the dot)
-	return messageFileName.slice(0, Math.max(0, lastDotIndex))
-}
-
-export function getPathFromMessageId(id: string) {
-	const path = id.replace("_", "/") + fileExtension
-	return path
-}
-
-/**
- * Returns a copy of a message object with sorted variants and object keys.
- * This produces a deterministic result when passed to stringify
- * independent of the initialization order.
- */
-export function normalizeMessage(message: Message) {
-	// order keys in message
-	const messageWithSortedKeys: any = {}
-	for (const key of Object.keys(message).sort()) {
-		messageWithSortedKeys[key] = (message as any)[key]
-	}
-
-	// order variants
-	messageWithSortedKeys["variants"] = messageWithSortedKeys["variants"]
-		.sort((variantA: Variant, variantB: Variant) => {
-			// compare by language
-			const languageComparison = variantA.languageTag.localeCompare(variantB.languageTag)
-
-			// if languages are the same, compare by match
-			if (languageComparison === 0) {
-				return variantA.match.join("-").localeCompare(variantB.match.join("-"))
-			}
-
-			return languageComparison
-		})
-		// order keys in each variant
-		.map((variant: Variant) => {
-			const variantWithSortedKeys: any = {}
-			for (const variantKey of Object.keys(variant).sort()) {
-				if (variantKey === "pattern") {
-					variantWithSortedKeys[variantKey] = (variant as any)["pattern"].map((token: any) => {
-						const tokenWithSortedKey: any = {}
-						for (const tokenKey of Object.keys(token).sort()) {
-							tokenWithSortedKey[tokenKey] = token[tokenKey]
-						}
-						return tokenWithSortedKey
-					})
-				} else {
-					variantWithSortedKeys[variantKey] = (variant as any)[variantKey]
-				}
-			}
-			return variantWithSortedKeys
-		})
-
-	return messageWithSortedKeys as Message
-}
-
-export function stringifyMessage(message: Message) {
-	return JSON.stringify(normalizeMessage(message), undefined, 4)
-}

package/src/storage/helpers.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect } from "vitest"
-// import { parseLixUri, parseOrigin } from "./helpers.js"
-import { normalizeMessage, stringifyMessage } from "./helper.js"
-import type { Message } from "@inlang/message"
-
-const unsortedMessageRaw: Message = {
-	alias: {},
-	selectors: [],
-	id: "footer_categories_apps",
-	variants: [
-		{ languageTag: "a", match: ["*", "1"], pattern: [{ type: "Text", value: "2" }] },
-		{ languageTag: "a", match: ["*", "*"], pattern: [{ type: "Text", value: "1" }] },
-		{
-			languageTag: "a",
-			match: ["1", "*"],
-			pattern: [
-				{ type: "Text", value: "2" },
-				{ type: "Text", value: "2" },
-			],
-		},
-		{ languageTag: "b", match: [], pattern: [{ type: "Text", value: "4" }] },
-		{ languageTag: "a", match: ["1", "1"], pattern: [{ type: "Text", value: "2" }] },
-		{ languageTag: "c", match: [], pattern: [{ value: "5", type: "Text" }] },
-		{ match: [], languageTag: "d", pattern: [{ type: "Text", value: "6" }] },
-		{ languageTag: "e", match: [], pattern: [{ type: "Text", value: "7" }] },
-		{ languageTag: "f", match: [], pattern: [{ type: "Text", value: "8" }] },
-		{ languageTag: "g", match: [], pattern: [{ type: "Text", value: "9" }] },
-	],
-}
-
-const sortedMessageRaw: Message = {
-	alias: {},
-	id: "footer_categories_apps",
-	selectors: [],
-	variants: [
-		{ languageTag: "a", match: ["*", "*"], pattern: [{ type: "Text", value: "1" }] },
-		{ languageTag: "a", match: ["*", "1"], pattern: [{ type: "Text", value: "2" }] },
-		{
-			languageTag: "a",
-			match: ["1", "*"],
-			pattern: [
-				{ type: "Text", value: "2" },
-				{ type: "Text", value: "2" },
-			],
-		},
-		{ languageTag: "a", match: ["1", "1"], pattern: [{ type: "Text", value: "2" }] },
-		{ languageTag: "b", match: [], pattern: [{ type: "Text", value: "4" }] },
-		{ languageTag: "c", match: [], pattern: [{ type: "Text", value: "5" }] },
-		{ languageTag: "d", match: [], pattern: [{ type: "Text", value: "6" }] },
-		{ languageTag: "e", match: [], pattern: [{ type: "Text", value: "7" }] },
-		{ languageTag: "f", match: [], pattern: [{ type: "Text", value: "8" }] },
-		{ languageTag: "g", match: [], pattern: [{ type: "Text", value: "9" }] },
-	],
-}
-
-// stringify with no indentation
-function str(obj: any) {
-	return JSON.stringify(obj)
-}
-
-// stringify with 2 space indentation
-function str2(obj: any) {
-	return JSON.stringify(obj, undefined, 2)
-}
-
-// stringify with 4 space indentation
-function str4(obj: any) {
-	return JSON.stringify(obj, undefined, 4)
-}
-
-describe("normalizeMessage", () => {
-	it("should return the message with sorted keys and variants", () => {
-		// test cases are not the same (deep equal) before normalization
-		// array order of variants is different
-		expect(unsortedMessageRaw).not.toEqual(sortedMessageRaw)
-
-		// test cases are the same after normalization
-		expect(normalizeMessage(unsortedMessageRaw)).toEqual(sortedMessageRaw)
-
-		// stringify results are not the same before normalization
-		expect(str(unsortedMessageRaw)).not.toBe(str(sortedMessageRaw))
-
-		// stringify results are the same after normalization
-		expect(str(normalizeMessage(unsortedMessageRaw))).toBe(str(sortedMessageRaw))
-		expect(str2(normalizeMessage(unsortedMessageRaw))).toBe(str2(sortedMessageRaw))
-		expect(str4(normalizeMessage(unsortedMessageRaw))).toBe(str4(sortedMessageRaw))
-	})
-})
-
-describe("stringifyMessage", () => {
-	it("should normalize and JSON stringify a message with 4 space indentation", () => {
-		expect(stringifyMessage(unsortedMessageRaw)).toBe(str4(sortedMessageRaw))
-		expect(stringifyMessage(sortedMessageRaw)).toBe(str4(sortedMessageRaw))
-	})
-})