@inlang/sdk 0.26.4 → 0.27.0

package/dist/storage/human-id/words.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=words.test.d.ts.map

package/dist/storage/human-id/words.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"words.test.d.ts","sourceRoot":"","sources":["../../../src/storage/human-id/words.test.ts"],"names":[],"mappings":""}

package/dist/storage/human-id/words.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect } from "vitest";
+import { adjectives, animals, adverbs, verbs } from "./words.js";
+const wordlists = [adjectives, animals, adverbs, verbs];
+const allwords = [...adjectives, ...animals, ...adverbs, ...verbs];
+describe("wordlists", () => {
+    it("should have 256 words", () => {
+        for (const wordlist of wordlists) {
+            expect(wordlist.length).toBe(256);
+        }
+    });
+    it("words should be unique across lists", () => {
+        const unique = new Set(allwords);
+        expect(unique.size).toBe(256 * 4);
+    });
+    it("words should have < 10 characters", () => {
+        for (const word of allwords) {
+            expect(word.length).toBeLessThan(10);
+        }
+    });
+    it("words should match /^[a-z]+$/", () => {
+        for (const word of allwords) {
+            expect(word.match(/^[a-z]+$/) !== null).toBe(true);
+        }
+    });
+});

package/dist/test-utilities/createMessage.d.ts

@@ -1,6 +1,7 @@
 import type { Pattern } from "@inlang/message";
 export declare const createMessage: (id: string, patterns: Record<string, Pattern | string>) => {
     id: string;
+    alias: {};
     selectors: never[];
     variants: {
         languageTag: string;

package/dist/test-utilities/createMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createMessage.d.ts","sourceRoot":"","sources":["../../src/test-utilities/createMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAEvD,eAAO,MAAM,aAAa,OAAQ,MAAM,YAAY,OAAO,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;;;;;;;;;;;;;;CAiB/D,CAAA"}
+{"version":3,"file":"createMessage.d.ts","sourceRoot":"","sources":["../../src/test-utilities/createMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAEvD,eAAO,MAAM,aAAa,OAAQ,MAAM,YAAY,OAAO,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC;;;;;;;;;;;;;;;CAkB/D,CAAA"}

package/dist/test-utilities/createMessage.js

@@ -1,5 +1,6 @@
 export const createMessage = (id, patterns) => ({
     id,
+    alias: {},
     selectors: [],
     variants: Object.entries(patterns).map(([languageTag, patterns]) => ({
         languageTag,

package/dist/test-utilities/createMessage.test.js

@@ -3,8 +3,25 @@ import { createMessage } from "./createMessage.js";
 test("should create a simple message", () => {
     expect(createMessage("welcome", {
         de: "Hallo inlang",
-    })).toMatchInlineSnapshot(`
+    })).toMatchInlineSnapshot({
+        alias: {},
+        id: "welcome",
+        selectors: [],
+        variants: [
+            {
+                languageTag: "de",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "Hallo inlang",
+                    },
+                ],
+            },
+        ],
+    }, `
 		{
+		  "alias": {},
 		  "id": "welcome",
 		  "selectors": [],
 		  "variants": [
@@ -29,63 +46,61 @@ test("should create a message with pattern", () => {
             { type: "VariableReference", name: "name" },
             { type: "Text", value: '"' },
         ],
-    })).toMatchInlineSnapshot(`
-			{
-			  "id": "greeting",
-			  "selectors": [],
-			  "variants": [
-			    {
-			      "languageTag": "en",
-			      "match": [],
-			      "pattern": [
-			        {
-			          "type": "Text",
-			          "value": "Hi ",
-			        },
-			        {
-			          "name": "name",
-			          "type": "VariableReference",
-			        },
-			        {
-			          "type": "Text",
-			          "value": "\\"",
-			        },
-			      ],
-			    },
-			  ],
-			}
-		`);
+    })).toStrictEqual({
+        alias: {},
+        id: "greeting",
+        selectors: [],
+        variants: [
+            {
+                languageTag: "en",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "Hi ",
+                    },
+                    {
+                        name: "name",
+                        type: "VariableReference",
+                    },
+                    {
+                        type: "Text",
+                        value: '"',
+                    },
+                ],
+            },
+        ],
+    });
 });
 test("should create a message with a pattern", () => {
     expect(createMessage("welcome", {
         en: "hello inlang",
         de: [{ type: "Text", value: "Hallo inlang" }],
-    })).toMatchInlineSnapshot(`
-			{
-			  "id": "welcome",
-			  "selectors": [],
-			  "variants": [
-			    {
-			      "languageTag": "en",
-			      "match": [],
-			      "pattern": [
-			        {
-			          "type": "Text",
-			          "value": "hello inlang",
-			        },
-			      ],
-			    },
-			    {
-			      "languageTag": "de",
-			      "match": [],
-			      "pattern": [
-			        {
-			          "type": "Text",
-			          "value": "Hallo inlang",
-			        },
-			      ],
-			    },
-			  ],
-			}
-		`);
+    })).toStrictEqual({
+        alias: {},
+        id: "welcome",
+        selectors: [],
+        variants: [
+            {
+                languageTag: "en",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "hello inlang",
+                    },
+                ],
+            },
+            {
+                languageTag: "de",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "Hallo inlang",
+                    },
+                ],
+            },
+        ],
+    });
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.26.4",
+  "version": "0.27.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -21,23 +21,27 @@
   },
   "dependencies": {
     "@sinclair/typebox": "^0.31.17",
+    "debug": "^4.3.4",
     "dedent": "1.5.1",
     "deepmerge-ts": "^5.1.0",
+    "murmurhash3js": "^3.0.1",
     "solid-js": "1.6.12",
     "throttle-debounce": "^5.0.0",
     "@inlang/json-types": "1.1.0",
+    "@inlang/message": "2.1.0",
+    "@inlang/message-lint-rule": "1.4.5",
     "@inlang/language-tag": "1.5.1",
-    "@inlang/message": "2.0.3",
-    "@inlang/message-lint-rule": "1.4.3",
-    "@inlang/module": "1.2.6",
-    "@inlang/plugin": "2.4.6",
-    "@inlang/project-settings": "2.2.3",
+    "@inlang/module": "1.2.8",
+    "@inlang/plugin": "2.4.8",
+    "@inlang/project-settings": "2.4.0",
     "@inlang/result": "1.1.0",
     "@inlang/translatable": "1.3.1",
-    "@lix-js/fs": "0.6.0",
-    "@lix-js/client": "0.8.0"
+    "@lix-js/client": "0.9.0",
+    "@lix-js/fs": "0.6.0"
   },
   "devDependencies": {
+    "@types/debug": "^4.1.12",
+    "@types/murmurhash3js": "^3.0.7",
     "@types/throttle-debounce": "5.0.0",
     "@vitest/coverage-v8": "^0.33.0",
     "jsdom": "22.1.0",

package/src/adapter/solidAdapter.test.ts

@@ -28,6 +28,11 @@ const config: ProjectSettings = {
 	},
 }
 
+const configWithAliases: ProjectSettings = {
+	...config,
+	experimental: { aliases: true },
+}
+
 const mockPlugin: Plugin = {
 	id: "plugin.project.i18next",
 	description: { en: "Mock plugin description" },
@@ -41,6 +46,7 @@ const mockPlugin: Plugin = {
 const exampleMessages: Message[] = [
 	{
 		id: "a",
+		alias: {},
 		selectors: [],
 		variants: [
 			{
@@ -57,6 +63,7 @@ const exampleMessages: Message[] = [
 	},
 	{
 		id: "b",
+		alias: {},
 		selectors: [],
 		variants: [
 			{
@@ -202,10 +209,10 @@ describe("messages", () => {
 			{ from }
 		)
 
-		let counter = 0
+		let effectOnMessagesCounter = 0
 		createEffect(() => {
 			project.query.messages.getAll()
-			counter += 1
+			effectOnMessagesCounter += 1
 		})
 
 		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
@@ -215,11 +222,11 @@ describe("messages", () => {
 		// TODO: how can we await `setConfig` correctly
 		await new Promise((resolve) => setTimeout(resolve, 510))
 
-		expect(counter).toBe(1) // 2 times because effect creation + set
+		expect(effectOnMessagesCounter).toBe(1) // 2 times because effect creation + set
 		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
 	})
 
-	it("should react to changes in messages", async () => {
+	it("should react to message udpate", async () => {
 		const repo = await mockRepo()
 		const fs = repo.nodeishFs
 		await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
@@ -268,6 +275,71 @@ describe("messages", () => {
 			},
 		})
 
+		it("should react to message udpate (with aliases)", async () => {
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
+			await fs.mkdir("/user/project.inlang.inlang", { recursive: true })
+			await fs.writeFile(
+				"/user/project.inlang.inlang/settings.json",
+				JSON.stringify(configWithAliases)
+			)
+			const project = solidAdapter(
+				await loadProject({
+					projectPath: "/user/project.inlang.inlang",
+					repo,
+					_import: $import,
+				}),
+				{ from }
+			)
+
+			let counter = 0
+			createEffect(() => {
+				project.query.messages.getAll()
+				counter += 1
+			})
+
+			const messagesBefore = project.query.messages.getAll
+			expect(Object.values(messagesBefore()).length).toBe(2)
+			expect(
+				(
+					Object.values(messagesBefore())[0]?.variants.find(
+						(variant) => variant.languageTag === "en"
+					)?.pattern[0] as Text
+				).value
+			).toBe("test")
+
+			project.query.messages.update({
+				where: { id: "raw_tapir_pause_grateful" },
+				// TODO: use `createMessage` utility
+				data: {
+					...exampleMessages[0],
+					variants: [
+						{
+							languageTag: "en",
+							match: [],
+							pattern: [
+								{
+									type: "Text",
+									value: "test2",
+								},
+							],
+						},
+					],
+				},
+			})
+
+			expect(counter).toBe(2) // 2 times because effect creation + set
+			const messagesAfter = project.query.messages.getAll
+			expect(Object.values(messagesAfter()).length).toBe(2)
+			expect(
+				(
+					Object.values(messagesAfter())[0]?.variants.find(
+						(variant) => variant.languageTag === "en"
+					)?.pattern[0] as Text
+				).value
+			).toBe("test2")
+		})
+
 		expect(counter).toBe(2) // 2 times because effect creation + set
 		const messagesAfter = project.query.messages.getAll
 		expect(Object.values(messagesAfter()).length).toBe(2)

package/src/api.ts

@@ -72,6 +72,10 @@ export type MessageQueryApi = {
 			callback: (message: Message) => void
 		) => void
 	}
+	// use getByDefaultAlias() to resolve a message from its alias, not subscribable
+	getByDefaultAlias: ((alias: Message["alias"]["default"]) => Readonly<Message>) & {
+		subscribe: (alias: Message["alias"]["default"], callback: (message: Message) => void) => void
+	}
 	includedMessageIds: Subscribable<Message["id"][]>
 	/*
 	 * getAll is depricated do not use it

package/src/createMessageLintReportsQuery.ts

@@ -10,8 +10,7 @@ import type { resolveModules } from "./resolve-modules/index.js"
 import type { MessageLintReport, Message } from "./versionedInterfaces.js"
 import { lintSingleMessage } from "./lint/index.js"
 import { ReactiveMap } from "./reactivity/map.js"
-import { debounce } from "throttle-debounce"
-import { createEffect } from "./reactivity/solid.js"
+import { createRoot, createEffect } from "./reactivity/solid.js"
 
 /**
  * Creates a reactive query API for messages.
@@ -21,7 +20,6 @@ export function createMessageLintReportsQuery(
 	settings: () => ProjectSettings,
 	installedMessageLintRules: () => Array<InstalledMessageLintRule>,
 	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined,
-	hasWatcher: boolean
 ): InlangProject["query"]["messageLintReports"] {
 	// @ts-expect-error
 	const index = new ReactiveMap<MessageLintReport["messageId"], MessageLintReport[]>()
@@ -41,41 +39,55 @@ export function createMessageLintReportsQuery(
 
 	const messages = messagesQuery.getAll() as Message[]
 
+	const trackedMessages: Map<string, () => void> = new Map()
+
 	createEffect(() => {
+		const currentMessageIds = new Set(messagesQuery.includedMessageIds())
+
+		const deletedTrackedMessages = [...trackedMessages].filter(
+			(tracked) => !currentMessageIds.has(tracked[0])
+		)
+
 		if (rulesArray) {
-			for (const messageId of messagesQuery.includedMessageIds()) {
-				createEffect(() => {
-					const message = messagesQuery.get({ where: { id: messageId } })
-					if (hasWatcher) {
-						lintSingleMessage({
-							rules: rulesArray,
-							settings: settingsObject(),
-							messages: messages,
-							message: message,
-						}).then((report) => {
-							if (report.errors.length === 0 && index.get(messageId) !== report.data) {
-								index.set(messageId, report.data)
+			for (const messageId of currentMessageIds) {
+				if (!trackedMessages.has(messageId)) {
+					createRoot((dispose) => {
+						createEffect(() => {
+							const message = messagesQuery.get({ where: { id: messageId } })
+							if (!message) {
+								return
+							}
+							if (!trackedMessages?.has(messageId)) {
+								// initial effect execution - add dispose function
+								trackedMessages?.set(messageId, dispose)
 							}
+
+							lintSingleMessage({
+								rules: rulesArray,
+								settings: settingsObject(),
+								messages: messages,
+								message: message,
+							}).then((report) => {
+								if (report.errors.length === 0 && index.get(messageId) !== report.data) {
+									index.set(messageId, report.data)
+								}
+							})
 						})
-					} else {
-						debounce(
-							500,
-							(message) => {
-								lintSingleMessage({
-									rules: rulesArray,
-									settings: settingsObject(),
-									messages: messages,
-									message: message,
-								}).then((report) => {
-									if (report.errors.length === 0 && index.get(messageId) !== report.data) {
-										index.set(messageId, report.data)
-									}
-								})
-							},
-							{ atBegin: false }
-						)(message)
-					}
-				})
+					})
+				}
+			}
+
+			for (const deletedMessage of deletedTrackedMessages) {
+				const deletedMessageId = deletedMessage[0]
+
+				// call dispose to cleanup the effect
+				const messageEffectDisposeFunction = trackedMessages.get(deletedMessageId)
+				if (messageEffectDisposeFunction) {
+					messageEffectDisposeFunction()
+					trackedMessages.delete(deletedMessageId)
+					// remove lint report result
+					index.delete(deletedMessageId)
+				}
 			}
 		}
 	})

package/src/createMessagesQuery.test.ts

@@ -6,6 +6,7 @@ import type { Message, Text } from "@inlang/message"
 import { createMessage } from "./test-utilities/createMessage.js"
 
 const createChangeListener = async (cb: () => void) => createEffect(cb)
+const nextTick = () => new Promise((resolve) => setTimeout(resolve, 0))
 
 describe("create", () => {
 	it("should create a message", () => {
@@ -19,6 +20,19 @@ describe("create", () => {
 		expect(created).toBe(true)
 	})
 
+	it("query.getByDefaultAlias should return a message with a default alias", () => {
+		const query = createMessagesQuery(() => [])
+		expect(query.get({ where: { id: "first-message" } })).toBeUndefined()
+
+		const mockMessage = createMessage("first-message", { en: "Hello World" })
+		mockMessage.alias = { default: "first-message-alias" }
+		const created = query.create({ data: mockMessage })
+
+		expect(query.get({ where: { id: "first-message" } })).toEqual(mockMessage)
+		expect(query.getByDefaultAlias("first-message-alias")).toEqual(mockMessage)
+		expect(created).toBe(true)
+	})
+
 	it("should return false if message with id already exists", () => {
 		const query = createMessagesQuery(() => [createMessage("first-message", { en: "Hello World" })])
 		expect(query.get({ where: { id: "first-message" } })).toBeDefined()
@@ -266,8 +280,46 @@ describe("reactivity", () => {
 		})
 	})
 
-	describe.todo("subscribe", () => {
-		// TODO: add tests for `subscribe`
+	describe("subscribe", () => {
+		describe("get", () => {
+			it("should subscribe to `create`", async () => {
+				await createRoot(async () => {
+					const query = createMessagesQuery(() => [])
+
+					// eslint-disable-next-line unicorn/no-null
+					let message: Message | undefined | null = null
+					query.get.subscribe({ where: { id: "1" } }, (v) => {
+						void (message = v)
+					})
+					await nextTick()
+					expect(message).toBeUndefined()
+
+					query.create({ data: createMessage("1", { en: "before" }) })
+					expect(message).toBeDefined()
+				})
+			})
+		})
+		describe("getByDefaultAlias", () => {
+			it("should subscribe to `create`", async () => {
+				await createRoot(async () => {
+					const query = createMessagesQuery(() => [])
+
+					// eslint-disable-next-line unicorn/no-null
+					let message: Message | undefined | null = null
+					query.getByDefaultAlias.subscribe("message-alias", (v) => {
+						void (message = v)
+					})
+					await nextTick() // required for effect to run on reactive map
+					expect(message).toBeUndefined()
+
+					const mockMessage = createMessage("1", { en: "before" })
+					mockMessage.alias = { default: "message-alias" }
+					query.create({ data: mockMessage })
+
+					expect(message).toBeDefined()
+				})
+			})
+		})
 	})
 
 	describe("getAll", () => {

package/src/createMessagesQuery.ts

@@ -13,19 +13,35 @@ export function createMessagesQuery(
 	// @ts-expect-error
 	const index = new ReactiveMap<string, Message>()
 
+	// Map default alias to message
+	// Assumes that aliases are only created and deleted, not updated
+	// TODO #2346 - handle updates to aliases
+	// TODO #2346 - refine to hold messageId[], if default alias is not unique
+	// @ts-expect-error
+	const defaultAliasIndex = new ReactiveMap<string, Message>()
+
 	createEffect(() => {
 		index.clear()
 		for (const message of structuredClone(messages())) {
 			index.set(message.id, message)
+			if ("default" in message.alias) {
+				defaultAliasIndex.set(message.alias.default, message)
+			}
 		}
 	})
 
 	const get = (args: Parameters<MessageQueryApi["get"]>[0]) => index.get(args.where.id)
 
+	const getByDefaultAlias = (alias: Parameters<MessageQueryApi["getByDefaultAlias"]>[0]) =>
+		defaultAliasIndex.get(alias)
+
 	return {
 		create: ({ data }): boolean => {
 			if (index.has(data.id)) return false
 			index.set(data.id, data)
+			if ("default" in data.alias) {
+				defaultAliasIndex.set(data.alias.default, data)
+			}
 			return true
 		},
 		get: Object.assign(get, {
@@ -34,6 +50,12 @@ export function createMessagesQuery(
 				callback: Parameters<MessageQueryApi["get"]["subscribe"]>[1]
 			) => createSubscribable(() => get(args)).subscribe(callback),
 		}) as any,
+		getByDefaultAlias: Object.assign(getByDefaultAlias, {
+			subscribe: (
+				alias: Parameters<MessageQueryApi["getByDefaultAlias"]["subscribe"]>[0],
+				callback: Parameters<MessageQueryApi["getByDefaultAlias"]["subscribe"]>[1]
+			) => createSubscribable(() => getByDefaultAlias(alias)).subscribe(callback),
+		}) as any,
 		includedMessageIds: createSubscribable(() => {
 			return [...index.keys()]
 		}),
@@ -50,13 +72,20 @@ export function createMessagesQuery(
 			const message = index.get(where.id)
 			if (message === undefined) {
 				index.set(where.id, data)
+				if ("default" in data.alias) {
+					defaultAliasIndex.set(data.alias.default, data)
+				}
 			} else {
 				index.set(where.id, { ...message, ...data })
 			}
 			return true
 		},
 		delete: ({ where }): boolean => {
-			if (!index.has(where.id)) return false
+			const message = index.get(where.id)
+			if (message === undefined) return false
+			if ("default" in message.alias) {
+				defaultAliasIndex.delete(message.alias.default)
+			}
 			index.delete(where.id)
 			return true
 		},

package/src/createNodeishFsWithAbsolutePaths.test.ts

@@ -1,6 +1,7 @@
 import { it, expect, vi } from "vitest"
 import { createNodeishFsWithAbsolutePaths } from "./createNodeishFsWithAbsolutePaths.js"
-import type { NodeishFilesystemSubset } from "./versionedInterfaces.js"
+// import type { NodeishFilesystemSubset } from "./versionedInterfaces.js"
+import type { NodeishFilesystem } from "@lix-js/fs"
 
 it("throws an error if projectPath is not an absolute path", () => {
 	const relativePath = "relative/path"
@@ -27,9 +28,16 @@ it("intercepts paths correctly for readFile", async () => {
 		readFile: vi.fn(),
 		readdir: vi.fn(),
 		mkdir: vi.fn(),
+		rmdir: vi.fn(),
 		writeFile: vi.fn(),
 		watch: vi.fn(),
-	} satisfies Record<keyof NodeishFilesystemSubset, any>
+		rm: vi.fn(),
+		stat: vi.fn(),
+		lstat: vi.fn(),
+		symlink: vi.fn(),
+		unlink: vi.fn(),
+		readlink: vi.fn(),
+	} satisfies Record<keyof NodeishFilesystem, any>
 
 	const interceptedFs = createNodeishFsWithAbsolutePaths({
 		projectPath,
@@ -38,7 +46,6 @@ it("intercepts paths correctly for readFile", async () => {
 
 	for (const [path, expectedPath] of filePaths) {
 		for (const fn of Object.keys(mockNodeishFs)) {
-			// @ts-expect-error
 			await interceptedFs[fn](path)
 			// @ts-expect-error
 			// expect the first argument to be the expectedPath