@inlang/sdk 0.26.5 → 0.28.0

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

package/src/createNodeishFsWithAbsolutePaths.ts

@@ -1,5 +1,4 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
-import { normalizePath } from "@lix-js/fs"
+import { normalizePath, type NodeishFilesystem } from "@lix-js/fs"
 import { isAbsolutePath } from "./isAbsolutePath.js"
 
 /**
@@ -10,8 +9,8 @@ import { isAbsolutePath } from "./isAbsolutePath.js"
  */
 export const createNodeishFsWithAbsolutePaths = (args: {
 	projectPath: string
-	nodeishFs: NodeishFilesystemSubset
-}): NodeishFilesystemSubset => {
+	nodeishFs: NodeishFilesystem
+}): NodeishFilesystem => {
 	if (!isAbsolutePath(args.projectPath)) {
 		throw new Error(`Expected an absolute path but received "${args.projectPath}".`)
 	}
@@ -33,11 +32,21 @@ export const createNodeishFsWithAbsolutePaths = (args: {
 		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
 			args.nodeishFs.readFile(makeAbsolute(path), options),
 		readdir: (path: string) => args.nodeishFs.readdir(makeAbsolute(path)),
-		mkdir: (path: string) => args.nodeishFs.mkdir(makeAbsolute(path)),
+		mkdir: (path: string, options: { recursive: boolean }) =>
+			args.nodeishFs.mkdir(makeAbsolute(path), options),
 		writeFile: (path: string, data: string) => args.nodeishFs.writeFile(makeAbsolute(path), data),
+		stat: (path: string) => args.nodeishFs.stat(makeAbsolute(path)),
+		rm: (path: string) => args.nodeishFs.rm(makeAbsolute(path)),
+		rmdir: (path: string) => (args.nodeishFs as any).rmdir(makeAbsolute(path)),
 		watch: (
 			path: string,
 			options: { signal: AbortSignal | undefined; recursive: boolean | undefined }
 		) => args.nodeishFs.watch(makeAbsolute(path), options),
+		// This might be surprising when symlinks were intended to be relative
+		symlink: (target: string, path: string) =>
+			args.nodeishFs.symlink(makeAbsolute(target), makeAbsolute(path)),
+		unlink: (path: string) => args.nodeishFs.unlink(makeAbsolute(path)),
+		readlink: (path: string) => args.nodeishFs.readlink(makeAbsolute(path)),
+		lstat: (path: string) => args.nodeishFs.lstat(makeAbsolute(path)),
 	}
 }

package/src/createNodeishFsWithWatcher.ts

@@ -1,4 +1,4 @@
-import type { NodeishFilesystemSubset } from "@inlang/plugin"
+import type { NodeishFilesystem } from "@lix-js/fs"
 
 /**
  * Wraps the nodeish filesystem subset with a function that intercepts paths
@@ -7,9 +7,9 @@ import type { NodeishFilesystemSubset } from "@inlang/plugin"
  * The paths are resolved from the `projectPath` argument.
  */
 export const createNodeishFsWithWatcher = (args: {
-	nodeishFs: NodeishFilesystemSubset
+	nodeishFs: NodeishFilesystem
 	updateMessages: () => void
-}): NodeishFilesystemSubset => {
+}): NodeishFilesystem => {
 	const pathList: string[] = []
 
 	const makeWatcher = (path: string) => {
@@ -50,9 +50,12 @@ export const createNodeishFsWithWatcher = (args: {
 		// @ts-expect-error
 		readFile: (path: string, options: { encoding: "utf-8" | "binary" }) =>
 			readFileAndExtractPath(path, options),
+		rm: args.nodeishFs.rm,
 		readdir: args.nodeishFs.readdir,
 		mkdir: args.nodeishFs.mkdir,
+		rmdir: (args.nodeishFs as any).rmdir,
 		writeFile: args.nodeishFs.writeFile,
 		watch: args.nodeishFs.watch,
+		stat: args.nodeishFs.stat,
 	}
 }

package/src/errors.ts

@@ -50,3 +50,23 @@ export class PluginLoadMessagesError extends Error {
 		this.name = "PluginLoadMessagesError"
 	}
 }
+
+export class LoadMessageError extends Error {
+	constructor(options: { path: string; messageId: string; cause: ErrorOptions["cause"] }) {
+		super(
+			`An error occured when loading message ${options.messageId} from path ${options.path} caused by ${options.cause}.`,
+			options
+		)
+		this.name = "LoadMessageError"
+	}
+}
+
+export class SaveMessageError extends Error {
+	constructor(options: { path: string; messageId: string; cause: ErrorOptions["cause"] }) {
+		super(
+			`An error occured when loading message ${options.messageId} from path ${options.path} caused by ${options.cause}.`,
+			options
+		)
+		this.name = "SaveMessageError"
+	}
+}

package/src/loadProject.test.ts

@@ -65,6 +65,7 @@ const mockPlugin: Plugin = {
 const exampleMessages: Message[] = [
 	{
 		id: "a",
+		alias: {},
 		selectors: [],
 		variants: [
 			{
@@ -81,6 +82,48 @@ const exampleMessages: Message[] = [
 	},
 	{
 		id: "b",
+		alias: {},
+		selectors: [],
+		variants: [
+			{
+				languageTag: "en",
+				match: [],
+				pattern: [
+					{
+						type: "Text",
+						value: "test",
+					},
+				],
+			},
+		],
+	},
+]
+
+const exampleAliasedMessages: Message[] = [
+	{
+		id: "raw_tapir_pause_grateful",
+		alias: {
+			default: "a",
+		},
+		selectors: [],
+		variants: [
+			{
+				languageTag: "en",
+				match: [],
+				pattern: [
+					{
+						type: "Text",
+						value: "test",
+					},
+				],
+			},
+		],
+	},
+	{
+		id: "dizzy_halibut_dial_vaguely",
+		alias: {
+			default: "b",
+		},
 		selectors: [],
 		variants: [
 			{
@@ -509,6 +552,7 @@ describe("functionality", () => {
 				description: mockPlugin.description,
 				displayName: mockPlugin.displayName,
 				module: settings.modules[0],
+				settingsSchema: mockPlugin.settingsSchema,
 			})
 
 			expect(project.installed.messageLintRules()[0]).toEqual({
@@ -517,6 +561,7 @@ describe("functionality", () => {
 				displayName: mockMessageLintRule.displayName,
 				module: settings.modules[1],
 				level: "warning",
+				settingsSchema: mockMessageLintRule.settingsSchema,
 			})
 		})
 
@@ -561,7 +606,7 @@ describe("functionality", () => {
 				description: { en: "Mock plugin description" },
 				displayName: { en: "Mock Plugin" },
 
-				loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
+				loadMessages: () => [{ id: "some-message", alias: {}, selectors: [], variants: [] }],
 				saveMessages: () => undefined,
 			}
 			const repo = await mockRepo()
@@ -613,7 +658,7 @@ describe("functionality", () => {
 				description: { en: "Mock plugin description" },
 				displayName: { en: "Mock Plugin" },
 
-				loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
+				loadMessages: () => [{ id: "some-message", alias: {}, selectors: [], variants: [] }],
 				saveMessages: () => undefined,
 			}
 			const repo = await mockRepo()
@@ -698,6 +743,25 @@ describe("functionality", () => {
 		})
 	})
 
+	describe("messages with aliases", () => {
+		it("should return the messages", 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({ ...settings, experimental: { aliases: true } })
+			)
+			const project = await loadProject({
+				projectPath: "/user/project.inlang",
+				repo,
+				_import,
+			})
+
+			expect(Object.values(project.query.messages.getAll())).toEqual(exampleAliasedMessages)
+		})
+	})
+
 	describe("query", () => {
 		it("should call saveMessages() on updates", async () => {
 			const repo = await mockRepo()
@@ -744,6 +808,7 @@ describe("functionality", () => {
 				where: { id: "a" },
 				data: {
 					id: "a",
+					alias: {},
 					selectors: [],
 					variants: [
 						{
@@ -774,6 +839,7 @@ describe("functionality", () => {
 				where: { id: "b" },
 				data: {
 					id: "b",
+					alias: {},
 					selectors: [],
 					variants: [
 						{
@@ -800,7 +866,8 @@ describe("functionality", () => {
 				},
 			})
 
-			await new Promise((resolve) => setTimeout(resolve, 510))
+			// lets wait for the next tick
+			await new Promise((resolve) => setTimeout(resolve, 100))
 
 			expect(mockSaveFn.mock.calls.length).toBe(1)
 
@@ -809,25 +876,26 @@ describe("functionality", () => {
 			expect(Object.values(mockSaveFn.mock.calls[0][0].messages)).toStrictEqual([
 				{
 					id: "a",
+					alias: {},
 					selectors: [],
 					variants: [
 						{
-							languageTag: "en",
+							languageTag: "de",
 							match: [],
 							pattern: [
 								{
 									type: "Text",
-									value: "a en",
+									value: "a de",
 								},
 							],
 						},
 						{
-							languageTag: "de",
+							languageTag: "en",
 							match: [],
 							pattern: [
 								{
 									type: "Text",
-									value: "a de",
+									value: "a en",
 								},
 							],
 						},
@@ -835,25 +903,26 @@ describe("functionality", () => {
 				},
 				{
 					id: "b",
+					alias: {},
 					selectors: [],
 					variants: [
 						{
-							languageTag: "en",
+							languageTag: "de",
 							match: [],
 							pattern: [
 								{
 									type: "Text",
-									value: "b en",
+									value: "b de",
 								},
 							],
 						},
 						{
-							languageTag: "de",
+							languageTag: "en",
 							match: [],
 							pattern: [
 								{
 									type: "Text",
-									value: "b de",
+									value: "b en",
 								},
 							],
 						},
@@ -926,6 +995,20 @@ describe("functionality", () => {
 
 			expect(mockSaveFn.mock.calls.length).toBe(1)
 			expect(mockSaveFn.mock.calls[0][0].messages).toHaveLength(4)
+
+			project.query.messages.create({ data: createMessage("fifth", { en: "fifth message" }) })
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			expect(mockSaveFn.mock.calls.length).toBe(2)
+			expect(mockSaveFn.mock.calls[1][0].messages).toHaveLength(5)
+
+			project.query.messages.delete({ where: { id: "fourth" } })
+
+			await new Promise((resolve) => setTimeout(resolve, 510))
+
+			expect(mockSaveFn.mock.calls.length).toBe(3)
+			expect(mockSaveFn.mock.calls[2][0].messages).toHaveLength(4)
 		})
 	})
 
@@ -1040,17 +1123,28 @@ describe("functionality", () => {
 				counter = counter + 1
 			})
 
+			// subscribe fires once
 			expect(counter).toBe(1)
 
-			// change file
+			// saving the file without changing should not trigger a message query
 			await fs.writeFile("./messages.json", JSON.stringify(messages))
-			await new Promise((resolve) => setTimeout(resolve, 0))
+			await new Promise((resolve) => setTimeout(resolve, 200)) // file event will lock a file and be handled sequentially - give it time to pickup the change
+
+			// we didn't change the message we write into message.json - shouldn't change the messages
+			expect(counter).toBe(1)
+
+			// saving the file without changing should trigger a change
+			messages.data[0]!.variants[0]!.pattern[0]!.value = "changed"
+			await fs.writeFile("./messages.json", JSON.stringify(messages))
+			await new Promise((resolve) => setTimeout(resolve, 200)) // file event will lock a file and be handled sequentially - give it time to pickup the change
 
 			expect(counter).toBe(2)
 
+			messages.data[0]!.variants[0]!.pattern[0]!.value = "changed3"
+
 			// change file
 			await fs.writeFile("./messages.json", JSON.stringify(messages))
-			await new Promise((resolve) => setTimeout(resolve, 0))
+			await new Promise((resolve) => setTimeout(resolve, 200)) // file event will lock a file and be handled sequentially - give it time to pickup the change
 
 			expect(counter).toBe(3)
 		})