@inlang/sdk 0.34.8 → 0.34.10

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.34.8",
+  "version": "0.34.10",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -33,11 +33,11 @@
     "murmurhash3js": "^3.0.1",
     "solid-js": "1.6.12",
     "throttle-debounce": "^5.0.0",
+    "@inlang/message": "2.1.0",
     "@inlang/json-types": "1.1.0",
     "@inlang/language-tag": "1.5.1",
-    "@inlang/message": "2.1.0",
-    "@inlang/message-lint-rule": "1.4.7",
     "@inlang/module": "1.2.11",
+    "@inlang/message-lint-rule": "1.4.7",
     "@inlang/plugin": "2.4.11",
     "@inlang/project-settings": "2.4.2",
     "@inlang/result": "1.1.0",

package/src/adapter/solidAdapter.test.ts

@@ -1,13 +1,7 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect } from "vitest"
 import type { ImportFunction } from "../resolve-modules/index.js"
-import {
-	createResource,
-	createSignal,
-	createEffect,
-	from,
-	createRoot,
-} from "../reactivity/solid.js"
+import { createEffect, from, createRoot } from "../reactivity/solid.js"
 import { solidAdapter } from "./solidAdapter.js"
 import { loadProject } from "../loadProject.js"
 import { mockRepo } from "@lix-js/client"
@@ -19,10 +13,6 @@ import type {
 	Text,
 } from "../versionedInterfaces.js"
 
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
 // ------------------------------------------------------------------------------------------------
 
 const config: ProjectSettings = {
@@ -170,8 +160,8 @@ describe("installed", () => {
 		// TODO: how can we await `setConfig` correctly
 		await new Promise((resolve) => setTimeout(resolve, 0))
 
-		expect(counterPlugins).toBe(2) // 2 times because effect creation + set
-		expect(counterLint).toBe(2) // 2 times because effect creation + set
+		expect(counterPlugins).toBe(3) // 3 times because effect creation + setSettings, setResolvedModules
+		expect(counterLint).toBe(3) // 3 times because effect creation + setSettings, setResolvedModules
 	})
 })
 
@@ -219,7 +209,7 @@ describe("messages", () => {
 			{ from }
 		)
 
-		let effectOnMessagesCounter = 0
+		let effectOnMessagesCounter = -1
 		createEffect(() => {
 			project.query.messages.getAll()
 			effectOnMessagesCounter += 1
@@ -232,7 +222,7 @@ describe("messages", () => {
 		// TODO: how can we await `setConfig` correctly
 		await new Promise((resolve) => setTimeout(resolve, 510))
 
-		expect(effectOnMessagesCounter).toBe(7) // 7 = initial effect, setSetting, loadMessage (2x - one per message), setResolvedPlugins, loadMessages (2x - one per message)
+		expect(effectOnMessagesCounter).toBe(3) // 3 = setSetting, loadMessage (2x - one per message)
 		expect(Object.values(project.query.messages.getAll()).length).toBe(2)
 	})
 
@@ -363,6 +353,65 @@ describe("messages", () => {
 })
 
 describe("lint", () => {
+	it("should react to changes in config", async () => {
+		await createRoot(async () => {
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
+			await fs.mkdir("/user/project.inlang", { recursive: true })
+			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(config))
+			const project = solidAdapter(
+				await loadProject({
+					projectPath: "/user/project.inlang",
+					repo,
+					_import: $import,
+				}),
+				{ from }
+			)
+
+			// set counter to -1 since creating effect will execute once
+			let counter = -1
+			createEffect(() => {
+				project.query.messageLintReports.getAll()
+				counter += 1
+			})
+
+			expect(counter).toBe(0)
+
+			// wait for all int reports beeing executed
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 1 because we batch the two lint rules
+			expect(counter).toBe(1)
+
+			const currentSettings = project.settings()!
+			const newConfig = { ...currentSettings, languageTags: ["en", "de"] }
+			project.setSettings(newConfig)
+
+			// set settings trigges synchronous -> +1
+			expect(counter).toBe(2)
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 4 = 2 + batched(1 (effect->settings) and  1 (effect->Resolved Plugin))
+			expect(counter).toBe(3)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			const newConfig2 = { ...project.settings()!, languageTags: ["en", "de", "fr"] }
+			project.setSettings(newConfig2)
+
+			// set settings trigges synchronous -> +1
+			expect(counter).toBe(4)
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 5 -> 4 + 1 new lint report batch
+			expect(counter).toBe(5)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
+		})
+	})
+
 	it.todo("should react to changes to packages")
 	it.todo("should react to changes to modules")
 
@@ -381,23 +430,16 @@ describe("lint", () => {
 				{ from }
 			)
 
-			const [messages, setMessages] = createSignal<readonly Message[]>()
-
-			let counter = 0
-
+			let counter = -1 // -1 to start counting after the initial effect
 			createEffect(() => {
-				setMessages(project.query.messages.getAll())
-			})
-
-			const [lintReports] = createResource(messages, async () => {
-				const reports = await project.query.messageLintReports.getAll()
+				project.query.messageLintReports.getAll()
 				counter += 1
-				return reports
 			})
+			expect(counter).toBe(0)
 
-			await sleep(10)
+			await new Promise((resolve) => setTimeout(resolve, 510))
+			// 1 -> lint rules are batched - we expect one signal on getAll
 			expect(counter).toBe(1)
-			expect(lintReports()).toStrictEqual([])
 
 			project.query.messages.update({
 				where: { id: "a" },
@@ -406,10 +448,11 @@ describe("lint", () => {
 					variants: [{ languageTag: "en", match: [], pattern: [{ type: "Text", value: "new" }] }],
 				},
 			})
+			await new Promise((resolve) => setTimeout(resolve, 510))
 
-			await sleep(10)
-			expect(counter).toBe(2)
-			expect(lintReports()).toStrictEqual([])
+			// 1 -> previous two messages + 0 - report results are the same - no effect
+			expect(counter).toBe(1)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
 
 			project.query.messages.update({
 				where: { id: "a" },
@@ -419,9 +462,11 @@ describe("lint", () => {
 				},
 			})
 
-			await sleep(10)
-			expect(counter).toBe(3)
-			expect(lintReports()).toStrictEqual([])
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			// 2 -> the updated message does not update the lint rules - result is the same
+			expect(counter).toBe(1)
+			expect(project.query.messageLintReports.getAll()).toEqual([])
 		})
 	})
 })

package/src/adapter/solidAdapter.ts

@@ -39,7 +39,7 @@ export const solidAdapter = (
 			},
 			messageLintReports: {
 				get: project.query.messageLintReports.get,
-				getAll: project.query.messageLintReports.getAll,
+				getAll: convert(project.query.messageLintReports.getAll),
 			},
 		},
 	} satisfies InlangProjectWithSolidAdapter

package/src/api.ts

@@ -65,7 +65,7 @@ export type InlangProject = {
 
 /**
  * WIP template for async V2 crud interfaces
- * E.g. `project.messageBundles.get({ id: "..." })`
+ * E.g. `await project.messageBundles.get({ id: "..." })`
  **/
 interface Query<T> {
 	get: (args: unknown) => Promise<T>
@@ -82,9 +82,9 @@ export type Subscribable<Value> = {
 }
 
 export type MessageQueryDelegate = {
-	onMessageCreate: (messageId: string, message: Message) => void
-	onMessageUpdate: (messageId: string, message: Message) => void
-	onMessageDelete: (messageId: string) => void
+	onMessageCreate: (messageId: string, message: Message, messages: Message[]) => void
+	onMessageUpdate: (messageId: string, message: Message, messages: Message[]) => void
+	onMessageDelete: (messageId: string, messages: Message[]) => void
 	onLoaded: (messages: Message[]) => void
 	onCleanup: () => void
 }
@@ -109,12 +109,19 @@ export type MessageQueryApi = {
 	update: (args: { where: { id: Message["id"] }; data: Partial<Message> }) => boolean
 	upsert: (args: { where: { id: Message["id"] }; data: Message }) => void
 	delete: (args: { where: { id: Message["id"] } }) => boolean
-	setDelegate: (delegate: MessageQueryDelegate) => void
+	setDelegate: (delegate: MessageQueryDelegate | undefined, callOnLoad: boolean) => void
 }
 
 export type MessageLintReportsQueryApi = {
-	getAll: () => Promise<MessageLintReport[]>
-	get: (args: {
+	getAll: Subscribable<MessageLintReport[]> & {
+		settled: () => Promise<MessageLintReport[]>
+	}
+	get: ((args: {
 		where: { messageId: MessageLintReport["messageId"] }
-	}) => Promise<Readonly<MessageLintReport[]>>
+	}) => Readonly<MessageLintReport[]>) & {
+		subscribe: (
+			args: { where: { messageId: MessageLintReport["messageId"] } },
+			callback: (MessageLintRules: Readonly<MessageLintReport[]>) => void
+		) => void
+	}
 }

package/src/createMessageLintReportsQuery.ts

@@ -10,12 +10,19 @@ import type { resolveModules } from "./resolve-modules/index.js"
 import type { MessageLintReport, Message } from "./versionedInterfaces.js"
 import { lintSingleMessage } from "./lint/index.js"
 
-function sleep(ms: number) {
-	return new Promise((resolve) => setTimeout(resolve, ms))
-}
+import { ReactiveMap } from "./reactivity/map.js"
+import { createMemo, onCleanup, untrack, batch } from "./reactivity/solid.js"
+import { createSubscribable } from "./loadProject.js"
+
+import _debug from "debug"
+const debug = _debug("sdk:lintReports")
 
 /**
- * Creates a ~~reactive~~ query API for lint reports.
+ * Creates a non-reactive async query API for lint reports.
+ * e.g. used in editor/.../Listheader.tsx
+ *
+ * TODO MESDK-50: reactivity should be restored in future
+ * See https://github.com/opral/monorepo/pull/2378 for why this design.
  */
 export function createMessageLintReportsQuery(
 	messagesQuery: MessageQueryApi,
@@ -23,80 +30,196 @@ export function createMessageLintReportsQuery(
 	installedMessageLintRules: () => Array<InstalledMessageLintRule>,
 	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined
 ): InlangProject["query"]["messageLintReports"] {
-	const index = new Map<MessageLintReport["messageId"], MessageLintReport[]>()
-
-	const modules = resolvedModules()
-
-	const rulesArray = modules?.messageLintRules
-	const messageLintRuleLevels = Object.fromEntries(
-		installedMessageLintRules().map((rule) => [rule.id, rule.level])
-	)
-	const settingsObject = () => {
-		return {
-			...settings(),
-			messageLintRuleLevels,
-		}
-	}
+	// @ts-expect-error Reactive map seems to have a problem with Type aliases here
+	const index = new ReactiveMap<MessageLintReport["messageId"], MessageLintReport[]>()
+
+	debug("resetting settledReports")
+	let settledReports = Promise.resolve()
+
+	let currentBatchEnd: undefined | (() => Promise<void>) = undefined
+
+	const updatedReports: { [messageId: string]: MessageLintReport[] } = {}
+
+	// triggered whenever settings or resolved modules changes
+	createMemo(() => {
+		// we clear the index independent from the change for
+		index.clear()
+
+		onCleanup(() => {
+			messagesQuery.setDelegate(undefined, false)
+		})
+
+		// settings is a signal - effect will be called whenever settings changes
+		const _settings = settings()
+		if (!_settings) return
 
-	const lintMessage = (message: Message, messages: Message[]) => {
-		if (!rulesArray) {
-			return
+		const _resolvedModules = resolvedModules()
+		if (!_resolvedModules) return
+
+		// resolvedModules is a signal - effect will be called whenever resolvedModules changes
+		const rulesArray = _resolvedModules.messageLintRules
+
+		const messageLintRuleLevels = Object.fromEntries(
+			installedMessageLintRules().map((rule) => [rule.id, rule.level])
+		)
+		const settingsObject = () => {
+			return {
+				...settings(),
+				messageLintRuleLevels,
+			}
 		}
 
-		// TODO unhandled promise rejection (as before the refactor) but won't tackle this in this pr
-		lintSingleMessage({
-			rules: rulesArray,
-			settings: settingsObject(),
-			messages: messages,
-			message: message,
-		}).then((report) => {
-			if (report.errors.length === 0 && index.get(message.id) !== report.data) {
-				// console.log("lintSingleMessage", messageId, report.data.length)
-				index.set(message.id, report.data)
+		const sheduleLintMessage = (message: Message, messages: Message[]) => {
+			debug("shedule Lint for message:", message.id)
+
+			const updateOutstandingReportsOnLast = async () => {
+				if (currentBatchEnd !== updateOutstandingReportsOnLast) {
+					debug("skip triggering reactivy", message.id)
+					return
+				}
+				debug("finished queue - trigger reactivity", message.id)
+
+				batch(() => {
+					for (const [id, reports] of Object.entries(updatedReports)) {
+						const currentReports = index.get(id)
+						// we only update the report if it differs from the known one - to not trigger reactivity
+						if (!reportsEqual(currentReports, reports)) {
+							debug("lint reports for message: ", id, " now n:", reports.length)
+							index.set(id, reports)
+						}
+					}
+				})
 			}
+
+			currentBatchEnd = updateOutstandingReportsOnLast
+
+			const scheduledLint = lintSingleMessage({
+				rules: rulesArray,
+				settings: settingsObject(),
+				messages: messages,
+				message: message,
+			}).then((reportsResult) => {
+				if (reportsResult.errors.length === 0) {
+					debug("lint reports for message: ", message.id, "n:", reportsResult.data.length)
+					updatedReports[message.id] = reportsResult.data
+				}
+
+				return updateOutstandingReportsOnLast()
+			})
+			settledReports = settledReports.then(() => scheduledLint)
+		}
+
+		// setup delegate of message query
+		const messageQueryChangeDelegate: MessageQueryDelegate = {
+			onCleanup: () => {
+				// NOTE: we could cancel all running lint rules - but results get overritten anyway
+				index.clear()
+			},
+			onLoaded: (messages: Message[]) => {
+				// for (const message of messages) {
+				// 	lintMessage(message, messages)
+				// }
+				debug("sheduluing Lint for all messages - on load")
+				batch(() => {
+					debug("sheduluing Lint for all messages - subsquencial call?")
+					for (const message of messages) {
+						// NOTE: this potentually creates thousands of promisses we could create a promise that batches linting
+						// NOTE: this produces a lot of signals - we could batch the
+						sheduleLintMessage(message, messages)
+					}
+				})
+			},
+			onMessageCreate: (messageId: string, message: Message, messages: Message[]) => {
+				// NOTE: unhandled promise rejection (as before the refactor) but won't tackle this in this pr
+				// TODO MESDK-105 reevaluate all lint's instead of those for the messsage that where created
+				debug("shedule Lint for message - onMessageCreate", message.id)
+				sheduleLintMessage(message, messages)
+			},
+			onMessageUpdate: (messageId: string, message: Message, messages: Message[]) => {
+				// NOTE: unhandled promise rejection (as before the refactor) but won't tackle this in this pr
+				// TODO MESDK-105 reevaluate all lint's instead of those for the messsage that changed
+				debug("shedule Lint for message - onMessageUpdate", message.id)
+				sheduleLintMessage(message, messages)
+			},
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars -- TODO MESDK-105 we gonna need the mesage Property for evaluation
+			onMessageDelete: (messageId: string, _messages: Message[]) => {
+				index.delete(messageId)
+			},
+		}
+
+		untrack(() => {
+			messagesQuery.setDelegate(messageQueryChangeDelegate, true)
 		})
+	})
+
+	const get = (args: Parameters<MessageLintReportsQueryApi["get"]>[0]) => {
+		debug("get", args.where.messageId)
+		return structuredClone(index.get(args.where.messageId))
 	}
 
-	const messages = messagesQuery.getAll() as Message[]
-	// load report for all messages once
-	for (const message of messages) {
-		// NOTE: this potentually creates thousands of promisses we could create a promise that batches linting
-		lintMessage(message, messages)
+	const getAll = () => {
+		const flatValues = [...index.values()].flat()
+		debug("getAll", flatValues.length)
+		return structuredClone(flatValues.length === 0 ? [] : flatValues) as MessageLintReport[]
 	}
 
-	const messageQueryChangeDelegate: MessageQueryDelegate = {
-		onCleanup: () => {
-			// NOTE: we could cancel all running lint rules - but results get overritten anyway
-			index.clear()
-		},
-		onLoaded: (messages: Message[]) => {
-			for (const message of messages) {
-				lintMessage(message, messages)
-			}
-		},
-		onMessageCreate: (messageId: string, message: Message) => {
-			lintMessage(message, messages)
-		},
-		onMessageUpdate: (messageId: string, message: Message) => {
-			lintMessage(message, messages)
-		},
-		onMessageDelete: (messageId: string) => {
-			index.delete(messageId)
-		},
+	return {
+		getAll: Object.assign(createSubscribable(getAll), {
+			settled: async () => {
+				await settledReports
+				return getAll()
+			},
+		}),
+		get: Object.assign(get, {
+			subscribe: (
+				args: Parameters<MessageLintReportsQueryApi["get"]["subscribe"]>[0],
+				callback: Parameters<MessageLintReportsQueryApi["get"]["subscribe"]>[1]
+			) => createSubscribable(() => get(args)).subscribe(callback),
+		}) as any,
 	}
+}
 
-	messagesQuery.setDelegate(messageQueryChangeDelegate)
+function reportsEqual(
+	reportsA: MessageLintReport[] | undefined,
+	reportsB: MessageLintReport[] | undefined
+) {
+	if (reportsA === undefined && reportsB === undefined) {
+		return true
+	} else if (reportsA === undefined || reportsB === undefined) {
+		return false
+	}
 
-	return {
-		getAll: async () => {
-			await sleep(0) // evaluate on next tick to allow for out-of-order effects
-			return structuredClone(
-				[...index.values()].flat().length === 0 ? [] : [...index.values()].flat()
-			)
-		},
-		get: async (args: Parameters<MessageLintReportsQueryApi["get"]>[0]) => {
-			await sleep(0) // evaluate on next tick to allow for out-of-order effects
-			return structuredClone(index.get(args.where.messageId) ?? [])
-		},
+	if (reportsA.length !== reportsB.length) {
+		return false
+	}
+
+	for (const [i, element] of reportsA.entries()) {
+		if (element?.languageTag !== reportsB[i]?.languageTag) {
+			return false
+		}
+
+		if (element?.level !== reportsB[i]?.level) {
+			return false
+		}
+
+		if (element?.ruleId !== reportsB[i]?.ruleId) {
+			return false
+		}
+
+		if (typeof element?.body !== typeof reportsB[i]?.body) {
+			return false
+		}
+
+		if (typeof element?.body === "string") {
+			if (reportsB[i]?.body !== reportsB[i]?.body) {
+				return false
+			}
+		} else {
+			// NOTE: this was the fastest way to check if both bodies are equal - we can optimize that later if needed
+			if (JSON.stringify(element?.body) !== JSON.stringify(element?.body)) {
+				return false
+			}
+		}
 	}
+	return true
 }