@inlang/sdk 0.7.0 → 0.9.0

package/src/messages/variant.ts

@@ -14,18 +14,18 @@ import {
  * (if it exists).
  *
  * @example
- * 	const variant = getVariant(message, { where: { languageTag: "en", selectors: { gender: "male" }}});
+ * 	const variant = getVariant(message, { where: { languageTag: "en", match: ["male"]}});
  */
 export function getVariant(
 	message: Message,
 	args: {
 		where: {
 			languageTag: LanguageTag
-			selectors?: Variant["match"]
+			match?: Variant["match"]
 		}
-	},
+	}
 ): Variant | undefined {
-	const variant = matchMostSpecificVariant(message, args.where.languageTag, args.where.selectors)
+	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
@@ -47,7 +47,7 @@ export function createVariant(
 	message: Message,
 	args: {
 		data: Variant
-	},
+	}
 ): Result<Message, MessageVariantAlreadyExistsError> {
 	const copy = structuredClone(message)
 
@@ -56,10 +56,9 @@ export function createVariant(
 		return { error: new MessageVariantAlreadyExistsError(message.id, args.data.languageTag) }
 	}
 
-	// need to resolve selectors to match length and order of message selectors
 	copy.variants.push({
 		...args.data,
-		match: resolveSelector(copy.selectors, args.data.match),
+		match: args.data.match,
 	})
 	return { data: copy }
 }
@@ -70,22 +69,22 @@ export function createVariant(
  * All actions are immutable.
  *
  * @example
- *  const message = updateVariant(message, { languageTag: "en", selectors: { gender: "male" }, pattern: []})
+ *  const message = updateVariant(message, { languageTag: "en", match: ["male"], pattern: []})
  */
 export function updateVariantPattern(
 	message: Message,
 	args: {
 		where: {
 			languageTag: LanguageTag
-			selectors: Record<string, string>
+			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,
+		(variant) => variant.languageTag === args.where.languageTag
 	)
 	if (!containsLanguageTag) {
 		return {
@@ -93,7 +92,7 @@ export function updateVariantPattern(
 		}
 	}
 
-	const variant = matchVariant(copy, args.where.languageTag, args.where.selectors)
+	const variant = matchVariant(copy, args.where.languageTag, args.where.match)
 	if (variant === undefined) {
 		return { error: new MessageVariantDoesNotExistError(message.id, args.where.languageTag) }
 	}
@@ -108,27 +107,31 @@ export function updateVariantPattern(
  * Returns the specific variant defined by selectors or undefined
  *
  * @example
- *  const variant = matchVariant(message, languageTag: "en", selectors: { gender: "male" })
+ *  const variant = matchVariant(message, languageTag: "en", match: ["male"])
  */
 const matchVariant = (
 	message: Message,
 	languageTag: LanguageTag,
-	selectors: Record<string, string>,
+	match: Variant["match"]
 ): Variant | undefined => {
-	// resolve preferenceSelectors to match length and order of message selectors
-	const resolvedSelectors = resolveSelector(message.selectors, selectors)
-
 	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
-		for (const [key, value] of Object.entries(variant.match)) {
-			if (resolvedSelectors[key] !== value) {
-				isMatch = false
-			}
+		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
 		}
@@ -145,13 +148,9 @@ const matchVariant = (
 const matchMostSpecificVariant = (
 	message: Message,
 	languageTag: LanguageTag,
-	selectors?: Record<string, string>,
+	match?: Variant["match"]
 ): Variant | undefined => {
-	// make selector undefined if empty object
-	selectors = JSON.stringify(selectors) === "{}" ? undefined : selectors
-
 	// resolve preferenceSelectors to match length and order of message selectors
-	const resolvedSelectors = resolveSelector(message.selectors, selectors)
 	const index: Record<string, any> = {}
 
 	for (const variant of message.variants) {
@@ -159,44 +158,70 @@ const matchMostSpecificVariant = (
 
 		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
-		for (const [key, value] of Object.entries(variant.match)) {
-			if (resolvedSelectors[key] !== value && value !== "*") {
-				isMatch = false
-			}
+		if (variant.match.length > 0) {
+			variant.match.map((value, index) => {
+				if (match && match[index] !== value && value !== "*") {
+					isMatch = false
+				}
+			})
 		}
-		if (isMatch && selectors) {
-			// add variant to nested index
+		if (isMatch && match && match.length > 0) {
 			// eslint-disable-next-line no-inner-declarations
 			function recursiveAddToIndex(
 				currentIndex: Record<string, any>,
-				currentKeys: Message["selectors"],
-				variant: Variant,
+				selectorIndex: number,
+				selectorLength: number,
+				variant: Variant
 			) {
-				if (currentKeys[0]?.name) {
-					const key = variant.match[currentKeys[0].name]
-					if (key) {
-						if (currentKeys.length === 1) {
-							currentIndex[key] = variant
-						} else {
-							if (!currentIndex[key]) {
-								currentIndex[key] = {}
-							}
-							recursiveAddToIndex(currentIndex[key], currentKeys.slice(1), 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, message.selectors, variant)
-		} else if (isMatch && !selectors) {
+			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[],
+		selectors: string[]
 	): Variant | undefined => {
 		const keys = Object.keys(index)
 
@@ -218,24 +243,5 @@ const matchMostSpecificVariant = (
 		return undefined
 	}
 
-	return findOptimalMatch(index, Object.values(resolvedSelectors))
-}
-
-/**
- * Returns resolved selector.
- * -> Adds all possible selectors, if not defined it adds '*'. Order is determined by messageSelectors
- *
- * @example
- *  const variant = resolveSelector(["gender","count"], selector: {count: "2"})
- */
-const resolveSelector = (
-	messageSelectors: Message["selectors"],
-	selectors?: Record<string, string>,
-): Record<string, string> => {
-	const resolvedSelectors: Record<string, string> = {}
-	if (!selectors) return {}
-	for (const messageSelector of messageSelectors) {
-		resolvedSelectors[messageSelector.name] = selectors[messageSelector.name] ?? "*"
-	}
-	return resolvedSelectors
+	return findOptimalMatch(index, match || [])
 }

package/src/parseConfig.ts

@@ -16,7 +16,7 @@ export class ParseConfigError extends Error {
 const ConfigCompiler = TypeCompiler.Compile(ProjectSettings)
 
 export const parseSettings = (
-	config: ProjectSettings,
+	config: ProjectSettings
 ): Result<ProjectSettings, ParseConfigError> => {
 	if (ConfigCompiler.Check(config)) {
 		return {
@@ -27,7 +27,7 @@ export const parseSettings = (
 		return {
 			error: new ParseConfigError(
 				"The inlang config is not valid.",
-				[...ConfigCompiler.Errors(config)].toString(),
+				[...ConfigCompiler.Errors(config)].toString()
 			),
 			data: undefined as never,
 		}

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

@@ -12,7 +12,7 @@ describe("$import", async () => {
 		export function hello() {
 			return "hello";
 		}
-		`,
+		`
 	)
 
 	// mock module in a directory
@@ -23,7 +23,7 @@ describe("$import", async () => {
 		export function hello() {
 			return "world";
 		}
-		`,
+		`
 	)
 
 	const _import = createImport({

package/src/resolve-modules/import.ts

@@ -35,7 +35,7 @@ async function $import(
 		 * Required to import from a local path.
 		 */
 		readFile: NodeishFilesystemSubset["readFile"]
-	},
+	}
 ): Promise<any> {
 	let moduleAsText: string
 

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

@@ -12,7 +12,7 @@ export const resolveMessageLintRules = (args: { messageLintRules: Array<MessageL
 			result.errors.push(
 				new MessageLintRuleIsInvalidError(`Couldn't parse lint rule "${rule.id}"`, {
 					module: "not implemented",
-				}),
+				})
 			)
 			continue
 		} else {

package/src/resolve-modules/plugins/resolvePlugins.test.ts

@@ -11,65 +11,98 @@ import {
 	PluginsDoNotProvideLoadOrSaveMessagesError,
 } from "./errors.js"
 import type { Plugin } from "@inlang/plugin"
+import type { ProjectSettings } from "@inlang/project-settings"
+
+it("should return an error if a plugin uses an invalid id", async () => {
+	const mockPlugin: Plugin = {
+		// @ts-expect-error - invalid id
+		id: "no-namespace",
+		description: { en: "My plugin description" },
+		displayName: { en: "My plugin" },
+		loadMessages: () => undefined as any,
+		saveMessages: () => undefined as any,
+	}
+
+	const resolved = await resolvePlugins({
+		plugins: [mockPlugin],
+		settings: {} as any as any,
+		nodeishFs: {} as any,
+	})
 
-describe("generally", () => {
-	it("should return an error if a plugin uses an invalid id", async () => {
-		const mockPlugin: Plugin = {
-			// @ts-expect-error - invalid id
-			id: "no-namespace",
-			description: { en: "My plugin description" },
-			displayName: { en: "My plugin" },
-			loadMessages: () => undefined as any,
-			saveMessages: () => undefined as any,
-		}
-
-		const resolved = await resolvePlugins({
-			plugins: [mockPlugin],
-			settings: {},
-			nodeishFs: {} as any,
-		})
+	expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidIdError)
+})
 
-		expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidIdError)
+it("should return an error if a plugin uses APIs that are not available", async () => {
+	const mockPlugin: Plugin = {
+		id: "plugin.namespace.undefinedApi",
+		description: { en: "My plugin description" },
+		displayName: { en: "My plugin" },
+		// @ts-expect-error the key is not available in type
+		nonExistentKey: {
+			nonexistentOptions: "value",
+		},
+		loadMessages: () => undefined as any,
+		saveMessages: () => undefined as any,
+	}
+
+	const resolved = await resolvePlugins({
+		plugins: [mockPlugin],
+		settings: {} as any,
+		nodeishFs: {} as any,
 	})
 
-	it("should return an error if a plugin uses APIs that are not available", async () => {
-		const mockPlugin: Plugin = {
-			id: "plugin.namespace.undefinedApi",
-			description: { en: "My plugin description" },
-			displayName: { en: "My plugin" },
-			// @ts-expect-error the key is not available in type
-			nonExistentKey: {
-				nonexistentOptions: "value",
-			},
-			loadMessages: () => undefined as any,
-			saveMessages: () => undefined as any,
-		}
-
-		const resolved = await resolvePlugins({
-			plugins: [mockPlugin],
-			settings: {},
-			nodeishFs: {} as any,
-		})
+	expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidSchemaError)
+})
 
-		expect(resolved.errors[0]).toBeInstanceOf(PluginHasInvalidSchemaError)
+it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
+	const mockPlugin: Plugin = {
+		id: "plugin.inlang.notWhitelisted",
+		description: { en: "My plugin description" },
+		displayName: { en: "My plugin" },
+		loadMessages: () => undefined as any,
+	}
+
+	const resolved = await resolvePlugins({
+		plugins: [mockPlugin],
+		settings: {} as any,
+		nodeishFs: {} as any,
 	})
 
-	it("should not initialize a plugin that uses the 'inlang' namespace except for inlang whitelisted plugins", async () => {
-		const mockPlugin: Plugin = {
-			id: "plugin.inlang.notWhitelisted",
-			description: { en: "My plugin description" },
-			displayName: { en: "My plugin" },
-			loadMessages: () => undefined as any,
-		}
-
-		const resolved = await resolvePlugins({
-			plugins: [mockPlugin],
-			settings: {},
-			nodeishFs: {} as any,
-		})
+	expect(resolved.errors[0]).toBeInstanceOf(PluginUsesReservedNamespaceError)
+})
 
-		expect(resolved.errors[0]).toBeInstanceOf(PluginUsesReservedNamespaceError)
+it("should expose the project settings including the plugin settings", async () => {
+	const settings: ProjectSettings = {
+		sourceLanguageTag: "en",
+		languageTags: ["en", "de"],
+		modules: [],
+		"plugin.namespace.placeholder": {
+			myPluginSetting: "value",
+		},
+	}
+	const mockPlugin: Plugin = {
+		id: "plugin.namespace.placeholder",
+		description: { en: "My plugin description" },
+		displayName: { en: "My plugin" },
+		saveMessages: async ({ settings }) => {
+			expect(settings).toStrictEqual(settings)
+		},
+		addCustomApi: ({ settings }) => {
+			expect(settings).toStrictEqual(settings)
+			return {}
+		},
+		loadMessages: async ({ settings }) => {
+			expect(settings).toStrictEqual(settings)
+			return []
+		},
+	}
+	const resolved = await resolvePlugins({
+		plugins: [mockPlugin],
+		settings: settings,
+		nodeishFs: {} as any,
 	})
+	await resolved.data.loadMessages!({ settings })
+	await resolved.data.saveMessages!({ settings, messages: [] })
 })
 
 describe("loadMessages", () => {
@@ -83,15 +116,14 @@ describe("loadMessages", () => {
 
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin],
-			settings: {},
+			settings: {} as any,
 			nodeishFs: {} as any,
 		})
 
 		expect(
 			await resolved.data.loadMessages!({
-				languageTags: ["en"],
-				sourceLanguageTag: "en",
-			}),
+				settings: {} as any,
+			})
 		).toEqual([{ id: "test", expressions: [], selectors: [], variants: [] }])
 	})
 
@@ -112,7 +144,7 @@ describe("loadMessages", () => {
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin, mockPlugin2],
 			nodeishFs: {} as any,
-			settings: {},
+			settings: {} as any,
 		})
 
 		expect(resolved.errors[0]).toBeInstanceOf(PluginLoadMessagesFunctionAlreadyDefinedError)
@@ -129,7 +161,7 @@ describe("loadMessages", () => {
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin],
 			nodeishFs: {} as any,
-			settings: {},
+			settings: {} as any,
 		})
 
 		expect(resolved.errors).toHaveLength(1)
@@ -150,7 +182,7 @@ describe("saveMessages", () => {
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin],
 			nodeishFs: {} as any,
-			settings: {},
+			settings: {} as any,
 		})
 
 		expect(resolved.errors).toHaveLength(0)
@@ -173,7 +205,7 @@ describe("saveMessages", () => {
 
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin, mockPlugin2],
-			settings: {},
+			settings: {} as any,
 			nodeishFs: {} as any,
 		})
 
@@ -191,7 +223,7 @@ describe("saveMessages", () => {
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin],
 			nodeishFs: {} as any,
-			settings: {},
+			settings: {} as any,
 		})
 		expect(resolved.errors).toHaveLength(1)
 		expect(resolved.errors[0]).toBeInstanceOf(PluginsDoNotProvideLoadOrSaveMessagesError)
@@ -214,7 +246,7 @@ describe("addCustomApi", () => {
 
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin],
-			settings: {},
+			settings: {} as any,
 			nodeishFs: {} as any,
 		})
 
@@ -249,7 +281,7 @@ describe("addCustomApi", () => {
 
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin, mockPlugin2],
-			settings: {},
+			settings: {} as any,
 			nodeishFs: {} as any,
 		})
 
@@ -269,7 +301,7 @@ describe("addCustomApi", () => {
 
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin],
-			settings: {},
+			settings: {} as any,
 			nodeishFs: {} as any,
 		})
 
@@ -292,13 +324,13 @@ describe("addCustomApi", () => {
 
 		const resolved = await resolvePlugins({
 			plugins: [mockPlugin],
-			settings: {},
+			settings: {} as any,
 			nodeishFs: {} as any,
 		})
 
 		expect(resolved.data.customApi).toHaveProperty("app.inlang.placeholder")
 		expect(
-			(resolved.data.customApi?.["app.inlang.placeholder"] as any).messageReferenceMatcher(),
+			(resolved.data.customApi?.["app.inlang.placeholder"] as any).messageReferenceMatcher()
 		).toEqual({
 			hello: "world",
 		})

package/src/resolve-modules/plugins/resolvePlugins.ts

@@ -44,9 +44,9 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 		if (hasInvalidId) {
 			result.errors.push(
 				new PluginHasInvalidIdError(
-					`Plugin ${plugin.id} has an invalid id "${plugin.id}". It must be kebap-case and contain a namespace like project.my-plugin.`,
-					{ plugin: plugin.id },
-				),
+					`Plugin ${plugin.id} has an invalid id "${plugin.id}". It must be camelCase and contain a namespace like plugin.namespace.myPlugin.`,
+					{ plugin: plugin.id }
+				)
 			)
 		}
 
@@ -57,8 +57,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 					`Plugin ${plugin.id} uses reserved namespace 'inlang'.`,
 					{
 						plugin: plugin.id,
-					},
-				),
+					}
+				)
 			)
 		}
 
@@ -70,8 +70,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 					{
 						plugin: plugin.id,
 						cause: errors,
-					},
-				),
+					}
+				)
 			)
 		}
 
@@ -80,8 +80,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 			result.errors.push(
 				new PluginLoadMessagesFunctionAlreadyDefinedError(
 					`Plugin ${plugin.id} defines the loadMessages function, but it was already defined by another plugin.`,
-					{ plugin: plugin.id },
-				),
+					{ plugin: plugin.id }
+				)
 			)
 		}
 
@@ -89,8 +89,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 			result.errors.push(
 				new PluginSaveMessagesFunctionAlreadyDefinedError(
 					`Plugin ${plugin.id} defines the saveMessages function, but it was already defined by another plugin.`,
-					{ plugin: plugin.id },
-				),
+					{ plugin: plugin.id }
+				)
 			)
 		}
 
@@ -99,8 +99,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 			// TODO: why do we call this function 2 times (here for validation and later for retrieving the actual value)?
 			const { data: customApi, error } = tryCatch(() =>
 				plugin.addCustomApi!({
-					settings: args.settings?.[plugin.id] ?? {},
-				}),
+					settings: args.settings,
+				})
 			)
 			if (error) {
 				// @ts-ignore
@@ -111,8 +111,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 				result.errors.push(
 					new PluginReturnedInvalidCustomApiError(
 						`Plugin ${plugin.id} defines the addCustomApi function, but it does not return an object.`,
-						{ plugin: plugin.id, cause: error },
-					),
+						{ plugin: plugin.id, cause: error }
+					)
 				)
 			}
 		}
@@ -130,7 +130,6 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 			result.data.loadMessages = (_args) =>
 				plugin.loadMessages!({
 					..._args,
-					settings: args.settings?.[plugin.id] ?? {},
 					nodeishFs: args.nodeishFs,
 				})
 		}
@@ -139,7 +138,6 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 			result.data.saveMessages = (_args) =>
 				plugin.saveMessages!({
 					..._args,
-					settings: args.settings?.[plugin.id] ?? {},
 					nodeishFs: args.nodeishFs,
 				})
 		}
@@ -147,8 +145,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 		if (typeof plugin.addCustomApi === "function") {
 			const { data: customApi } = tryCatch(() =>
 				plugin.addCustomApi!({
-					settings: args.settings?.[plugin.id] ?? {},
-				}),
+					settings: args.settings,
+				})
 			)
 			if (customApi) {
 				result.data.customApi = deepmerge(result.data.customApi, customApi)
@@ -164,8 +162,8 @@ export const resolvePlugins: ResolvePluginsFunction = async (args) => {
 		result.errors.push(
 			new PluginsDoNotProvideLoadOrSaveMessagesError(
 				"It seems you did not install any plugin that handles messages. Please add one to make inlang work. See https://inlang.com/documentation/plugins/registry.",
-				{ plugin: undefined },
-			),
+				{ plugin: undefined }
+			)
 		)
 	}