@inlang/sdk 0.1.0

package/src/adapter/solidAdapter.test.ts

@@ -0,0 +1,363 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { describe, it, expect } from "vitest"
+import type { ImportFunction } from "../resolve-modules/index.js"
+import { createEffect, from, createRoot } from "../reactivity/solid.js"
+import { solidAdapter } from "./solidAdapter.js"
+import { openInlangProject } from "../openInlangProject.js"
+import { createNodeishMemoryFs } from "@lix-js/fs"
+import type {
+	Message,
+	ProjectConfig,
+	Plugin,
+	MessageLintRule,
+	Text,
+} from "../versionedInterfaces.js"
+
+// ------------------------------------------------------------------------------------------------
+
+const config: ProjectConfig = {
+	sourceLanguageTag: "en",
+	languageTags: ["en"],
+	modules: ["plugin.js", "plugin2.js"],
+	settings: {
+		"project.messageLintRuleLevels": {
+			"messageLintRule.inlang.missingTranslation": "error",
+		},
+		"plugin.inlang.i18next": {
+			pathPattern: "./examples/example01/{languageTag}.json",
+			variableReferencePattern: ["{", "}"],
+		},
+	},
+}
+
+const mockPlugin: Plugin = {
+	meta: {
+		id: "plugin.inlang.i18next",
+		description: { en: "Mock plugin description" },
+		displayName: { en: "Mock Plugin" },
+	},
+	loadMessages: () => exampleMessages,
+	saveMessages: () => undefined,
+}
+
+// TODO: use `createMessage` utility
+const exampleMessages: Message[] = [
+	{
+		id: "a",
+		selectors: [],
+		variants: [
+			{
+				languageTag: "en",
+				match: {},
+				pattern: [
+					{
+						type: "Text",
+						value: "test",
+					},
+				],
+			},
+		],
+	},
+	{
+		id: "b",
+		selectors: [],
+		variants: [
+			{
+				languageTag: "en",
+				match: {},
+				pattern: [
+					{
+						type: "Text",
+						value: "test",
+					},
+				],
+			},
+		],
+	},
+]
+
+const mockLintRule: MessageLintRule = {
+	meta: {
+		id: "messageLintRule.namespace.mock",
+		description: { en: "Mock lint rule description" },
+		displayName: { en: "Mock Lint Rule" },
+	},
+	message: () => undefined,
+}
+
+const $import: ImportFunction = async (name) => ({
+	default: name === "plugin.js" ? mockPlugin : mockLintRule,
+})
+
+// ------------------------------------------------------------------------------------------------
+
+describe("config", () => {
+	it("should react to changes in config", async () => {
+		const fs = createNodeishMemoryFs()
+		await fs.writeFile("./project.inlang.json", JSON.stringify(config))
+		const inlang = solidAdapter(
+			await openInlangProject({
+				projectFilePath: "./project.inlang.json",
+				nodeishFs: fs,
+				_import: $import,
+			}),
+			{ from },
+		)
+
+		let counter = 0
+		createEffect(() => {
+			inlang.config()
+			counter += 1
+		})
+
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		const newConfig = { ...inlang.config()!, languageTags: ["en", "de"] }
+
+		inlang.setConfig(newConfig)
+		// TODO: how can we await `setConfig` correctly
+		await new Promise((resolve) => setTimeout(resolve, 0))
+		expect(counter).toBe(2) // 2 times because effect creation + set
+		expect(inlang.config()).toStrictEqual(newConfig)
+	})
+})
+
+describe("installed", () => {
+	it("react to changes that are unrelated to installed items", async () => {
+		const fs = createNodeishMemoryFs()
+		await fs.writeFile("./project.inlang.json", JSON.stringify(config))
+		const inlang = solidAdapter(
+			await openInlangProject({
+				projectFilePath: "./project.inlang.json",
+				nodeishFs: fs,
+				_import: $import,
+			}),
+			{ from },
+		)
+		let counterPlugins = 0
+		let counterLint = 0
+
+		createEffect(() => {
+			inlang.installed.plugins()
+			counterPlugins += 1
+		})
+
+		createEffect(() => {
+			inlang.installed.messageLintRules()
+			counterLint += 1
+		})
+
+		inlang.setConfig({ ...inlang.config()!, languageTags: ["en", "fr"] })
+
+		// 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
+	})
+})
+
+describe("messages", () => {
+	it("should react to changes in config", async () => {
+		const fs = createNodeishMemoryFs()
+		const mockConfig: ProjectConfig = {
+			sourceLanguageTag: "en",
+			languageTags: ["en", "de"],
+			modules: ["./plugin-a.js"],
+			settings: {
+				"library.inlang.paraglideJsSveltekit": {
+					languageNegotiation: {
+						strategies: [
+							{
+								type: "localStorage",
+							} as any,
+						],
+					},
+				},
+			},
+		}
+		const mockPlugin: Plugin = {
+			meta: {
+				id: "plugin.mock.id",
+				displayName: {
+					en: "hello",
+				},
+				description: {
+					en: "wo",
+				},
+			},
+			loadMessages: ({ languageTags }) => (languageTags.length ? exampleMessages : []),
+			saveMessages: () => undefined,
+		}
+
+		const mockImport: ImportFunction = async () => ({ default: mockPlugin })
+
+		await fs.writeFile("./project.inlang.json", JSON.stringify(mockConfig))
+		const inlang = solidAdapter(
+			await openInlangProject({
+				projectFilePath: "./project.inlang.json",
+				nodeishFs: fs,
+				_import: mockImport,
+			}),
+			{ from },
+		)
+
+		let counter = 0
+		createEffect(() => {
+			inlang.query.messages.getAll()
+			counter += 1
+		})
+
+		expect(Object.values(inlang.query.messages.getAll()).length).toBe(2)
+
+		inlang.setConfig({ ...inlang.config()!, languageTags: [] })
+
+		// TODO: how can we await `setConfig` correctly
+		await new Promise((resolve) => setTimeout(resolve, 0))
+
+		expect(counter).toBe(2) // 2 times because effect creation + set
+		expect(Object.values(inlang.query.messages.getAll()).length).toBe(0)
+	})
+
+	it("should react to changes in messages", async () => {
+		const fs = createNodeishMemoryFs()
+		await fs.writeFile("./project.inlang.json", JSON.stringify(config))
+		const inlang = solidAdapter(
+			await openInlangProject({
+				projectFilePath: "./project.inlang.json",
+				nodeishFs: fs,
+				_import: $import,
+			}),
+			{ from },
+		)
+
+		let counter = 0
+		createEffect(() => {
+			inlang.query.messages.getAll()
+			counter += 1
+		})
+
+		const messagesBefore = inlang.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")
+
+		inlang.query.messages.update({
+			where: { id: "a" },
+			// 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 = inlang.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")
+	})
+})
+
+describe("lint", () => {
+	it.todo("should react to changes in config", async () => {
+		await createRoot(async () => {
+			const fs = createNodeishMemoryFs()
+			await fs.writeFile("./inlang.config.json", JSON.stringify(config))
+			const inlang = solidAdapter(
+				await openInlangProject({
+					projectFilePath: "./inlang.config.json",
+					nodeishFs: fs,
+					_import: $import,
+				}),
+				{ from },
+			)
+
+			let counter = 0
+			createEffect(() => {
+				inlang.query.messageLintReports.getAll()
+				counter += 1
+			})
+
+			const newConfig = { ...inlang.config()!, languageTags: ["en", "de"] }
+			inlang.setConfig(newConfig)
+
+			expect(counter).toBe(1)
+			expect(inlang.query.messageLintReports.getAll()).toEqual([])
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			const newConfig2 = { ...inlang.config()!, languageTags: ["en", "de", "fr"] }
+			inlang.setConfig(newConfig2)
+
+			expect(counter).toBe(9)
+			expect(inlang.query.messageLintReports.getAll()).toEqual([])
+		})
+	})
+
+	it.todo("should react to changes to packages")
+	it.todo("should react to changes to modules")
+
+	it.todo("should react to changes to messages", async () => {
+		await createRoot(async () => {
+			const fs = createNodeishMemoryFs()
+			await fs.writeFile("./inlang.config.json", JSON.stringify(config))
+			const inlang = solidAdapter(
+				await openInlangProject({
+					projectFilePath: "./inlang.config.json",
+					nodeishFs: fs,
+					_import: $import,
+				}),
+				{ from },
+			)
+
+			let counter = 0
+			createEffect(() => {
+				inlang.query.messageLintReports.getAll()
+				counter += 1
+			})
+
+			inlang.query.messages.update({
+				where: { id: "a" },
+				data: {
+					...exampleMessages[0],
+					variants: [{ languageTag: "en", match: {}, pattern: [{ type: "Text", value: "new" }] }],
+				},
+			})
+
+			expect(counter).toBe(1)
+			expect(inlang.query.messageLintReports.getAll()).toEqual([])
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			inlang.query.messages.update({
+				where: { id: "a" },
+				data: {
+					...exampleMessages[0],
+					variants: [{ languageTag: "en", match: {}, pattern: [{ type: "Text", value: "new" }] }],
+				},
+			})
+
+			expect(counter).toBe(6)
+			expect(inlang.query.messageLintReports.getAll()).toEqual([])
+		})
+	})
+})

package/src/adapter/solidAdapter.ts

@@ -0,0 +1,77 @@
+import type { InlangProject, MessageLintReportsQueryApi } from "../api.js"
+import { observable, type from as solidFrom } from "../reactivity/solid.js"
+import type { MessageQueryApi } from "@inlang/sdk"
+
+export const solidAdapter = (
+	project: InlangProject,
+	arg: {
+		from: typeof solidFrom
+	},
+): InlangProjectWithSolidAdapter => {
+	const convert = <T>(signal: () => T): (() => T) => {
+		return arg.from(observable(signal)) as () => T
+	}
+
+	return {
+		customApi: convert(project.customApi),
+		config: convert(project.config),
+		errors: convert(project.errors),
+		installed: {
+			messageLintRules: convert(project.installed.messageLintRules),
+			plugins: convert(project.installed.plugins),
+		},
+		setConfig: project.setConfig,
+		query: {
+			messages: {
+				create: project.query.messages.create,
+				update: project.query.messages.update,
+				delete: project.query.messages.delete,
+				upsert: project.query.messages.upsert,
+				get: project.query.messages.get,
+				// get: (args) => {
+				// 	const [message, setMessage] = createSignal<Message | undefined>()
+				// 	project.query.messages.get.subscribe(args, setMessage)
+				// 	return message()
+				// },
+				getAll: convert(project.query.messages.getAll),
+				includedMessageIds: convert(project.query.messages.includedMessageIds),
+			},
+			messageLintReports: {
+				get: project.query.messageLintReports.get,
+				getAll: convert(project.query.messageLintReports.getAll),
+			},
+		},
+	} satisfies InlangProjectWithSolidAdapter
+}
+
+export type InlangProjectWithSolidAdapter = {
+	customApi: () => ReturnType<InlangProject["customApi"]>
+	installed: {
+		plugins: () => ReturnType<InlangProject["installed"]["plugins"]>
+		messageLintRules: () => ReturnType<InlangProject["installed"]["messageLintRules"]>
+	}
+	errors: () => ReturnType<InlangProject["errors"]>
+	config: () => ReturnType<InlangProject["config"]>
+	setConfig: InlangProject["setConfig"]
+	query: {
+		messages: {
+			create: MessageQueryApi["create"]
+			update: MessageQueryApi["update"]
+			delete: MessageQueryApi["delete"]
+			upsert: MessageQueryApi["upsert"]
+			get: MessageQueryApi["get"]
+			//get: (args: Parameters<MessageQueryApi["get"]>[0]) => ReturnType<MessageQueryApi["get"]>
+			getAll: () => ReturnType<MessageQueryApi["getAll"]>
+			includedMessageIds: () => ReturnType<MessageQueryApi["includedMessageIds"]>
+		}
+		messageLintReports: {
+			get: MessageLintReportsQueryApi["get"]
+			getAll: () => ReturnType<MessageLintReportsQueryApi["getAll"]>
+		}
+	}
+}
+
+// const x = {} as InlangProjectWithSolidAdapter
+// x.query.lintReports.getAll()
+
+// console.log(await x.lint())

package/src/api.ts

@@ -0,0 +1,86 @@
+import type { Result } from "@inlang/result"
+import type * as RuntimeError from "./errors.js"
+import type * as ModuleResolutionError from "./resolve-modules/errors.js"
+import type {
+	MessageLintLevel,
+	MessageLintRule,
+	Message,
+	Plugin,
+	ProjectConfig,
+	MessageLintReport,
+} from "./versionedInterfaces.js"
+import type { ResolvedPluginApi } from "./resolve-modules/plugins/types.js"
+
+export type InstalledPlugin = {
+	meta: Plugin["meta"]
+	/**
+	 * The module which the plugin is installed from.
+	 */
+	module: string
+	// disabled: boolean
+}
+
+export type InstalledMessageLintRule = {
+	meta: MessageLintRule["meta"]
+	/**
+	 * The module which the lint rule is installed from.
+	 */
+	module: string
+	lintLevel: MessageLintLevel
+}
+
+export type InlangProject = {
+	installed: {
+		plugins: Subscribable<InstalledPlugin[]>
+		messageLintRules: Subscribable<InstalledMessageLintRule[]>
+	}
+	errors: Subscribable<
+		((typeof ModuleResolutionError)[keyof typeof ModuleResolutionError] | Error)[]
+	>
+	customApi: Subscribable<ResolvedPluginApi["customApi"]>
+	config: Subscribable<ProjectConfig | undefined>
+	setConfig: (config: ProjectConfig) => Result<void, RuntimeError.InvalidConfigError>
+	query: {
+		messages: MessageQueryApi
+		messageLintReports: MessageLintReportsQueryApi
+	}
+}
+
+// const x = {} as InlangProject
+// const l = await x.lint()
+// x.lint.subscribe((m) => console.log(m))
+
+export type Subscribable<Value> = {
+	(): Value
+	subscribe: (callback: (value: Value) => void) => void
+}
+
+export type MessageQueryApi = {
+	create: (args: { data: Message }) => boolean
+	get: ((args: { where: { id: Message["id"] } }) => Readonly<Message>) & {
+		subscribe: (
+			args: { where: { id: Message["id"] } },
+			callback: (message: Message) => void,
+		) => void
+	}
+	includedMessageIds: Subscribable<Message["id"][]>
+	/*
+	 * getAll is depricated do not use it
+	 */
+	getAll: Subscribable<Readonly<Message[]>>
+	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
+}
+
+export type MessageLintReportsQueryApi = {
+	getAll: Subscribable<MessageLintReport[]>
+	get: ((args: {
+		where: { messageId: MessageLintReport["messageId"] }
+	}) => Readonly<MessageLintReport[]>) & {
+		subscribe: (
+			args: { where: { messageId: MessageLintReport["messageId"] } },
+			callback: (MessageLintRules: Readonly<MessageLintReport[]>) => void,
+		) => void
+	}
+}

package/src/createMessageLintReportsQuery.ts

@@ -0,0 +1,77 @@
+import { createEffect } from "./reactivity/solid.js"
+import { createSubscribable } from "./openInlangProject.js"
+import type { InlangProject, InstalledMessageLintRule, MessageLintReportsQueryApi } from "./api.js"
+import type { ProjectConfig } from "@inlang/project-config"
+import type { resolveModules } from "./resolve-modules/index.js"
+import type {
+	JSONObject,
+	MessageLintReport,
+	MessageLintRule,
+	Message,
+} from "./versionedInterfaces.js"
+import { lintSingleMessage } from "./lint/index.js"
+import { ReactiveMap } from "./reactivity/map.js"
+
+/**
+ * Creates a reactive query API for messages.
+ */
+export function createMessageLintReportsQuery(
+	messages: () => Array<Message> | undefined,
+	config: () => ProjectConfig | undefined,
+	installedMessageLintRules: () => Array<InstalledMessageLintRule>,
+	resolvedModules: () => Awaited<ReturnType<typeof resolveModules>> | undefined,
+): InlangProject["query"]["messageLintReports"] {
+	// @ts-expect-error
+	const index = new ReactiveMap<MessageLintReport["messageId"], MessageLintReport[]>()
+
+	createEffect(() => {
+		const msgs = messages()
+		const conf = config()
+		const modules = resolvedModules()
+
+		if (msgs && conf && modules) {
+			// console.log("new calculation")
+			// index.clear()
+			for (const message of msgs) {
+				// TODO: only lint changed messages and update arrays selectively
+
+				lintSingleMessage({
+					rules: modules.messageLintRules,
+					ruleSettings: conf.settings as Record<MessageLintRule["meta"]["id"], JSONObject>,
+					ruleLevels: Object.fromEntries(
+						installedMessageLintRules().map((rule) => [rule.meta.id, rule.lintLevel]),
+					),
+					sourceLanguageTag: conf.sourceLanguageTag,
+					languageTags: conf.languageTags,
+					messages: msgs,
+					message: message,
+				}).then((report) => {
+					if (
+						report.errors.length === 0 &&
+						JSON.stringify(index.get(message.id)) !== JSON.stringify(report.data)
+					) {
+						index.set(message.id, report.data || [])
+					}
+				})
+			}
+		}
+	})
+
+	const get = (args: Parameters<MessageLintReportsQueryApi["get"]>[0]) => {
+		return structuredClone(index.get(args.where.messageId))
+	}
+
+	return {
+		getAll: createSubscribable(() => {
+			return structuredClone(
+				[...index.values()].flat().length === 0 ? [] : [...index.values()].flat(),
+			)
+		}),
+		get: Object.assign(get, {
+			subscribe: (
+				args: Parameters<MessageLintReportsQueryApi["get"]["subscribe"]>[0],
+				callback: Parameters<MessageLintReportsQueryApi["get"]["subscribe"]>[1],
+			) => createSubscribable(() => get(args)).subscribe(callback),
+		}) as any,
+	}
+}