@embeddable.com/sdk-core 3.9.2 → 3.9.4

package/lib/logger.d.ts

@@ -0,0 +1,9 @@
+export declare const ERROR_LOG_FILE: string;
+interface LogErrorParams {
+    command: string;
+    breadcrumbs: string[];
+    error: unknown;
+}
+export declare function initLogger(command: string): Promise<void>;
+export declare function logError({ command, breadcrumbs, error, }: LogErrorParams): Promise<void>;
+export {};

package/lib/utils.d.ts

@@ -20,4 +20,5 @@ export declare const removeBuildSuccessFlag: () => Promise<void>;
  * Check if the build was successful
  */
 export declare const checkBuildSuccess: () => Promise<boolean>;
-export declare const getPackageVersion: (packageName: string) => any;
+export declare const getSDKVersions: () => Record<string, string>;
+export declare const hrtimeToISO8601: (hrtime: number[] | null | undefined) => String;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "3.9.2",
+  "version": "3.9.4",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",

package/src/build.test.ts

@@ -5,11 +5,17 @@ import buildTypes from "./buildTypes";
 import provideConfig from "./provideConfig";
 import generate from "./generate";
 import cleanup from "./cleanup";
+import { initLogger, logError } from "./logger";
 
 // @ts-ignore
 import reportErrorToRollbar from "./rollbar.mjs";
 import { storeBuildSuccessFlag } from "./utils";
 
+vi.mock("./logger", () => ({
+  initLogger: vi.fn().mockResolvedValue(undefined),
+  logError: vi.fn().mockResolvedValue(undefined),
+}));
+
 const mockPlugin = {
   validate: vi.fn(),
   build: vi.fn(),

package/src/build.ts

@@ -11,10 +11,16 @@ import {
   removeBuildSuccessFlag,
   storeBuildSuccessFlag,
 } from "./utils";
+import { initLogger, logError } from "./logger";
 
 export default async () => {
+  await initLogger("build");
+  const breadcrumbs: string[] = [];
+
   try {
+    const startTime = process.hrtime();
     checkNodeVersion();
+    breadcrumbs.push("checkNodeVersion");
     removeBuildSuccessFlag();
 
     const config = await provideConfig();
@@ -28,16 +34,24 @@ export default async () => {
     for (const getPlugin of config.plugins) {
       const plugin = getPlugin();
 
+      breadcrumbs.push(`${plugin.pluginName}: validate`);
       await plugin.validate(config);
+      breadcrumbs.push(`${plugin.pluginName}: build`);
       await plugin.build(config);
+      breadcrumbs.push(`${plugin.pluginName}: cleanup`);
       await plugin.cleanup(config);
     }
 
     // NOTE: likely this will be called inside the loop above if we decide to support clients with mixed frameworks simultaneously.
+    breadcrumbs.push("generate");
     await generate(config, "sdk-react");
+    // Calculating build time in seconds
+    config.buildTime = process.hrtime(startTime);
+    breadcrumbs.push("cleanup");
     await cleanup(config);
     await storeBuildSuccessFlag();
   } catch (error: any) {
+    await logError({ command: "build", breadcrumbs, error });
     await reportErrorToRollbar(error);
     console.log(error);
     process.exit(1);

package/src/cleanup.test.ts

@@ -9,6 +9,7 @@ const ctx = {
     stencilBuild: "stencilBuild",
     buildDir: "buildDir",
   },
+  buildTime: [80, 525000],
 };
 
 vi.mock("node:fs/promises", () => ({
@@ -77,6 +78,9 @@ describe("cleanup", () => {
             sdkVersions: {},
             packageManager: "npm",
             packageManagerVersion: "10.7.0",
+            metrics: {
+              buildTime: "PT1M20.001S",
+            },
           },
         }),
       );

package/src/cleanup.ts

@@ -1,7 +1,7 @@
 import { findFiles } from "@embeddable.com/sdk-utils";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { getPackageVersion } from "./utils";
+import { getSDKVersions, hrtimeToISO8601 } from "./utils";
 
 export default async (ctx: any) => {
   await extractBuild(ctx);
@@ -26,24 +26,7 @@ export async function createManifest({
   editorsMetaFileName,
   stencilWrapperFileName,
 }: ManifestArgs) {
-  const packageNames = [
-    "@embeddable.com/core",
-    "@embeddable.com/react",
-    "@embeddable.com/sdk-core",
-    "@embeddable.com/sdk-react",
-    "@embeddable.com/sdk-utils",
-  ];
-
-  const sdkVersions = packageNames.reduce<Record<string, string>>(
-    (acc, packageName) => {
-      const version = getPackageVersion(packageName);
-      if (version) {
-        acc[packageName] = version;
-      }
-      return acc;
-    },
-    {},
-  );
+  const sdkVersions = getSDKVersions();
   // identify user's package manager and its version
   let packageManager = "npm";
   if (process.env.npm_config_user_agent?.includes("yarn")) {
@@ -72,6 +55,9 @@ export async function createManifest({
       sdkVersions,
       packageManager,
       packageManagerVersion,
+      metrics: {
+        buildTime: hrtimeToISO8601(ctx.buildTime),
+      },
     },
   };
 

package/src/dev.test.ts

@@ -9,6 +9,7 @@ import { checkNodeVersion } from "./utils";
 import { createManifest } from "./cleanup";
 import prepare from "./prepare";
 import { WebSocketServer } from "ws";
+import { initLogger, logError } from "./logger";
 
 // Mock dependencies
 vi.mock("./buildTypes", () => ({ default: vi.fn() }));
@@ -31,6 +32,10 @@ vi.mock("./cleanup", () => ({ createManifest: vi.fn() }));
 vi.mock("node:http", () => ({
   createServer: vi.fn(() => ({ listen: vi.fn() })),
 }));
+vi.mock("./logger", () => ({
+  initLogger: vi.fn(),
+  logError: vi.fn(),
+}));
 
 const mockConfig = {
   client: {
@@ -100,4 +105,24 @@ describe("dev command", () => {
 
     await expect.poll(() => chokidar.watch).toBeCalledTimes(2);
   });
+
+  it("should log errors and exit on failure", async () => {
+    const error = new Error("Test error");
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    vi.mocked(checkNodeVersion).mockImplementation(() => {
+      throw error;
+    });
+
+    await expect(dev()).rejects.toThrow("process.exit");
+
+    expect(logError).toHaveBeenCalledWith({
+      command: "dev",
+      breadcrumbs: ["run dev"],
+      error,
+    });
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
 });

package/src/dev.ts

@@ -28,6 +28,7 @@ import { createManifest } from "./cleanup";
 import { selectWorkspace } from "./workspaceUtils";
 import * as fs from "fs";
 const minimist = require("minimist");
+import { initLogger, logError } from "./logger";
 
 const oraP = import("ora");
 let wss: WSServer;
@@ -69,132 +70,152 @@ const chokidarWatchOptions = {
 };
 
 export default async () => {
-  checkNodeVersion();
-  addToGitingore();
+  await initLogger("dev");
+  const breadcrumbs: string[] = [];
 
-  ora = (await oraP).default;
+  try {
+    breadcrumbs.push("run dev");
+    checkNodeVersion();
+    addToGitingore();
 
-  process.on("warning", (e) => console.warn(e.stack));
+    ora = (await oraP).default;
 
-  const logger = createNodeLogger();
-  const sys = createNodeSys({ process });
+    process.on("warning", (e) => console.warn(e.stack));
 
-  const defaultConfig = await provideConfig();
+    const logger = createNodeLogger();
+    const sys = createNodeSys({ process });
 
-  const buildDir = path.resolve(defaultConfig.client.rootDir, BUILD_DEV_DIR);
+    const defaultConfig = await provideConfig();
 
-  const config = {
-    ...defaultConfig,
-    dev: {
-      watch: true,
-      logger,
-      sys,
-    },
-    client: {
-      ...defaultConfig.client,
-      buildDir,
-      componentDir: path.resolve(buildDir, "component"),
-      stencilBuild: path.resolve(buildDir, "dist", "embeddable-wrapper"),
-      tmpDir: path.resolve(defaultConfig.client.rootDir, ".embeddable-dev-tmp"),
-    },
-  };
+    const buildDir = path.resolve(defaultConfig.client.rootDir, BUILD_DEV_DIR);
 
-  await prepare(config);
+    const config = {
+      ...defaultConfig,
+      dev: {
+        watch: true,
+        logger,
+        sys,
+      },
+      client: {
+        ...defaultConfig.client,
+        buildDir,
+        componentDir: path.resolve(buildDir, "component"),
+        stencilBuild: path.resolve(buildDir, "dist", "embeddable-wrapper"),
+        tmpDir: path.resolve(
+          defaultConfig.client.rootDir,
+          ".embeddable-dev-tmp",
+        ),
+      },
+    };
 
-  const finalhandler = require("finalhandler");
-  const serveStatic = require("serve-static");
+    breadcrumbs.push("prepare config");
+    await prepare(config);
 
-  const serve = serveStatic(config.client.buildDir);
+    const finalhandler = require("finalhandler");
+    const serveStatic = require("serve-static");
 
-  const workspacePreparation = ora("Preparing workspace...").start();
+    const serve = serveStatic(config.client.buildDir);
 
-  try {
-    previewWorkspace = await getPreviewWorkspace(workspacePreparation, config);
-  } catch (e: any) {
-    workspacePreparation.fail(
-      e.response?.data?.errorMessage || "Unknown error: " + e.message,
-    );
-    process.exit(1);
-  }
+    const workspacePreparation = ora("Preparing workspace...").start();
 
-  workspacePreparation.succeed("Workspace is ready");
-
-  const server = http.createServer(
-    (request: IncomingMessage, res: ServerResponse) => {
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      res.setHeader(
-        "Access-Control-Allow-Methods",
-        "GET, POST, PUT, DELETE, OPTIONS",
+    breadcrumbs.push("get preview workspace");
+    try {
+      previewWorkspace = await getPreviewWorkspace(
+        workspacePreparation,
+        config,
       );
-      res.setHeader(
-        "Access-Control-Allow-Headers",
-        "Content-Type, Authorization",
+    } catch (e: any) {
+      workspacePreparation.fail(
+        e.response?.data?.errorMessage || "Unknown error: " + e.message,
       );
+      process.exit(1);
+    }
 
-      if (request.method === "OPTIONS") {
-        // Respond to OPTIONS requests with just the CORS headers and a 200 status code
-        res.writeHead(200);
-        res.end();
-        return;
-      }
-
-      const done = finalhandler(request, res);
-
-      try {
-        if (request.url?.endsWith(GLOBAL_CSS)) {
-          res.writeHead(200, { "Content-Type": "text/css" });
-          res.end(fs.readFileSync(config.client.globalCss));
+    workspacePreparation.succeed("Workspace is ready");
+
+    const server = http.createServer(
+      (request: IncomingMessage, res: ServerResponse) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader(
+          "Access-Control-Allow-Methods",
+          "GET, POST, PUT, DELETE, OPTIONS",
+        );
+        res.setHeader(
+          "Access-Control-Allow-Headers",
+          "Content-Type, Authorization",
+        );
+
+        if (request.method === "OPTIONS") {
+          // Respond to OPTIONS requests with just the CORS headers and a 200 status code
+          res.writeHead(200);
+          res.end();
           return;
         }
-      } catch {}
 
-      serve(request, res, done);
-    },
-  );
+        const done = finalhandler(request, res);
 
-  wss = new WebSocketServer({ server });
+        try {
+          if (request.url?.endsWith(GLOBAL_CSS)) {
+            res.writeHead(200, { "Content-Type": "text/css" });
+            res.end(fs.readFileSync(config.client.globalCss));
+            return;
+          }
+        } catch {}
 
-  server.listen(SERVER_PORT, async () => {
-    const watchers: Array<RollupWatcher | FSWatcher> = [];
-    if (sys?.onProcessInterrupt) {
-      sys.onProcessInterrupt(
-        async () => await onClose(server, sys, watchers, config),
-      );
-    }
-
-    await createManifest({
-      ctx: {
-        ...config,
-        client: {
-          ...config.client,
-          tmpDir: buildDir,
-        },
+        serve(request, res, done);
       },
-      typesFileName: "embeddable-types.js",
-      stencilWrapperFileName: "embeddable-wrapper.js",
-      metaFileName: "embeddable-components-meta.js",
-      editorsMetaFileName: "embeddable-editors-meta.js",
-    });
-
-    await sendDataModelsAndSecurityContextsChanges(config);
+    );
 
-    for (const getPlugin of config.plugins) {
-      const plugin = getPlugin();
+    wss = new WebSocketServer({ server });
 
-      await plugin.validate(config);
-      const watcher = await plugin.build(config);
+    server.listen(SERVER_PORT, async () => {
+      const watchers: Array<RollupWatcher | FSWatcher> = [];
+      if (sys?.onProcessInterrupt) {
+        sys.onProcessInterrupt(
+          async () => await onClose(server, sys, watchers, config),
+        );
+      }
 
-      await configureWatcher(watcher, config);
-      watchers.push(watcher);
-    }
+      breadcrumbs.push("create manifest");
+      await createManifest({
+        ctx: {
+          ...config,
+          client: {
+            ...config.client,
+            tmpDir: buildDir,
+          },
+        },
+        typesFileName: "embeddable-types.js",
+        stencilWrapperFileName: "embeddable-wrapper.js",
+        metaFileName: "embeddable-components-meta.js",
+        editorsMetaFileName: "embeddable-editors-meta.js",
+      });
+
+      await sendDataModelsAndSecurityContextsChanges(config);
+
+      for (const getPlugin of config.plugins) {
+        const plugin = getPlugin();
+
+        breadcrumbs.push("validate plugin");
+        await plugin.validate(config);
+        breadcrumbs.push("build plugin");
+        const watcher = await plugin.build(config);
+        breadcrumbs.push("configure watcher");
+        await configureWatcher(watcher, config);
+        watchers.push(watcher);
+      }
 
-    const dataModelAndSecurityContextWatch =
-      dataModelAndSecurityContextWatcher(config);
+      const dataModelAndSecurityContextWatch =
+        dataModelAndSecurityContextWatcher(config);
 
-    const customGlobalCssWatch = globalCssWatcher(config);
-    watchers.push(dataModelAndSecurityContextWatch);
-    watchers.push(customGlobalCssWatch);
-  });
+      const customGlobalCssWatch = globalCssWatcher(config);
+      watchers.push(dataModelAndSecurityContextWatch);
+      watchers.push(customGlobalCssWatch);
+    });
+  } catch (error: any) {
+    await logError({ command: "dev", breadcrumbs, error });
+    process.exit(1);
+  }
 };
 
 const configureWatcher = async (watcher: RollupWatcher, ctx: any) => {

package/src/logger.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { initLogger, logError, ERROR_LOG_FILE } from "./logger";
+import * as fs from "node:fs/promises";
+
+vi.mock("fs/promises", () => ({
+  readFile: vi.fn(),
+  appendFile: vi.fn(),
+  access: vi.fn(),
+  mkdir: vi.fn(),
+}));
+
+describe("Logger", () => {
+  describe("initLogger", () => {
+    it("should create log directory if it does not exist", async () => {
+      await initLogger("test");
+      expect(fs.mkdir).toHaveBeenCalledWith(
+        expect.stringContaining(".embeddable/logs"),
+        { recursive: true },
+      );
+    });
+
+    it("should handle errors when creating log directory", async () => {
+      const consoleErrorSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      vi.mocked(fs.mkdir).mockRejectedValueOnce(
+        new Error("Failed to create directory"),
+      );
+
+      await initLogger("test");
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        "Failed to create log directory:",
+        expect.any(Error),
+      );
+    });
+  });
+
+  describe("logError", () => {
+    it("should append error message to log file", async () => {
+      const error = new Error("Test error");
+      await logError({
+        command: "test",
+        breadcrumbs: ["step1", "step2"],
+        error,
+      });
+
+      expect(fs.appendFile).toHaveBeenCalledWith(
+        ERROR_LOG_FILE,
+        expect.stringContaining(
+          "Command: test\nBreadcrumbs: step1 > step2\nError: Error: Test error",
+        ),
+      );
+    });
+
+    it("should handle non-Error objects", async () => {
+      await logError({
+        command: "test",
+        breadcrumbs: ["step1"],
+        error: "String error",
+      });
+
+      expect(fs.appendFile).toHaveBeenCalledWith(
+        ERROR_LOG_FILE,
+        expect.stringContaining(
+          "Command: test\nBreadcrumbs: step1\nError: String error",
+        ),
+      );
+    });
+
+    it("should log to console when error occurs", async () => {
+      const consoleErrorSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      await logError({ command: "test", breadcrumbs: [], error: "Test error" });
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining("An error occurred during test"),
+      );
+    });
+
+    it("should handle errors when writing to log file", async () => {
+      const consoleErrorSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      vi.mocked(fs.appendFile).mockRejectedValueOnce(
+        new Error("Failed to write"),
+      );
+
+      await logError({ command: "test", breadcrumbs: [], error: "Test error" });
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        "Failed to write to log file:",
+        expect.any(Error),
+      );
+    });
+  });
+});

package/src/logger.ts

@@ -0,0 +1,116 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getSDKVersions } from "./utils";
+
+const LOG_DIR = path.join(process.cwd(), ".embeddable", "logs");
+export const ERROR_LOG_FILE = path.join(LOG_DIR, "error.log");
+const MAX_LOG_SIZE = 5 * 1024 * 1024; // 5 MB
+const MAX_LOG_FILES = 5;
+
+interface LogEntry {
+  timestamp: string;
+  command: string;
+  breadcrumbs: string[];
+  error: string;
+}
+
+interface LogErrorParams {
+  command: string;
+  breadcrumbs: string[];
+  error: unknown;
+}
+
+export async function initLogger(command: string) {
+  try {
+    await fs.mkdir(LOG_DIR, { recursive: true });
+  } catch (error) {
+    console.error("Failed to create log directory:", error);
+  }
+
+  setupGlobalErrorHandlers(command);
+}
+
+export async function logError({
+  command,
+  breadcrumbs,
+  error,
+}: LogErrorParams) {
+  const sdkVersions = getSDKVersions();
+  const logEntry: LogEntry = {
+    timestamp: new Date().toISOString(),
+    command,
+    breadcrumbs,
+    error:
+      error instanceof Error
+        ? `${error.name}: ${error.message}\n${error.stack}`
+        : String(error),
+  };
+
+  const logMessage = `
+[${logEntry.timestamp}] Command: ${logEntry.command}
+Breadcrumbs: ${logEntry.breadcrumbs.join(" > ")}
+Error: ${logEntry.error}
+OS: ${process.platform}
+Node: ${process.version}
+SDK Versions: ${JSON.stringify(sdkVersions, null, 2)}
+----------------------------------------
+`;
+
+  try {
+    await rotateLogIfNeeded();
+    await fs.appendFile(ERROR_LOG_FILE, logMessage);
+    console.error(
+      `An error occurred during ${command}. Check the log file for details: ${ERROR_LOG_FILE}`,
+    );
+  } catch (error) {
+    console.error("Failed to write to log file:", error);
+  }
+}
+
+async function rotateLogIfNeeded() {
+  try {
+    const stats = await fs.stat(ERROR_LOG_FILE);
+    if (stats.size < MAX_LOG_SIZE) {
+      return;
+    }
+
+    for (let i = MAX_LOG_FILES - 1; i > 0; i--) {
+      const oldFile = `${ERROR_LOG_FILE}.${i}`;
+      const newFile = `${ERROR_LOG_FILE}.${i + 1}`;
+      try {
+        await fs.rename(oldFile, newFile);
+      } catch (error) {
+        // Ignore error if file doesn't exist
+      }
+    }
+
+    await fs.rename(ERROR_LOG_FILE, `${ERROR_LOG_FILE}.1`);
+    await fs.writeFile(ERROR_LOG_FILE, ""); // Create a new empty log file
+  } catch (error: any) {
+    if (error.code !== "ENOENT") {
+      console.error("Error rotating log file:", error);
+    }
+  }
+}
+
+function setupGlobalErrorHandlers(command: string) {
+  process.on("uncaughtException", async (error) => {
+    await logError({ command, breadcrumbs: ["uncaughtException"], error });
+    console.error(
+      "An uncaught error occurred. Check the log file for details.",
+    );
+    process.exit(1);
+  });
+
+  process.on("unhandledRejection", async (reason) => {
+    await logError({
+      command,
+      breadcrumbs: ["unhandledRejection"],
+      error: reason as Error | string,
+    });
+    console.error(
+      "An unhandled rejection occurred. Check the log file for details.",
+    );
+    process.exit(1);
+  });
+}

package/src/login.test.ts

@@ -8,6 +8,11 @@ import { CREDENTIALS_DIR, CREDENTIALS_FILE } from "./credentials";
 import { http, HttpResponse } from "msw";
 import { AxiosError } from "axios";
 
+vi.mock("./logger", () => ({
+  initLogger: vi.fn(),
+  logError: vi.fn(),
+}));
+
 vi.mock("fs/promises", () => ({
   readFile: vi.fn(),
   writeFile: vi.fn(),