@inlang/sdk 0.24.1 → 0.26.0

package/src/loadProject.test.ts

@@ -16,10 +16,10 @@ import {
 	ProjectSettingsFileNotFoundError,
 	ProjectSettingsInvalidError,
 } from "./errors.js"
-import { createNodeishMemoryFs, normalizePath } from "@lix-js/fs"
+import { normalizePath } from "@lix-js/fs"
 import { createMessage } from "./test-utilities/createMessage.js"
 import { tryCatch } from "@inlang/result"
-import { mockRepo, openRepository } from "@lix-js/client"
+import { mockRepo } from "@lix-js/client"
 import { type Snapshot } from "@lix-js/fs"
 // eslint-disable-next-line no-restricted-imports -- test
 import { readFileSync } from "node:fs"
@@ -109,15 +109,11 @@ const _import: ImportFunction = async (name) =>
 		default: name === "plugin.js" ? mockPlugin : mockMessageLintRule,
 	} satisfies InlangModule)
 
-async function openCiTestRepo() {
-	return await mockRepo({
-		fromSnapshot: JSON.parse(
-			readFileSync(resolve(__dirname, "../mocks/ci-test-repo-no-shallow.json"), {
-				encoding: "utf-8",
-			})
-		) as Snapshot,
+const ciTestRepoSnapshot = JSON.parse(
+	readFileSync(resolve(__dirname, "../mocks/ci-test-repo-no-shallow.json"), {
+		encoding: "utf-8",
 	})
-}
+) as Snapshot
 
 // ------------------------------------------------------------------------------------------------
 
@@ -128,8 +124,7 @@ async function openCiTestRepo() {
  * like files: they can be renamed and moved around.
  */
 it("should throw if a project (path) does not have a name", async () => {
-	const fs = createNodeishMemoryFs()
-	const repo = await openRepository("file://", { nodeishFs: fs })
+	const repo = await mockRepo()
 	const project = await tryCatch(() =>
 		loadProject({
 			projectPath: "/source-code/.inlang",
@@ -141,8 +136,7 @@ it("should throw if a project (path) does not have a name", async () => {
 })
 
 it("should throw if a project path does not end with .inlang", async () => {
-	const fs = createNodeishMemoryFs()
-	const repo = await openRepository("file://", { nodeishFs: fs })
+	const repo = await mockRepo()
 
 	const invalidPaths = [
 		"/source-code/frontend.inlang/settings",
@@ -164,8 +158,7 @@ it("should throw if a project path does not end with .inlang", async () => {
 
 describe("initialization", () => {
 	it("should throw if projectPath is not an absolute path", async () => {
-		const fs = createNodeishMemoryFs()
-		const repo = await openRepository("file://", { nodeishFs: fs })
+		const repo = await mockRepo()
 
 		const result = await tryCatch(() =>
 			loadProject({
@@ -179,7 +172,7 @@ describe("initialization", () => {
 	})
 
 	it("should generate projectId on missing projectid", async () => {
-		const repo = await openCiTestRepo()
+		const repo = await mockRepo({ fromSnapshot: ciTestRepoSnapshot })
 
 		const existing = await repo.nodeishFs
 			.readFile("/project.inlang/project_id", {
@@ -215,7 +208,7 @@ describe("initialization", () => {
 	})
 
 	it("should reuse projectId on existing projectid", async () => {
-		const repo = await openCiTestRepo()
+		const repo = await mockRepo({ fromSnapshot: ciTestRepoSnapshot })
 
 		repo.nodeishFs.writeFile("/project.inlang/project_id", "testId")
 
@@ -242,10 +235,10 @@ describe("initialization", () => {
 	})
 
 	it("should resolve from a windows path", async () => {
-		const fs = createNodeishMemoryFs()
+		const repo = await mockRepo()
+		const fs = repo.nodeishFs
 		fs.mkdir("C:\\Users\\user\\project.inlang", { recursive: true })
 		fs.writeFile("C:\\Users\\user\\project.inlang\\settings.json", JSON.stringify(settings))
-		const repo = await openRepository("file://", { nodeishFs: fs })
 
 		const result = await tryCatch(() =>
 			loadProject({
@@ -261,9 +254,9 @@ describe("initialization", () => {
 
 	describe("settings", () => {
 		it("should return an error if settings file is not found", async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			fs.mkdir("/user/project", { recursive: true })
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/non-existend-project.inlang",
@@ -275,10 +268,10 @@ describe("initialization", () => {
 		})
 
 		it("should return an error if settings file is not a valid JSON", async () => {
-			const fs = await createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", "invalid json")
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
@@ -290,10 +283,10 @@ describe("initialization", () => {
 		})
 
 		it("should return an error if settings file is does not match schema", async () => {
-			const fs = await createNodeishMemoryFs()
+			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({}))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
@@ -305,10 +298,10 @@ describe("initialization", () => {
 		})
 
 		it("should return the parsed settings", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -319,11 +312,11 @@ describe("initialization", () => {
 		})
 
 		it("should not re-write the settings to disk when initializing", async () => {
-			const fs = await createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			const settingsWithDeifferentFormatting = JSON.stringify(settings, undefined, 4)
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", settingsWithDeifferentFormatting)
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
@@ -354,10 +347,10 @@ describe("initialization", () => {
 					default: {} as Plugin,
 				} satisfies InlangModule)
 
-			const fs = createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
@@ -388,10 +381,10 @@ describe("initialization", () => {
 describe("functionality", () => {
 	describe("settings", () => {
 		it("should return the settings", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -402,10 +395,10 @@ describe("functionality", () => {
 		})
 
 		it("should set a new settings", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -429,10 +422,10 @@ describe("functionality", () => {
 
 	describe("setSettings", () => {
 		it("should fail if settings are not valid", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -445,7 +438,8 @@ describe("functionality", () => {
 		})
 
 		it("should throw an error if sourceLanguageTag is not in languageTags", async () => {
-			const fs = await createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 
 			const settings: ProjectSettings = {
@@ -455,7 +449,6 @@ describe("functionality", () => {
 			}
 
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
@@ -468,10 +461,10 @@ describe("functionality", () => {
 		})
 
 		it("should write settings to disk", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -496,7 +489,8 @@ describe("functionality", () => {
 
 	describe("installed", () => {
 		it("should return the installed items", async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			const settings: ProjectSettings = {
 				sourceLanguageTag: "en",
 				languageTags: ["en"],
@@ -504,7 +498,6 @@ describe("functionality", () => {
 			}
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -528,7 +521,8 @@ describe("functionality", () => {
 		})
 
 		it("should apply 'warning' as default lint level to lint rules that have no lint level defined in the settings", async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 
 			const settings: ProjectSettings = {
 				sourceLanguageTag: "en",
@@ -538,7 +532,6 @@ describe("functionality", () => {
 
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
@@ -571,7 +564,8 @@ describe("functionality", () => {
 				loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
 				saveMessages: () => undefined,
 			}
-			const fs = await createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile(
 				"/user/project.inlang/settings.json",
@@ -581,7 +575,6 @@ describe("functionality", () => {
 					modules: ["plugin.js", "lintRule.js"],
 				} satisfies ProjectSettings)
 			)
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const _import: ImportFunction = async (name) => {
 				return {
@@ -623,7 +616,8 @@ describe("functionality", () => {
 				loadMessages: () => [{ id: "some-message", selectors: [], variants: [] }],
 				saveMessages: () => undefined,
 			}
-			const fs = await createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			await fs.mkdir("/user/project.inlang", { recursive: true })
 			await fs.writeFile(
 				"/user/project.inlang/settings.json",
@@ -633,7 +627,6 @@ describe("functionality", () => {
 					modules: ["plugin.js", "lintRule.js"],
 				} satisfies ProjectSettings)
 			)
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const _import: ImportFunction = async (name) => {
 				return {
 					default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
@@ -656,10 +649,10 @@ describe("functionality", () => {
 
 	describe("errors", () => {
 		it("should return the errors", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -673,10 +666,10 @@ describe("functionality", () => {
 
 	describe("customApi", () => {
 		it("should return the app specific api", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -691,10 +684,10 @@ describe("functionality", () => {
 
 	describe("messages", () => {
 		it("should return the messages", async () => {
-			const fs = await createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -707,7 +700,8 @@ describe("functionality", () => {
 
 	describe("query", () => {
 		it("should call saveMessages() on updates", async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 
 			const settings: ProjectSettings = {
 				sourceLanguageTag: "en",
@@ -722,7 +716,6 @@ describe("functionality", () => {
 			await fs.writeFile("/user/project.inlang/settings.json", JSON.stringify(settings))
 
 			await fs.mkdir("./resources")
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const mockSaveFn = vi.fn()
 
@@ -885,7 +878,8 @@ describe("functionality", () => {
 		 *  - Might be slow for a large number of messages. The requirement hasn't popped up yet though.
 		 */
 		it("should pass all messages, regardless of which message changed, to saveMessages()", async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 
 			const settings: ProjectSettings = {
 				sourceLanguageTag: "en",
@@ -898,7 +892,6 @@ describe("functionality", () => {
 
 			await fs.mkdir("./project.inlang", { recursive: true })
 			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			const mockSaveFn = vi.fn()
 
@@ -938,10 +931,10 @@ describe("functionality", () => {
 
 	describe("lint", () => {
 		it.todo("should throw if lint reports are not initialized yet", async () => {
-			const fs = await createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 			await fs.mkdir("/user/project", { recursive: true })
 			await fs.writeFile("/user/project/project.inlang.json", JSON.stringify(settings))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project/project.inlang.json",
 				repo,
@@ -961,10 +954,10 @@ describe("functionality", () => {
 				languageTags: ["en"],
 				modules: ["lintRule.js"],
 			}
-			const fs = createNodeishMemoryFs()
+			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))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 			const project = await loadProject({
 				projectPath: "/user/project.inlang",
 				repo,
@@ -979,7 +972,8 @@ describe("functionality", () => {
 
 	describe("watcher", () => {
 		it("changing files in resources should trigger callback of message query", async () => {
-			const fs = createNodeishMemoryFs()
+			const repo = await mockRepo()
+			const fs = repo.nodeishFs
 
 			const messages = {
 				$schema: "https://inlang.com/schema/inlang-message-format",
@@ -1030,7 +1024,6 @@ describe("functionality", () => {
 
 			await fs.mkdir("./project.inlang", { recursive: true })
 			await fs.writeFile("./project.inlang/settings.json", JSON.stringify(settings))
-			const repo = await openRepository("file://", { nodeishFs: fs })
 
 			// establish watcher
 			const project = await loadProject({

package/src/loadProject.ts

@@ -30,39 +30,16 @@ import { maybeMigrateToDirectory } from "./migrations/migrateToDirectory.js"
 import { maybeCreateFirstProjectId } from "./migrations/maybeCreateFirstProjectId.js"
 import type { Repository } from "@lix-js/client"
 import { capture } from "./telemetry/capture.js"
+import { identifyProject } from "./telemetry/groupIdentify.js"
 
 const settingsCompiler = TypeCompiler.Compile(ProjectSettings)
 
-/**
- * Creates an inlang instance.
- *
- * @param projectPath - Absolute path to the inlang settings file.
- * @param @deprecated nodeishFs - Filesystem that implements the NodeishFilesystemSubset interface.
- * @param _import - Use `_import` to pass a custom import function for testing,
- *   and supporting legacy resolvedModules such as CJS.
- *
- */
-export async function loadProject(args: {
-	projectPath: string
-	nodeishFs: Repository["nodeishFs"]
-	/**
-	 * The app id is used to identify the app that is using the SDK.
-	 *
-	 * We use the app id to group events in telemetry to answer questions
-	 * like "Which apps causes these errors?" or "Which apps are used more than others?".
-	 *
-	 * @example
-	 * 	appId: "app.inlang.badge"
-	 */
-	appId?: string
-	_import?: ImportFunction
-}): Promise<InlangProject>
-
 /**
  * @param projectPath - Absolute path to the inlang settings file.
  * @param repo - An instance of a lix repo as returned by `openRepository`.
  * @param _import - Use `_import` to pass a custom import function for testing,
  *   and supporting legacy resolvedModules such as CJS.
+ * @param appId - The app id to use for telemetry e.g "app.inlang.badge"
  *
  */
 export async function loadProject(args: {
@@ -70,14 +47,6 @@ export async function loadProject(args: {
 	repo: Repository
 	appId?: string
 	_import?: ImportFunction
-}): Promise<InlangProject>
-
-export async function loadProject(args: {
-	projectPath: string
-	repo?: Repository
-	appId?: string
-	_import?: ImportFunction
-	nodeishFs?: Repository["nodeishFs"]
 }): Promise<InlangProject> {
 	const projectPath = normalizePath(args.projectPath)
 
@@ -98,15 +67,7 @@ export async function loadProject(args: {
 		)
 	}
 
-	let fs: Repository["nodeishFs"]
-	if (args.nodeishFs) {
-		// TODO: deprecate
-		fs = args.nodeishFs
-	} else if (args.repo) {
-		fs = args.repo.nodeishFs
-	} else {
-		throw new LoadProjectInvalidArgument(`Repo missing from arguments.`, { argument: "repo" })
-	}
+	const fs = args.repo.nodeishFs
 
 	const nodeishFs = createNodeishFsWithAbsolutePaths({
 		projectPath,
@@ -319,6 +280,14 @@ export async function loadProject(args: {
 		if (projectId && projectLoadedCapturedAlready === false) {
 			projectLoadedCapturedAlready = true
 			// TODO ensure that capture is "awaited" without blocking the the app from starting
+			await identifyProject({
+				projectId,
+				properties: {
+					// using the id for now as a name but can be changed in the future
+					// we need at least one property to make a project visible in the dashboard
+					name: projectId,
+				},
+			})
 			await capture("SDK loaded project", {
 				projectId,
 				properties: {
@@ -332,6 +301,7 @@ export async function loadProject(args: {
 		}
 
 		return {
+			id: projectId,
 			installed: {
 				plugins: createSubscribable(() => installedPlugins()),
 				messageLintRules: createSubscribable(() => installedMessageLintRules()),

package/src/telemetry/groupIdentify.ts

@@ -0,0 +1,41 @@
+import { ENV_VARIABLES } from "../env-variables/index.js"
+
+/**
+ * Capture an event.
+ *
+ * - manually calling the PostHog API because the SDKs were not platform angostic (and generally bloated)
+ */
+export const identifyProject = async (args: {
+	projectId: string
+	/**
+	 * Please use snake_case for property names.
+	 */
+	properties: Record<string, any>
+}) => {
+	// do not send events if the token is not set
+	// (assuming this eases testing)
+	if (ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN === undefined) {
+		return
+	}
+	try {
+		await fetch("https://eu.posthog.com/capture/", {
+			method: "POST",
+			body: JSON.stringify({
+				api_key: ENV_VARIABLES.PUBLIC_POSTHOG_TOKEN,
+				event: "$groupidentify",
+				// id is "unknown" because no user information is available
+				distinct_id: "unknown",
+				properties: {
+					$group_type: "project",
+					$group_key: args.projectId,
+					$group_set: {
+						...args.properties,
+					},
+				},
+			}),
+		})
+	} catch (e) {
+		// TODO implement sentry logging
+		// do not console.log and avoid exposing internal errors to the user
+	}
+}