@inlang/sdk 0.36.3 → 2.0.0-beta.1

package/src/import-export/upsertBundleNestedMatchByProperties.ts

@@ -0,0 +1,74 @@
+import type { Kysely } from "kysely";
+import type {
+	InlangDatabaseSchema,
+	NewBundleNested,
+} from "../database/schema.js";
+
+export const upsertBundleNestedMatchByProperties = async (
+	db: Kysely<InlangDatabaseSchema>,
+	bundle: NewBundleNested
+): Promise<void> => {
+	if (bundle.id === undefined) {
+		throw new Error("upsert expets a bundle id for matching");
+	}
+	const bundleToInsert = { ...bundle, messages: undefined };
+
+	await db.transaction().execute(async (trx) => {
+		const insertedBundle = await trx
+			.insertInto("bundle")
+			.values(bundleToInsert)
+			.onConflict((oc) => oc.column("id").doUpdateSet(bundleToInsert))
+			.returning("id")
+			.executeTakeFirstOrThrow();
+
+		const existingMessages = await trx
+			.selectFrom("message")
+			.where("bundleId", "=", insertedBundle.id)
+			.selectAll()
+			.execute();
+
+		for (const message of bundle.messages) {
+			// match by locale
+			const existingMessage = existingMessages.find(
+				(m) => m.locale === message.locale
+			);
+
+			const messageToInsert = {
+				...message,
+				id: existingMessage?.id,
+				bundleId: insertedBundle.id,
+				variants: undefined,
+			};
+			const insertedMessage = await trx
+				.insertInto("message")
+				.values(messageToInsert)
+				.onConflict((oc) => oc.column("id").doUpdateSet(messageToInsert))
+				.returning("id")
+				.executeTakeFirstOrThrow();
+
+			const existingVariants = await trx
+				.selectFrom("variant")
+				.where("messageId", "=", insertedMessage.id)
+				.selectAll()
+				.execute();
+
+			for (const variant of message.variants) {
+				// match by matches
+				const existingVariant = existingVariants.find(
+					(v) => JSON.stringify(v.matches) === JSON.stringify(variant.matches)
+				);
+
+				const variantToInsert = {
+					...variant,
+					id: existingVariant?.id,
+					messageId: insertedMessage.id,
+				};
+				await trx
+					.insertInto("variant")
+					.values(variantToInsert)
+					.onConflict((oc) => oc.column("id").doUpdateSet(variantToInsert))
+					.execute();
+			}
+		}
+	});
+};

package/src/index.ts

@@ -1,40 +1,32 @@
-/**
- *! PUBLIC API FOR THE INLANG SDK.
- *!
- *! EXPORT AS LITTLE AS POSSIBLE TO MINIMIZE THE CHANCE OF BREAKING CHANGES.
- */
+export { newProject } from "./project/newProject.js";
+export { loadProjectInMemory } from "./project/loadProjectInMemory.js";
 
-export type {
-	InlangProject,
-	InstalledMessageLintRule,
-	InstalledPlugin,
-	MessageQueryApi,
-	Subscribable,
-} from "./api.js"
-export { type ImportFunction, createImport } from "./resolve-modules/index.js"
-export { createNewProject } from "./createNewProject.js"
-export { defaultProjectSettings } from "./defaultProjectSettings.js"
-export { loadProject } from "./loadProject.js"
-export { listProjects } from "./listProjects.js"
-export { solidAdapter, type InlangProjectWithSolidAdapter } from "./adapter/solidAdapter.js"
-export { createMessagesQuery } from "./createMessagesQuery.js"
-export {
-	ProjectSettingsFileJSONSyntaxError,
-	ProjectSettingsFileNotFoundError,
-	ProjectSettingsInvalidError,
-	PluginLoadMessagesError,
-	PluginSaveMessagesError,
-} from "./errors.js"
 export {
-	ModuleError,
-	ModuleHasNoExportsError,
-	ModuleImportError,
-	ModuleExportIsInvalidError,
-	ModuleSettingsAreInvalidError,
-} from "./resolve-modules/errors.js"
+	loadProjectFromDirectory,
+	/**
+	 * @deprecated use `loadProjectFromDirectory()` instead (it's a rename)
+	 */
+	loadProjectFromDirectory as loadProjectFromDirectoryInMemory,
+} from "./project/loadProjectFromDirectory.js";
 
-export { randomHumanId } from "./storage/human-id/human-readable-id.js"
-export { normalizeMessage } from "./storage/helper.js"
-export * from "./messages/variant.js"
-export * from "./versionedInterfaces.js"
-export { InlangModule } from "@inlang/module"
+export { saveProjectToDirectory } from "./project/saveProjectToDirectory.js";
+export type { InlangProject } from "./project/api.js";
+export * from "./json-schema/settings.js";
+export * from "./json-schema/pattern.js";
+export * from "./helper.js";
+export * from "./query-utilities/index.js";
+export * from "./plugin/errors.js";
+export { humanId } from "./human-id/human-id.js";
+export type { InlangDatabaseSchema } from "./database/schema.js";
+export type { ImportFile, ExportFile } from "./project/api.js";
+export type {
+	InlangPlugin,
+	BundleImport,
+	MessageImport,
+	VariantImport,
+} from "./plugin/schema.js";
+export type { IdeExtensionConfig } from "./plugin/meta/ideExtension.js";
+export * from "./database/schema.js";
+export * from "@lix-js/sdk";
+export { createMessageV1 } from "./migrations/v2/createMessageV1.js";
+export { v7 as uuidV7 } from "uuid";

package/src/json-schema/old-v1-message/README.md

@@ -0,0 +1 @@
+This is the message data structure that has been used in the v1 version of the SDK.

package/src/json-schema/old-v1-message/fromMessageV1.test.ts

@@ -0,0 +1,87 @@
+import { test, expect } from "vitest";
+import { fromMessageV1 } from "./fromMessageV1.js";
+import { Value } from "@sinclair/typebox/value";
+import { MessageV1 } from "./schemaV1.js";
+import type { BundleNested } from "../../database/schema.js";
+
+const messageV1: MessageV1 = {
+	id: "hello_world",
+	alias: {},
+	variants: [
+		{
+			languageTag: "en",
+			match: [],
+			pattern: [
+				{
+					type: "Text",
+					value: "Hello World!",
+				},
+			],
+		},
+		{
+			languageTag: "de",
+			match: [],
+			pattern: [
+				{
+					type: "Text",
+					value: "Hallo Welt!",
+				},
+			],
+		},
+	],
+	selectors: [],
+};
+
+const bundle: BundleNested = {
+	id: "hello_world",
+	declarations: [],
+	messages: [
+		{
+			bundleId: "hello_world",
+			id: "hello_world" + "_en",
+			locale: "en",
+			selectors: [],
+			variants: [
+				{
+					id: "hello_world" + "_en_1",
+					matches: [],
+					messageId: "hello_world" + "_en",
+					pattern: [
+						{
+							type: "text",
+							value: "Hello World!",
+						},
+					],
+				},
+			],
+		},
+		{
+			bundleId: "hello_world",
+			id: "hello_world" + "_de",
+			locale: "de",
+			selectors: [],
+			variants: [
+				{
+					id: "hello_world" + "_de_1",
+					matches: [],
+					messageId: "hello_world" + "_de",
+					pattern: [
+						{
+							type: "text",
+							value: "Hallo Welt!",
+						},
+					],
+				},
+			],
+		},
+	],
+};
+
+test("fromMessageV1", () => {
+	expect(Value.Check(MessageV1, messageV1)).toBe(true);
+	const nestedBundle: unknown = fromMessageV1(messageV1);
+
+	expect(nestedBundle).toEqual(bundle);
+});
+
+test.todo("with variable references", () => {});

package/src/json-schema/old-v1-message/fromMessageV1.ts

@@ -0,0 +1,99 @@
+import type {
+	BundleNested,
+	MessageNested,
+	Variant,
+} from "../../database/schema.js";
+import type { Declaration, Pattern } from "../pattern.js";
+import type { MessageV1, PatternV1 } from "./schemaV1.js";
+
+/**
+ * Converts a MessageV1 into a BundleNested
+ *
+ * @throws If the message cannot be represented in the v1 format
+ */
+export function fromMessageV1(messageV1: MessageV1): BundleNested {
+	const bundleId = messageV1.id;
+
+	const languages = [
+		...new Set(messageV1.variants.map((variant) => variant.languageTag)),
+	];
+
+	const declarations = new Set<Declaration>();
+
+	const messages: MessageNested[] = languages.map((language): MessageNested => {
+		const messageId = bundleId + "_" + language;
+		//All variants that will be part of this message
+		const v1Variants = messageV1.variants.filter(
+			(variant) => variant.languageTag === language
+		);
+
+		//find all selector names
+		const selectorNames = new Set<string>();
+		for (const v1Selector of messageV1.selectors ?? []) {
+			selectorNames.add(v1Selector.name);
+		}
+
+		//The set of variables that need to be defined - Certainly includes the selectors
+		const variableNames = new Set<string>(selectorNames);
+		const variants: Variant[] = [];
+		let variantIndex = 1;
+		for (const v1Variant of v1Variants) {
+			for (const element of v1Variant.pattern) {
+				if (element.type === "VariableReference") {
+					variableNames.add(element.name);
+				}
+			}
+
+			variants.push({
+				// matching was not supported. no problem should arise
+				matches: [],
+				pattern: fromPatternV1(v1Variant.pattern),
+				id: messageId + "_" + variantIndex,
+				messageId: messageId,
+			});
+			variantIndex += 1;
+		}
+
+		//Create an input declaration for each variable and selector we need
+		for (const variable of variableNames) {
+			declarations.add({
+				type: "input-variable",
+				name: variable,
+			});
+		}
+
+		return {
+			id: messageId,
+			bundleId: bundleId,
+			locale: language,
+			selectors: [],
+			variants,
+		};
+	});
+
+	return {
+		id: bundleId,
+		declarations: [...declarations],
+		messages,
+	};
+}
+function fromPatternV1(pattern: PatternV1): Pattern {
+	return pattern.map((element) => {
+		switch (element.type) {
+			case "Text": {
+				return {
+					type: "text",
+					value: element.value,
+				};
+			}
+			case "VariableReference":
+				return {
+					type: "expression",
+					arg: {
+						type: "variable-reference",
+						name: element.name,
+					},
+				};
+		}
+	});
+}

package/src/json-schema/old-v1-message/schemaV1.ts

@@ -0,0 +1,66 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+/**
+ * A (text) element that is translatable and rendered to the UI.
+ */
+export type TextV1 = Static<typeof TextV1>;
+export const TextV1 = Type.Object({
+	type: Type.Literal("Text"),
+	value: Type.String(),
+});
+
+export type VariableReferenceV1 = Static<typeof VariableReferenceV1>;
+export const VariableReferenceV1 = Type.Object({
+	type: Type.Literal("VariableReference"),
+	name: Type.String(),
+});
+
+/**
+ * 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 ExpressionV1 = Static<typeof ExpressionV1>;
+export const ExpressionV1 = Type.Union([VariableReferenceV1]);
+
+// 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 PatternV1 = Static<typeof PatternV1>;
+export const PatternV1 = Type.Array(Type.Union([TextV1, ExpressionV1]));
+
+/**
+ * A variant contains a pattern that is rendered to the UI.
+ */
+export type VariantV1 = Static<typeof VariantV1>;
+export const VariantV1 = Type.Object({
+	languageTag: Type.String(),
+	/**
+	 * 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: PatternV1,
+});
+
+export type MessageV1 = Static<typeof MessageV1>;
+export const MessageV1 = Type.Object({
+	id: Type.String(),
+	alias: Type.Record(Type.String(), Type.String()),
+	/**
+	 * The order in which the selectors are placed determines the precedence of patterns.
+	 */
+	selectors: Type.Array(ExpressionV1),
+	variants: Type.Array(VariantV1),
+});

package/src/json-schema/old-v1-message/toMessageV1.test.ts

@@ -0,0 +1,87 @@
+import { test, expect } from "vitest";
+import { toMessageV1 } from "./toMessageV1.js";
+import { Value } from "@sinclair/typebox/value";
+import { MessageV1 } from "./schemaV1.js";
+import type { BundleNested } from "../../database/schema.js";
+
+test("toMessageV1", () => {
+	const message: unknown = toMessageV1(bundle);
+	expect(Value.Check(MessageV1, message)).toBe(true);
+
+	expect(message).toStrictEqual(messageV1);
+});
+
+test.todo("with variable references", () => {});
+
+const messageV1: MessageV1 = {
+	id: "hello_world",
+	alias: {},
+	variants: [
+		{
+			languageTag: "en",
+			match: [],
+			pattern: [
+				{
+					type: "Text",
+					value: "Hello World!",
+				},
+			],
+		},
+		{
+			languageTag: "de",
+			match: [],
+			pattern: [
+				{
+					type: "Text",
+					value: "Hallo Welt!",
+				},
+			],
+		},
+	],
+	selectors: [],
+};
+
+const bundle: BundleNested = {
+	id: "hello_world",
+	declarations: [],
+	messages: [
+		{
+			bundleId: "hello_world",
+			id: "hello_world" + "_en",
+			locale: "en",
+			selectors: [],
+			variants: [
+				{
+					id: "hello_world" + "_en_1",
+					matches: [],
+					messageId: "hello_world" + "_en",
+					pattern: [
+						{
+							type: "text",
+							value: "Hello World!",
+						},
+					],
+				},
+			],
+		},
+		{
+			bundleId: "hello_world",
+			id: "hello_world" + "_de",
+			locale: "de",
+			selectors: [],
+			variants: [
+				{
+					id: "hello_world" + "_de_1",
+					matches: [],
+					messageId: "hello_world" + "_de",
+					pattern: [
+						{
+							type: "text",
+							value: "Hallo Welt!",
+						},
+					],
+				},
+			],
+		},
+	],
+};

package/src/json-schema/old-v1-message/toMessageV1.ts

@@ -0,0 +1,79 @@
+import type { BundleNested } from "../../database/schema.js";
+import type { Pattern } from "../pattern.js";
+import type {
+	ExpressionV1,
+	MessageV1,
+	PatternV1,
+	VariantV1,
+} from "./schemaV1.js";
+
+/**
+ * Converts a BundleNested into a legacy format.
+ *
+ * @throws If the message cannot be represented in the v1 format
+ */
+export function toMessageV1(bundle: BundleNested): MessageV1 {
+	const variants: VariantV1[] = [];
+	const selectorNames = new Set<string>();
+
+	for (const message of bundle.messages) {
+		// collect all selector names
+		for (const selector of message.selectors.map((s) => ({
+			type: "variable-reference",
+			name: s.name,
+		}))) {
+			selectorNames.add(selector.name);
+		}
+
+		// collect all variants
+		for (const variant of message.variants) {
+			variants.push({
+				languageTag: message.locale,
+				match: [],
+				pattern: toV1Pattern(variant.pattern),
+			});
+		}
+	}
+
+	const selectors: ExpressionV1[] = [...selectorNames].map((name) => ({
+		type: "VariableReference",
+		name,
+	}));
+
+	return {
+		id: bundle.id,
+		alias: {},
+		variants,
+		selectors,
+	};
+}
+
+/**
+ * @throws If the pattern cannot be represented in the v1 format
+ */
+function toV1Pattern(pattern: Pattern): PatternV1 {
+	return pattern.map((element) => {
+		switch (element.type) {
+			case "text": {
+				return {
+					type: "Text",
+					value: element.value,
+				};
+			}
+
+			case "expression": {
+				if (element.arg.type === "variable-reference") {
+					return {
+						type: "VariableReference",
+						name: element.arg.name,
+					};
+				}
+				throw new Error(`Unsupported expression argument type`);
+			}
+
+			default: {
+				throw new Error(`Unsupported pattern element type`);
+			}
+		}
+	});
+}

package/src/json-schema/pattern.ts

@@ -0,0 +1,59 @@
+import { Type, type Static } from "@sinclair/typebox";
+
+export type VariableReference = Static<typeof VariableReference>;
+export const VariableReference = Type.Object({
+	type: Type.Literal("variable-reference"),
+	name: Type.String(),
+});
+
+export type Literal = Static<typeof Literal>;
+export const Literal = Type.Object({
+	type: Type.Literal("literal"),
+	value: Type.String(),
+});
+
+export type Option = Static<typeof Option>;
+export const Option = Type.Object({
+	name: Type.String(),
+	value: Type.Union([Literal, VariableReference]),
+});
+
+export type FunctionReference = Static<typeof FunctionReference>;
+export const FunctionReference = Type.Object({
+	type: Type.Literal("function-reference"),
+	name: Type.String(),
+	options: Type.Array(Option),
+});
+
+export type Expression = Static<typeof Expression>;
+export const Expression = Type.Object({
+	type: Type.Literal("expression"),
+	arg: Type.Union([VariableReference, Literal]),
+	annotation: Type.Optional(FunctionReference),
+});
+
+export type Text = Static<typeof Text>;
+export const Text = Type.Object({
+	type: Type.Literal("text"),
+	value: Type.String(),
+});
+
+export type LocalVariable = Static<typeof VariableReference>;
+export const LocalVariable = Type.Object({
+	type: Type.Literal("local-variable"),
+	name: Type.String(),
+	value: Expression,
+});
+
+export type InputVariable = Static<typeof InputVariable>;
+export const InputVariable = Type.Object({
+	type: Type.Literal("input-variable"),
+	name: Type.String(),
+	annotation: Type.Optional(FunctionReference),
+});
+
+export type Declaration = Static<typeof Declaration>;
+export const Declaration = Type.Union([InputVariable, LocalVariable]);
+
+export type Pattern = Static<typeof Pattern>;
+export const Pattern = Type.Array(Type.Union([Text, Expression]));

package/src/json-schema/settings.test-d.ts

@@ -0,0 +1,21 @@
+import { ProjectSettings } from "./settings.js";
+
+const settings = {} as ProjectSettings;
+
+// language tag and locale should be optional
+settings.languageTags = undefined;
+settings.sourceLanguageTag = undefined;
+
+// @ts-expect-error - base locale is required
+settings.baseLocale = undefined;
+
+// @ts-expect-error - locales are required
+settings.locales = undefined;
+
+// expect no error
+settings["plugin.mock"] = {
+	key: "value",
+	nested: {
+		moreNested: {},
+	},
+};