@inlang/sdk 0.22.0 → 0.24.0

package/dist/loadProject.test.js

@@ -5,7 +5,12 @@ import { LoadProjectInvalidArgument, ProjectSettingsFileJSONSyntaxError, Project
 import { createNodeishMemoryFs, normalizePath } from "@lix-js/fs";
 import { createMessage } from "./test-utilities/createMessage.js";
 import { tryCatch } from "@inlang/result";
-import { mockRepo } from "@lix-js/client";
+import { mockRepo, openRepository } from "@lix-js/client";
+import {} from "@lix-js/fs";
+// eslint-disable-next-line no-restricted-imports -- test
+import { readFileSync } from "node:fs";
+// eslint-disable-next-line no-restricted-imports -- test
+import { resolve } from "node:path";
 // ------------------------------------------------------------------------------------------------
 const getValue = (subscribable) => {
     let value;
@@ -80,6 +85,13 @@ const mockMessageLintRule = {
 const _import = async (name) => ({
     default: name === "plugin.js" ? mockPlugin : mockMessageLintRule,
 });
+async function openCiTestRepo() {
+    return await mockRepo({
+        fromSnapshot: JSON.parse(readFileSync(resolve(__dirname, "../mocks/ci-test-repo-no-shallow.json"), {
+            encoding: "utf-8",
+        })),
+    });
+}
 // ------------------------------------------------------------------------------------------------
 /**
  * Dear Developers,
@@ -89,15 +101,17 @@ const _import = async (name) => ({
  */
 it("should throw if a project (path) does not have a name", async () => {
     const fs = createNodeishMemoryFs();
+    const repo = await openRepository("file://", { nodeishFs: fs });
     const project = await tryCatch(() => loadProject({
         projectPath: "/source-code/.inlang",
-        nodeishFs: fs,
+        repo,
         _import,
     }));
     expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
 });
 it("should throw if a project path does not end with .inlang", async () => {
     const fs = createNodeishMemoryFs();
+    const repo = await openRepository("file://", { nodeishFs: fs });
     const invalidPaths = [
         "/source-code/frontend.inlang/settings",
         "/source-code/frontend.inlang/settings.json",
@@ -106,7 +120,7 @@ it("should throw if a project path does not end with .inlang", async () => {
     for (const invalidPath of invalidPaths) {
         const project = await tryCatch(() => loadProject({
             projectPath: invalidPath,
-            nodeishFs: fs,
+            repo,
             _import,
         }));
         expect(project.error).toBeInstanceOf(LoadProjectInvalidArgument);
@@ -115,16 +129,17 @@ 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 result = await tryCatch(() => loadProject({
             projectPath: "relative/path",
-            nodeishFs: fs,
+            repo,
             _import,
         }));
         expect(result.error).toBeInstanceOf(LoadProjectInvalidArgument);
         expect(result.data).toBeUndefined();
     });
     it("should generate projectId on missing projectid", async () => {
-        const repo = await mockRepo();
+        const repo = await openCiTestRepo();
         const existing = await repo.nodeishFs
             .readFile("/project.inlang/project_id", {
             encoding: "utf-8",
@@ -136,7 +151,6 @@ describe("initialization", () => {
         expect(existing.error.code).toBe("ENOENT");
         const result = await tryCatch(() => loadProject({
             projectPath: "/project.inlang",
-            nodeishFs: repo.nodeishFs,
             repo,
             _import,
         }));
@@ -147,16 +161,15 @@ describe("initialization", () => {
             .catch((error) => {
             return { error };
         });
-        expect(newId).toBe("7cd6c2b7cf12febf99496408917123fdfe158b6bc442914f5fb42aa74346bd50");
+        expect(newId).toBe("aef225403be8b526dfb492a4617fd59d8181e8fef2c7f4aff56ab299046e36ed");
         expect(result.error).toBeUndefined();
         expect(result.data).toBeDefined();
     });
     it("should reuse projectId on existing projectid", async () => {
-        const repo = await mockRepo();
+        const repo = await openCiTestRepo();
         repo.nodeishFs.writeFile("/project.inlang/project_id", "testId");
         const result = await tryCatch(() => loadProject({
             projectPath: "/project.inlang",
-            nodeishFs: repo.nodeishFs,
             repo,
             _import,
         }));
@@ -175,9 +188,10 @@ describe("initialization", () => {
         const fs = createNodeishMemoryFs();
         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({
             projectPath: "C:\\Users\\user\\project.inlang",
-            nodeishFs: fs,
+            repo,
             _import,
         }));
         expect(result.error).toBeUndefined();
@@ -187,9 +201,10 @@ describe("initialization", () => {
         it("should return an error if settings file is not found", async () => {
             const fs = createNodeishMemoryFs();
             fs.mkdir("/user/project", { recursive: true });
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const project = await loadProject({
                 projectPath: "/user/non-existend-project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileNotFoundError);
@@ -198,9 +213,10 @@ describe("initialization", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsFileJSONSyntaxError);
@@ -209,9 +225,10 @@ describe("initialization", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()[0]).toBeInstanceOf(ProjectSettingsInvalidError);
@@ -220,9 +237,10 @@ describe("initialization", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.settings()).toStrictEqual(settings);
@@ -232,9 +250,10 @@ describe("initialization", () => {
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             const settingsOnDisk = await fs.readFile("/user/project.inlang/settings.json", {
@@ -258,9 +277,10 @@ describe("initialization", () => {
             const fs = createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import: $badImport,
             });
             expect(project.errors()).not.toHaveLength(0);
@@ -286,9 +306,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(getValue(project.settings)).toStrictEqual(settings);
@@ -297,9 +318,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.settings()).toStrictEqual(settings);
@@ -319,9 +341,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             const result = project.setSettings({});
@@ -337,9 +360,10 @@ describe("functionality", () => {
                 modules: [],
             };
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.errors()).toHaveLength(1);
@@ -349,9 +373,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             const before = await fs.readFile("/user/project.inlang/settings.json", { encoding: "utf-8" });
@@ -376,9 +401,10 @@ 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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.installed.plugins()[0]).toStrictEqual({
@@ -404,9 +430,10 @@ 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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(project.installed.messageLintRules()[0]?.level).toBe("warning");
@@ -439,6 +466,7 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             }));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const _import = async (name) => {
                 return {
                     default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
@@ -446,7 +474,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             await new Promise((resolve) => setTimeout(resolve, 510));
@@ -481,6 +509,7 @@ describe("functionality", () => {
                 languageTags: ["en"],
                 modules: ["plugin.js", "lintRule.js"],
             }));
+            const repo = await openRepository("file://", { nodeishFs: fs });
             const _import = async (name) => {
                 return {
                     default: name === "plugin.js" ? _mockPlugin : _mockLintRule,
@@ -488,7 +517,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             await new Promise((resolve) => setTimeout(resolve, 510));
@@ -500,9 +529,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             project.errors.subscribe((errors) => {
@@ -515,9 +545,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             project.customApi.subscribe((api) => {
@@ -530,9 +561,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             expect(Object.values(project.query.messages.getAll())).toEqual(exampleMessages);
@@ -552,6 +584,7 @@ describe("functionality", () => {
             await fs.mkdir("/user/project.inlang", { recursive: true });
             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();
             const _mockPlugin = {
                 id: "plugin.project.json",
@@ -567,7 +600,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/user/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             await project.query.messages.upsert({
@@ -713,6 +746,7 @@ 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();
             const _mockPlugin = {
                 id: "plugin.placeholder.name",
@@ -732,7 +766,7 @@ describe("functionality", () => {
             };
             const project = await loadProject({
                 projectPath: "/project.inlang",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             project.query.messages.create({ data: createMessage("fourth", { en: "fourth message" }) });
@@ -746,9 +780,10 @@ describe("functionality", () => {
             const fs = await createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import,
             });
             // TODO: test with real lint rules
@@ -769,9 +804,10 @@ describe("functionality", () => {
             const fs = createNodeishMemoryFs();
             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",
-                nodeishFs: fs,
+                repo,
                 _import: async () => ({
                     default: mockMessageLintRule,
                 }),
@@ -826,10 +862,11 @@ 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({
                 projectPath: normalizePath("/project.inlang"),
-                nodeishFs: fs,
+                repo,
                 _import: async () => ({
                     default: mockMessageFormatPlugin,
                 }),

package/dist/migrations/maybeCreateFirstProjectId.d.ts

@@ -0,0 +1,16 @@
+import type { Repository } from "@lix-js/client";
+/**
+ * Creates a project id if it does not exist yet.
+ *
+ * - this is a migration to ensure that all projects have a project id
+ * - new projects are created with a project id (in the future)
+ */
+export declare function maybeCreateFirstProjectId(args: {
+    projectPath: string;
+    repo?: Repository;
+}): Promise<void>;
+export declare function generateProjectId(args: {
+    repo?: Repository;
+    projectPath: string;
+}): Promise<string | undefined>;
+//# sourceMappingURL=maybeCreateFirstProjectId.d.ts.map

package/dist/migrations/maybeCreateFirstProjectId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybeCreateFirstProjectId.d.ts","sourceRoot":"","sources":["../../src/migrations/maybeCreateFirstProjectId.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACrD,WAAW,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,UAAU,CAAA;CACjB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkBhB;AAED,wBAAsB,iBAAiB,CAAC,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,+BAUvF"}

package/dist/migrations/maybeCreateFirstProjectId.js

@@ -0,0 +1,37 @@
+import { hash } from "@lix-js/client";
+/**
+ * Creates a project id if it does not exist yet.
+ *
+ * - this is a migration to ensure that all projects have a project id
+ * - new projects are created with a project id (in the future)
+ */
+export async function maybeCreateFirstProjectId(args) {
+    // the migration assumes a repository
+    if (args.repo === undefined) {
+        return;
+    }
+    try {
+        await args.repo.nodeishFs.readFile(args.projectPath + "/project_id", {
+            encoding: "utf-8",
+        });
+    }
+    catch (error) {
+        // @ts-ignore
+        if (error.code === "ENOENT" && args.repo) {
+            const projectId = await generateProjectId({ repo: args.repo, projectPath: args.projectPath });
+            if (projectId) {
+                await args.repo.nodeishFs.writeFile(args.projectPath + "/project_id", projectId);
+            }
+        }
+    }
+}
+export async function generateProjectId(args) {
+    if (!args.repo || !args.projectPath) {
+        return undefined;
+    }
+    const firstCommitHash = await args.repo.getFirstCommitHash();
+    if (firstCommitHash) {
+        return hash(`${firstCommitHash + args.projectPath}`);
+    }
+    return undefined;
+}

package/dist/migrations/maybeCreateFirstProjectId.test.d.ts

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

package/dist/migrations/maybeCreateFirstProjectId.test.d.ts.map

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

package/dist/migrations/maybeCreateFirstProjectId.test.js

@@ -0,0 +1,27 @@
+import { generateProjectId } from "./maybeCreateFirstProjectId.js";
+import { it, expect } from "vitest";
+import { openRepository } from "@lix-js/client/src/openRepository.ts";
+import { mockRepo, createNodeishMemoryFs } from "@lix-js/client";
+import {} from "@lix-js/fs";
+// eslint-disable-next-line no-restricted-imports -- test
+import { readFileSync } from "node:fs";
+const ciTestRepo = JSON.parse(readFileSync("./mocks/ci-test-repo-no-shallow.json", { encoding: "utf-8" }));
+const repo = await mockRepo({ fromSnapshot: ciTestRepo });
+it("should return if repo is undefined", async () => {
+    const projectId = await generateProjectId({ repo: undefined, projectPath: "mocked_project_path" });
+    expect(projectId).toBeUndefined();
+});
+it("should generate a project id", async () => {
+    const projectId = await generateProjectId({ repo, projectPath: "mocked_project_path" });
+    expect(projectId).toBe("432d7ef29c510e99d95e2d14ef57a0797a1603859b5a851b7dff7e77161b8c08");
+});
+it("should return undefined if repoMeta contains error", async () => {
+    const repoWithError = await openRepository("https://github.com/inlang/no-exist", {
+        nodeishFs: createNodeishMemoryFs(),
+    });
+    const projectId = await generateProjectId({
+        repo: repoWithError,
+        projectPath: "mocked_project_path",
+    });
+    expect(projectId).toBeUndefined();
+});

package/dist/migrations/migrateToDirectory.d.ts

@@ -1,7 +1,7 @@
 import type { NodeishFilesystem } from "@lix-js/fs";
 /**
  * Migrates to the new project directory structure
- * https://github.com/inlang/monorepo/issues/1678
+ * https://github.com/opral/monorepo/issues/1678
  */
 export declare const maybeMigrateToDirectory: (args: {
     nodeishFs: NodeishFilesystem;

package/dist/migrations/migrateToDirectory.js

@@ -1,7 +1,7 @@
 import { tryCatch } from "@inlang/result";
 /**
  * Migrates to the new project directory structure
- * https://github.com/inlang/monorepo/issues/1678
+ * https://github.com/opral/monorepo/issues/1678
  */
 export const maybeMigrateToDirectory = async (args) => {
     // the migration assumes that the projectPath ends with project.inlang
@@ -38,9 +38,9 @@ The \`project.inlang.json\` file is now contained in a project directory e.g. \`
 ## Why is this happening?
 
 See this RFC https://docs.google.com/document/d/1OYyA1wYfQRbIJOIBDliYoWjiUlkFBNxH_U2R4WpVRZ4/edit#heading=h.pecv6xb7ial6 
-and the following GitHub issue for more information https://github.com/inlang/monorepo/issues/1678.
+and the following GitHub issue for more information https://github.com/opral/monorepo/issues/1678.
 
-- Monorepo support https://github.com/inlang/monorepo/discussions/258. 
+- Monorepo support https://github.com/opral/monorepo/discussions/258. 
 - Required for many other future features like caching, first class offline support, and more. 
 - Stablize the inlang project format.
 `;

package/dist/telemetry/capture.d.ts

@@ -0,0 +1,21 @@
+/**
+ * List of telemetry events for typesafety.
+ *
+ * - prefix with `SDK` to avoid collisions with other apps
+ * - use past tense to indicate that the event is completed
+ */
+declare const events: readonly ["SDK loaded project"];
+/**
+ * Capture an event.
+ *
+ * - manually calling the PostHog API because the SDKs were not platform angostic (and generally bloated)
+ */
+export declare const capture: (event: (typeof events)[number], args: {
+    projectId: string;
+    /**
+     * Please use snake_case for property names.
+     */
+    properties: Record<string, any>;
+}) => Promise<void>;
+export {};
+//# sourceMappingURL=capture.d.ts.map

package/dist/telemetry/capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../src/telemetry/capture.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,QAAA,MAAM,MAAM,iCAAkC,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,OAAO,UACZ,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,QACxB;IACL,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,UAAU,EAAE,OAAO,MAAM,EAAE,GAAG,CAAC,CAAA;CAC/B,kBAyBD,CAAA"}

package/dist/telemetry/capture.js

@@ -0,0 +1,39 @@
+import { ENV_VARIABLES } from "../env-variables/index.js";
+/**
+ * List of telemetry events for typesafety.
+ *
+ * - prefix with `SDK` to avoid collisions with other apps
+ * - use past tense to indicate that the event is completed
+ */
+const events = ["SDK loaded project"];
+/**
+ * Capture an event.
+ *
+ * - manually calling the PostHog API because the SDKs were not platform angostic (and generally bloated)
+ */
+export const capture = async (event, args) => {
+    // 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,
+                // id is "unknown" because no user information is available
+                distinct_id: "unknown",
+                properties: {
+                    $groups: { project: args.projectId },
+                    ...args.properties,
+                },
+            }),
+        });
+    }
+    catch (e) {
+        // TODO implement sentry logging
+        // do not console.log and avoid exposing internal errors to the user
+    }
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/sdk",
   "type": "module",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public"
@@ -26,16 +26,16 @@
     "solid-js": "1.6.12",
     "throttle-debounce": "^5.0.0",
     "@inlang/json-types": "1.1.0",
-    "@inlang/language-tag": "1.3.0",
-    "@inlang/message-lint-rule": "1.4.0",
-    "@inlang/message": "2.0.0",
-    "@inlang/module": "1.2.1",
-    "@inlang/plugin": "2.4.1",
-    "@inlang/project-settings": "2.2.0",
+    "@inlang/language-tag": "1.4.0",
+    "@inlang/message": "2.0.1",
+    "@inlang/message-lint-rule": "1.4.1",
+    "@inlang/module": "1.2.3",
+    "@inlang/plugin": "2.4.3",
     "@inlang/result": "1.1.0",
-    "@inlang/translatable": "1.2.0",
-    "@lix-js/client": "0.5.0",
-    "@lix-js/fs": "0.5.0"
+    "@inlang/translatable": "1.2.1",
+    "@inlang/project-settings": "2.2.1",
+    "@lix-js/fs": "0.6.0",
+    "@lix-js/client": "0.6.0"
   },
   "devDependencies": {
     "@types/throttle-debounce": "5.0.0",
@@ -47,8 +47,9 @@
     "vitest": "^0.33.0"
   },
   "scripts": {
-    "build": "tsc --build",
-    "dev": "tsc --watch",
+    "build": "npm run prepare-env-variables && tsc --build",
+    "dev": "npm run prepare-env-variables && tsc --watch",
+    "prepare-env-variables": "node ./src/env-variables/createIndexFile.js",
     "test": "tsc --noEmit && vitest run --passWithNoTests --coverage",
     "lint": "eslint ./src --fix",
     "format": "prettier ./src --write",