@embeddable.com/sdk-core 2.6.0-next.2 → 2.6.0-next.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@embeddable.com/sdk-core",
-  "version": "2.6.0-next.2",
+  "version": "2.6.0-next.3",
   "description": "Core Embeddable SDK module responsible for web-components bundling and publishing.",
   "keywords": [
     "embeddable",
@@ -21,6 +21,7 @@
   "author": "Embeddable.com <engineering@embeddable.com>",
   "files": [
     "bin/",
+    "src/",
     "lib/",
     "loader/",
     "templates/",

package/src/build.ts

@@ -0,0 +1,38 @@
+import buildTypes from "./buildTypes";
+import prepare from "./prepare";
+import generate from "./generate";
+import cleanup from "./cleanup";
+import validate from "./validate";
+import provideConfig from "./provideConfig";
+// @ts-ignore
+import reportErrorToRollbar from "./rollbar.mjs";
+import { checkNodeVersion } from "./utils";
+
+export default async () => {
+  try {
+    checkNodeVersion();
+    const config = await provideConfig();
+
+    await validate(config);
+
+    await prepare(config);
+
+    await buildTypes(config);
+
+    for (const getPlugin of config.plugins) {
+      const plugin = getPlugin();
+
+      await plugin.validate(config);
+      await plugin.build(config);
+      await plugin.cleanup(config);
+    }
+
+    // NOTE: likely this will be called inside the loop above if we decide to support clients with mixed frameworks simultaneously.
+    await generate(config, "sdk-react");
+    await cleanup(config);
+  } catch (error: any) {
+    await reportErrorToRollbar(error);
+    console.log(error);
+    process.exit(1);
+  }
+};

package/src/buildTypes.ts

@@ -0,0 +1,69 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as vite from "vite";
+const oraP = import("ora");
+import { findFiles } from "@embeddable.com/sdk-utils";
+
+export const EMB_TYPE_FILE_REGEX = /^(.*)\.type\.emb\.[jt]s$/;
+export const EMB_OPTIONS_FILE_REGEX = /^(.*)\.options\.emb\.[jt]s$/;
+
+export default async (ctx: any) => {
+  const ora = (await oraP).default;
+
+  const progress = ora("Building types...").start();
+
+  await generate(ctx);
+
+  await build(ctx);
+
+  await cleanup(ctx);
+
+  progress.succeed("Types built completed");
+};
+
+async function generate(ctx: any) {
+  const typeFiles = await findFiles(ctx.client.srcDir, EMB_TYPE_FILE_REGEX);
+  const optionsFiles = await findFiles(
+    ctx.client.srcDir,
+    EMB_OPTIONS_FILE_REGEX,
+  );
+
+  const typeImports = typeFiles
+    .concat(optionsFiles)
+    .map(
+      ([_fileName, filePath]) =>
+        `import './${path
+          .relative(ctx.client.rootDir, filePath)
+          .replaceAll("\\", "/")}';`,
+    )
+    .join("\n");
+
+  await fs.writeFile(
+    path.resolve(ctx.client.rootDir, ctx.outputOptions.typesEntryPointFilename),
+    typeImports,
+  );
+}
+
+async function build(ctx: any) {
+  await vite.build({
+    logLevel: "error",
+    build: {
+      emptyOutDir: false,
+      lib: {
+        entry: path.resolve(
+          ctx.client.rootDir,
+          ctx.outputOptions.typesEntryPointFilename,
+        ),
+        formats: ["es"],
+        fileName: "embeddable-types",
+      },
+      outDir: ctx.client.buildDir,
+    },
+  });
+}
+
+async function cleanup(ctx: any) {
+  await fs.rm(
+    path.resolve(ctx.client.rootDir, "embeddable-types-entry-point.js"),
+  );
+}

package/src/cleanup.ts

@@ -0,0 +1,40 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+
+export default async (ctx: any) => {
+  await extractBuild(ctx);
+
+  await removeObsoleteDir(ctx.client.buildDir);
+
+  await moveBuildTOBuildDir(ctx);
+};
+
+async function extractBuild(ctx: any) {
+  await fs.rename(
+    path.resolve(ctx.client.buildDir, ctx.client.stencilBuild),
+    ctx.client.tmpDir,
+  );
+
+  await fs.rename(
+    path.resolve(ctx.client.buildDir, "embeddable-types.js"),
+    path.join(ctx.client.tmpDir, "embeddable-types.js"),
+  );
+
+  await fs.rename(
+    path.resolve(ctx.client.buildDir, "embeddable-components-meta.js"),
+    path.join(ctx.client.tmpDir, "embeddable-components-meta.js"),
+  );
+
+  await fs.rename(
+    path.resolve(ctx.client.buildDir, "embeddable-editors-meta.js"),
+    path.join(ctx.client.tmpDir, "embeddable-editors-meta.js"),
+  );
+}
+
+async function removeObsoleteDir(dir: string) {
+  await fs.rm(dir, { recursive: true });
+}
+
+async function moveBuildTOBuildDir(ctx: any) {
+  await fs.rename(ctx.client.tmpDir, ctx.client.buildDir);
+}

package/src/createContext.ts

@@ -0,0 +1,26 @@
+import * as path from "node:path";
+
+export default (coreRoot: string, clientRoot: string) => ({
+  core: {
+    rootDir: coreRoot,
+    templatesDir: path.resolve(coreRoot, "templates"),
+    configsDir: path.resolve(coreRoot, "configs"),
+  },
+  client: {
+    rootDir: clientRoot,
+    buildDir: path.resolve(clientRoot, ".embeddable-build"),
+    srcDir: path.resolve(clientRoot, "src"),
+    tmpDir: path.resolve(clientRoot, ".embeddable-tmp"),
+    componentDir: path.resolve(clientRoot, ".embeddable-build", "component"),
+    stencilBuild: path.resolve(
+      clientRoot,
+      ".embeddable-build",
+      "dist",
+      "embeddable-wrapper",
+    ),
+    archiveFile: path.resolve(clientRoot, "embeddable-build.zip"),
+  },
+  outputOptions: {
+    typesEntryPointFilename: "embeddable-types-entry-point.js",
+  },
+});

package/src/credentials.ts

@@ -0,0 +1,5 @@
+import * as path from "node:path";
+import * as os from "node:os";
+
+export const CREDENTIALS_DIR = path.resolve(os.homedir(), ".embeddable");
+export const CREDENTIALS_FILE = path.resolve(CREDENTIALS_DIR, "credentials");

package/src/defineConfig.ts

@@ -0,0 +1,70 @@
+import * as path from "node:path";
+
+export type EmbeddableConfig = {
+  plugins: (() => {
+    pluginName: string;
+    build: (config: EmbeddableConfig) => Promise<void>;
+    cleanup: (config: EmbeddableConfig) => Promise<void>;
+    validate: (config: EmbeddableConfig) => Promise<void>;
+  })[];
+  pushBaseUrl?: string;
+  audienceUrl?: string;
+  authDomain?: string;
+  authClientId?: string;
+  errorFallbackComponent?: string;
+  applicationEnvironment?: string;
+  rollbarAccessToken?: string;
+  previewBaseUrl?: string;
+};
+
+export default ({
+  plugins,
+  pushBaseUrl,
+  audienceUrl,
+  authDomain,
+  authClientId,
+  errorFallbackComponent,
+  applicationEnvironment,
+  rollbarAccessToken,
+  previewBaseUrl,
+}: EmbeddableConfig) => {
+  const coreRoot = path.resolve(__dirname, "..");
+  const clientRoot = process.cwd();
+
+  return {
+    core: {
+      rootDir: coreRoot,
+      templatesDir: path.resolve(coreRoot, "templates"),
+      configsDir: path.resolve(coreRoot, "configs"),
+    },
+    client: {
+      rootDir: clientRoot,
+      buildDir: path.resolve(clientRoot, ".embeddable-build"),
+      srcDir: path.resolve(clientRoot, "src"),
+      tmpDir: path.resolve(clientRoot, ".embeddable-tmp"),
+      componentDir: path.resolve(clientRoot, ".embeddable-build", "component"),
+      stencilBuild: path.resolve(
+        clientRoot,
+        ".embeddable-build",
+        "dist",
+        "embeddable-wrapper",
+      ),
+      archiveFile: path.resolve(clientRoot, "embeddable-build.zip"),
+      errorFallbackComponent: errorFallbackComponent
+        ? path.resolve(clientRoot, errorFallbackComponent)
+        : undefined,
+    },
+    outputOptions: {
+      typesEntryPointFilename: "embeddable-types-entry-point.js",
+    },
+    pushBaseUrl: pushBaseUrl ?? "https://api.embeddable.com",
+    audienceUrl: audienceUrl ?? "https://auth.embeddable.com",
+    previewBaseUrl: previewBaseUrl ?? "https://app.embeddable.com",
+    authDomain: authDomain ?? "auth.embeddable.com",
+    authClientId: authClientId ?? "dygrSUmI6HmgY5ymVbEAoLDEBxIOyr1V",
+    applicationEnvironment: applicationEnvironment ?? "production",
+    rollbarAccessToken:
+      rollbarAccessToken ?? "5c6028038d844bf1835a0f4db5f55d9e",
+    plugins,
+  };
+};

package/src/dev.ts

@@ -0,0 +1,265 @@
+import buildTypes, {
+  EMB_OPTIONS_FILE_REGEX,
+  EMB_TYPE_FILE_REGEX,
+} from "./buildTypes";
+import prepare, { removeIfExists } from "./prepare";
+import generate from "./generate";
+import provideConfig from "./provideConfig";
+import {
+  CompilerSystem,
+  createNodeLogger,
+  createNodeSys,
+} from "@stencil/core/sys/node";
+import { RollupWatcher } from "rollup";
+import { IncomingMessage, Server, ServerResponse } from "http";
+import { ChildProcess } from "node:child_process";
+import { WebSocketServer, Server as WSServer } from "ws";
+import * as chokidar from "chokidar";
+import * as path from "path";
+import { FSWatcher } from "chokidar";
+import { getToken, default as login } from "./login";
+import axios from "axios";
+import { findFiles } from "@embeddable.com/sdk-utils";
+import { archive, YAML_OR_JS_FILES, sendBuild } from "./push";
+import validate from "./validate";
+import { checkNodeVersion } from "./utils";
+const minimist = require("minimist");
+
+const oraP = import("ora");
+let wss: WSServer;
+let changedFiles: string[] = [];
+let browserWindow: ChildProcess | null = null;
+
+let ora: any;
+let previewWorkspace: string;
+
+const SERVER_PORT = 8926;
+
+const buildWebComponent = async (config: any) => {
+  await generate(config, "sdk-react");
+};
+
+export default async () => {
+  checkNodeVersion();
+
+  const http = require("http");
+  ora = (await oraP).default;
+
+  process.on("warning", (e) => console.warn(e.stack));
+
+  const logger = createNodeLogger({ process });
+  const sys = createNodeSys({ process });
+
+  const config = {
+    dev: {
+      watch: true,
+      logger,
+      sys,
+    },
+    ...(await provideConfig()),
+  };
+
+  await prepare(config);
+
+  const finalhandler = require("finalhandler");
+  const serveStatic = require("serve-static");
+
+  const serve = serveStatic(config.client.buildDir);
+
+  const workspacePreparation = ora("Preparing workspace...").start();
+
+  try {
+    previewWorkspace = await getPreviewWorkspace(config);
+  } catch (e: any) {
+    workspacePreparation.fail(e.response.data?.errorMessage);
+    process.exit(1);
+  }
+
+  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;
+      }
+
+      const done = finalhandler(request, res);
+      serve(request, res, done);
+    },
+  );
+  wss = new WebSocketServer({ server });
+
+  server.listen(SERVER_PORT, async () => {
+    const watchers: Array<RollupWatcher | FSWatcher> = [];
+    if (sys?.onProcessInterrupt) {
+      sys.onProcessInterrupt(
+        async () => await onClose(server, sys, watchers, config),
+      );
+    }
+
+    await sendDataModelsAndSecurityContextsChanges(config);
+
+    for (const getPlugin of config.plugins) {
+      const plugin = getPlugin();
+
+      await plugin.validate(config);
+      const watcher = await plugin.build(config);
+      await configureWatcher(watcher, config);
+      watchers.push(watcher);
+    }
+
+    const dataModelAndSecurityContextWatch =
+      dataModelAndSecurityContextWatcher(config);
+    watchers.push(dataModelAndSecurityContextWatch);
+  });
+};
+
+const configureWatcher = async (watcher: RollupWatcher, ctx: any) => {
+  watcher.on("change", (path) => {
+    changedFiles.push(path);
+  });
+
+  watcher.on("event", async (e) => {
+    if (e.code === "BUNDLE_START") {
+      await onBuildStart(ctx);
+    }
+    if (e.code === "BUNDLE_END") {
+      await onBundleBuildEnd(ctx);
+      changedFiles = [];
+    }
+    if (e.code === "ERROR") {
+      sendMessage("componentsBuildError", { error: e.error?.message });
+      changedFiles = [];
+    }
+  });
+};
+
+const sendMessage = (type: string, meta = {}) => {
+  wss.clients.forEach((ws) => {
+    ws.send(JSON.stringify({ type, ...meta }));
+  });
+};
+
+const typeFilesFilter = (f: string) =>
+  EMB_OPTIONS_FILE_REGEX.test(f) || EMB_TYPE_FILE_REGEX.test(f);
+const onlyTypesChanged = () =>
+  changedFiles.length !== 0 &&
+  changedFiles.filter(typeFilesFilter).length === changedFiles.length;
+const isTypeFileChanged = () => changedFiles.findIndex(typeFilesFilter) >= 0;
+
+const onBuildStart = async (ctx: any) => {
+  if (changedFiles.length === 0 || isTypeFileChanged()) {
+    await buildTypes(ctx);
+  }
+  sendMessage("componentsBuildStart", { changedFiles });
+};
+
+const onBundleBuildEnd = async (ctx: any) => {
+  if (!onlyTypesChanged() || changedFiles.length === 0) {
+    await buildWebComponent(ctx);
+  }
+  if (browserWindow == null) {
+    const open = (await import("open")).default;
+    browserWindow = await open(
+      `${ctx.previewBaseUrl}/workspace/${previewWorkspace}`,
+    );
+  } else {
+    sendMessage("componentsBuildSuccess");
+  }
+};
+
+const dataModelAndSecurityContextWatcher = (ctx: any): FSWatcher => {
+  const fsWatcher = chokidar.watch(
+    [path.resolve(ctx.client.srcDir, "**/*.{cube,sc}.{yaml,yml,js}")],
+    {
+      ignoreInitial: true,
+    },
+  );
+  fsWatcher.on("all", async () => {
+    await sendDataModelsAndSecurityContextsChanges(ctx);
+  });
+
+  return fsWatcher;
+};
+
+const sendDataModelsAndSecurityContextsChanges = async (ctx: any) => {
+  sendMessage("dataModelsAndOrSecurityContextUpdateStart");
+  const isValid = await validate(ctx, false);
+  if (isValid) {
+    const token = await getToken();
+    const sending = ora(
+      "Synchronising data models and/or security contexts...",
+    ).start();
+    const filesList = await findFiles(ctx.client.srcDir, YAML_OR_JS_FILES);
+    await archive(ctx, filesList, false);
+    await sendBuild(ctx, { workspaceId: previewWorkspace, token });
+    sending.succeed(`Data models and/or security context synchronized`);
+    sendMessage("dataModelsAndOrSecurityContextUpdateSuccess");
+  } else {
+    sendMessage("dataModelsAndOrSecurityContextUpdateError");
+  }
+};
+
+const onClose = async (
+  server: Server,
+  sys: CompilerSystem,
+  watchers: Array<RollupWatcher | FSWatcher>,
+  config: any,
+) => {
+  server.close();
+  wss.close();
+  browserWindow?.unref();
+  for (const watcher of watchers) {
+    if (watcher.close) {
+      await watcher.close();
+    }
+  }
+  for (const getPlugin of config.plugins) {
+    const plugin = getPlugin();
+    await plugin.cleanup(config);
+  }
+  await removeIfExists(config);
+  await sys.destroy();
+  process.exit(0);
+};
+
+const getPreviewWorkspace = async (ctx: any): Promise<string> => {
+  const token = await getToken();
+
+  const params = minimist(process.argv.slice(2));
+  const primaryWorkspace = params.w || params.workspace;
+
+  try {
+    const response = await axios.get(
+      `${ctx.pushBaseUrl}/workspace/dev-workspace`,
+      {
+        params: { primaryWorkspace },
+        headers: {
+          Authorization: `Bearer ${token}`,
+        },
+      },
+    );
+    return response.data;
+  } catch (e: any) {
+    if (e.response.status === 401) {
+      // login and retry
+      await login();
+      return await getPreviewWorkspace(ctx);
+    } else {
+      throw e;
+    }
+  }
+};

package/src/entryPoint.ts

@@ -0,0 +1,16 @@
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const COMMANDS_MAP = await import(path.join(__dirname, "../lib/index.js"));
+
+async function main() {
+  const command = process.argv[2];
+  const runScript = COMMANDS_MAP[command];
+
+  if (!runScript) process.exit(1);
+
+  await runScript();
+}
+
+main();

package/src/generate.ts

@@ -0,0 +1,124 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { createNodeLogger, createNodeSys } from "@stencil/core/sys/node";
+import { createCompiler, loadConfig } from "@stencil/core/compiler";
+
+const sorcery = require("sorcery");
+
+const STYLE_IMPORTS_TOKEN = "{{STYLES_IMPORT}}";
+const RENDER_IMPORT_TOKEN = "{{RENDER_IMPORT}}";
+
+export default async (ctx: any, pluginName: string) => {
+  await injectCSS(ctx, pluginName);
+
+  await injectBundleRender(ctx, pluginName);
+
+  await runStencil(ctx);
+
+  await generateSourceMap(ctx, pluginName);
+};
+
+async function injectCSS(ctx: any, pluginName: string) {
+  const CUSTOMER_BUILD = path.resolve(
+    ctx.client.buildDir,
+    ctx[pluginName].outputOptions.buildName,
+  );
+  const allFiles = await fs.readdir(CUSTOMER_BUILD);
+
+  const cssFilesImportsStr = allFiles
+    .filter((fileName) => fileName.endsWith(".css"))
+    .map(
+      (fileName) =>
+        `@import '../${ctx[pluginName].outputOptions.buildName}/${fileName}';`,
+    )
+    .join("\n");
+
+  const content = await fs.readFile(
+    path.resolve(ctx.core.templatesDir, "style.css.template"),
+    "utf8",
+  );
+
+  await fs.writeFile(
+    path.resolve(ctx.client.componentDir, "style.css"),
+    content.replace(STYLE_IMPORTS_TOKEN, cssFilesImportsStr),
+  );
+}
+
+async function injectBundleRender(ctx: any, pluginName: string) {
+  const importStr = `import render from '../${ctx[pluginName].outputOptions.buildName}/${ctx[pluginName].outputOptions.fileName}';`;
+
+  const content = await fs.readFile(
+    path.resolve(ctx.core.templatesDir, "component.tsx.template"),
+    "utf8",
+  );
+
+  await fs.writeFile(
+    path.resolve(ctx.client.componentDir, "component.tsx"),
+    content.replace(RENDER_IMPORT_TOKEN, importStr),
+  );
+}
+
+async function runStencil(ctx: any) {
+  const logger = ctx.dev?.logger || createNodeLogger({ process });
+  const sys = ctx.dev?.sys || createNodeSys({ process });
+  const devMode = !!ctx.dev;
+
+  const validated = await loadConfig({
+    initTsConfig: true,
+    logger,
+    sys,
+    config: {
+      devMode,
+      rootDir: ctx.client.buildDir,
+      configPath: path.resolve(ctx.client.buildDir, "stencil.config.ts"),
+      tsconfig: path.resolve(ctx.client.buildDir, "tsconfig.json"),
+      namespace: "embeddable-wrapper",
+      srcDir: path.resolve(ctx.client.buildDir, "component"),
+      outputTargets: [
+        {
+          type: "dist",
+        },
+      ],
+    },
+  });
+
+  const compiler = await createCompiler(validated.config);
+
+  await compiler.build();
+
+  await compiler.destroy();
+  process.chdir(ctx.client.rootDir);
+}
+
+async function generateSourceMap(ctx: any, pluginName: string) {
+  const componentBuildDir = path.resolve(
+    ctx.client.buildDir,
+    ctx[pluginName].outputOptions.buildName,
+  );
+  const stencilBuild = path.resolve(ctx.client.stencilBuild);
+
+  const tmpComponentDir = path.resolve(
+    stencilBuild,
+    ctx[pluginName].outputOptions.buildName,
+  );
+  await fs.cp(componentBuildDir, tmpComponentDir, { recursive: true });
+
+  const stencilFiles = await fs.readdir(stencilBuild);
+  const jsFiles = stencilFiles.filter((file) =>
+    file.toLowerCase().endsWith(".js"),
+  );
+
+  await Promise.all(
+    jsFiles.map(async (jsFile) => {
+      try {
+        const chain = await sorcery.load(path.resolve(stencilBuild, jsFile));
+        // overwrite the existing file
+        await chain.write();
+      } catch (e) {
+        // do nothing if a map file can not be generated
+      }
+    }),
+  );
+
+  await fs.rm(tmpComponentDir, { recursive: true });
+}

package/src/globalCleanup.ts

@@ -0,0 +1,19 @@
+import * as fsP from "node:fs/promises";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export default async (ctx: any) => {
+  const componentsEntryPath = path.resolve(
+    ctx.client.rootDir,
+    ctx.outputOptions.componentsEntryPointFilename,
+  );
+  const typesEntryPath = path.resolve(
+    ctx.client.rootDir,
+    ctx.outputOptions.typesEntryPointFilename,
+  );
+
+  if (fs.existsSync(ctx.client.buildDir))
+    await fsP.rm(ctx.client.buildDir, { recursive: true });
+  if (fs.existsSync(componentsEntryPath)) await fsP.rm(componentsEntryPath);
+  if (fs.existsSync(typesEntryPath)) await fsP.rm(typesEntryPath);
+};

package/src/index.ts

@@ -0,0 +1,5 @@
+export { default as build } from "./build";
+export { default as login } from "./login";
+export { default as push } from "./push";
+export { default as dev } from "./dev";
+export { default as defineConfig } from "./defineConfig";

package/src/login.ts

@@ -0,0 +1,111 @@
+import * as path from "node:path";
+import * as os from "node:os";
+import * as fs from "node:fs/promises";
+import axios from "axios";
+import provideConfig from "./provideConfig";
+import { jwtDecode } from "jwt-decode";
+// @ts-ignore
+import reportErrorToRollbar from "./rollbar.mjs";
+import { CREDENTIALS_DIR, CREDENTIALS_FILE } from "./credentials";
+const oraP = import("ora");
+const openP = import("open");
+
+export default async () => {
+  const ora = (await oraP).default;
+  const authenticationSpinner = ora("Waiting for code verification...").start();
+
+  try {
+    const open = (await openP).default;
+    const config = await provideConfig();
+
+    await resolveFiles();
+
+    const deviceCodePayload = {
+      client_id: config.authClientId,
+      audience: config.audienceUrl,
+    };
+
+    const deviceCodeResponse = await axios.post(
+      `https://${config.authDomain}/oauth/device/code`,
+      deviceCodePayload,
+    );
+
+    ora(
+      "Confirm this code on your browser: " +
+        deviceCodeResponse.data["user_code"],
+    ).info();
+
+    const tokenPayload = {
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCodeResponse.data["device_code"],
+      client_id: config.authClientId,
+    };
+
+    await open(deviceCodeResponse.data["verification_uri_complete"]);
+
+    /**
+     * This is a recommended way to poll, since it take some time for a user to enter a `user_code` in a browser.
+     * deviceCodeResponse.data['interval'] is a recommended/calculated polling interval specified in seconds.
+     */
+    while (true) {
+      try {
+        const tokenResponse = await axios.post(
+          `https://${config.authDomain}/oauth/token`,
+          tokenPayload,
+        );
+        await fs.writeFile(
+          CREDENTIALS_FILE,
+          JSON.stringify(tokenResponse.data),
+        );
+        authenticationSpinner.succeed(
+          "You are successfully authenticated now!",
+        );
+        break;
+      } catch (e: any) {
+        if (e.response.data?.error !== "authorization_pending") {
+          authenticationSpinner.fail(
+            "Authentication failed. Please try again.",
+          );
+          process.exit(1);
+        }
+
+        await sleep(deviceCodeResponse.data["interval"] * 1000);
+      }
+    }
+  } catch (error) {
+    authenticationSpinner.fail("Authentication failed. Please try again.");
+    await reportErrorToRollbar(error);
+    console.log(error);
+
+    process.exit(1);
+  }
+};
+
+export async function getToken() {
+  try {
+    const rawCredentials = await fs.readFile(CREDENTIALS_FILE, "utf-8");
+    const credentials = JSON.parse(rawCredentials.toString());
+
+    return credentials?.access_token ?? "";
+  } catch (_e) {
+    return "";
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise((res) => setTimeout(res, ms));
+}
+
+async function resolveFiles() {
+  try {
+    await fs.access(CREDENTIALS_DIR);
+  } catch (_e) {
+    await fs.mkdir(CREDENTIALS_DIR);
+  }
+
+  try {
+    await fs.access(CREDENTIALS_FILE);
+  } catch (e) {
+    await fs.writeFile(CREDENTIALS_FILE, "");
+  }
+}

package/src/prepare.ts

@@ -0,0 +1,23 @@
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+
+export default async (ctx: any) => {
+  await removeIfExists(ctx);
+
+  await copyStencilConfigsToClient(ctx);
+
+  await createComponentDir(ctx.client.componentDir);
+};
+
+export async function removeIfExists(ctx: any) {
+  if (fsSync.existsSync(ctx.client.buildDir))
+    await fs.rm(ctx.client.buildDir, { recursive: true });
+}
+
+async function copyStencilConfigsToClient(ctx: any) {
+  await fs.cp(ctx.core.configsDir, ctx.client.buildDir, { recursive: true });
+}
+
+async function createComponentDir(dir: string) {
+  await fs.mkdir(dir);
+}

package/src/provideConfig.ts

@@ -0,0 +1,14 @@
+import * as fs from "node:fs";
+import * as url from "node:url";
+
+export default async () => {
+  const configFilePath = `${process.cwd()}/embeddable.config.js`;
+
+  if (!fs.existsSync(configFilePath)) {
+    console.log("Please create a proper `embeddable.config.js` file first.");
+    process.exit(1);
+  }
+
+  const configFileUrl = url.pathToFileURL(configFilePath).href;
+  return (await import(configFileUrl)).default;
+};

package/src/push.ts

@@ -0,0 +1,189 @@
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import * as archiver from "archiver";
+import axios from "axios";
+const oraP = import("ora");
+const inquirerSelect = import("@inquirer/select");
+import provideConfig from "./provideConfig";
+// @ts-ignore
+import reportErrorToRollbar from "./rollbar.mjs";
+
+import { findFiles } from "@embeddable.com/sdk-utils";
+import { getToken } from "./login";
+import { checkNodeVersion } from "./utils";
+
+// grab .cube.yml|js and .sc.yml|js files
+export const YAML_OR_JS_FILES = /^(.*)\.(cube|sc)\.(ya?ml|js)$/;
+
+let ora: any;
+export default async () => {
+  try {
+    checkNodeVersion();
+    ora = (await oraP).default;
+
+    const config = await provideConfig();
+
+    const token = await verify(config);
+
+    const { workspaceId, name: workspaceName } = await selectWorkspace(
+      config,
+      token,
+    );
+
+    const spinnerArchive = ora("Building...").start();
+
+    const filesList = await findFiles(config.client.srcDir, YAML_OR_JS_FILES);
+
+    await archive(config, filesList);
+    spinnerArchive.succeed("Bundling completed");
+
+    const spinnerPushing = ora(
+      `Publishing to ${workspaceName} using ${config.pushBaseUrl}...`,
+    ).start();
+
+    await sendBuild(config, { workspaceId, token });
+    spinnerPushing.succeed(
+      `Published to ${workspaceName} using ${config.pushBaseUrl}`,
+    );
+  } catch (error: any) {
+    console.log(error);
+    await reportErrorToRollbar(error);
+    throw error;
+  }
+};
+
+async function selectWorkspace(ctx: any, token: string) {
+  const workspaceSpinner = ora({
+    text: `Fetching workspaces using ${ctx.pushBaseUrl}...`,
+    color: "green",
+    discardStdin: false,
+  }).start();
+
+  const availableWorkspaces = await getWorkspaces(ctx, token, workspaceSpinner);
+
+  let selectedWorkspace;
+
+  if (availableWorkspaces.length === 0) {
+    workspaceSpinner.fail("No workspaces found");
+    process.exit(1);
+  }
+
+  workspaceSpinner.info(`Found ${availableWorkspaces.length} workspace(s)`);
+
+  if (availableWorkspaces.length === 1) {
+    selectedWorkspace = availableWorkspaces[0];
+  } else {
+    const select = (await inquirerSelect).default;
+    selectedWorkspace = await select({
+      message: "Select workspace to push changes",
+      choices: availableWorkspaces.map((workspace: any) => ({
+        name: `${workspace.name} (${workspace.workspaceId})`,
+        value: workspace,
+      })),
+    });
+  }
+
+  workspaceSpinner.succeed(
+    `Workspace: ${selectedWorkspace.name} (${selectedWorkspace.workspaceId})`,
+  );
+
+  return selectedWorkspace;
+}
+
+async function verify(ctx: any) {
+  try {
+    await fs.access(ctx.client.buildDir);
+  } catch (_e) {
+    console.error("No embeddable build was produced.");
+    process.exit(1);
+  }
+
+  // TODO: initiate login if no/invalid token.
+  const token = await getToken();
+
+  if (!token) {
+    console.error("Expired token. Please login again.");
+    process.exit(1);
+  }
+
+  return token;
+}
+
+export async function archive(
+  ctx: any,
+  yamlFiles: [string, string][],
+  includeBuild: boolean = true,
+) {
+  const output = fsSync.createWriteStream(ctx.client.archiveFile);
+
+  const _archiver = archiver.create("zip", {
+    zlib: { level: 9 },
+  });
+
+  _archiver.pipe(output);
+  if (includeBuild) {
+    _archiver.directory(ctx.client.buildDir, false);
+  }
+
+  for (const fileData of yamlFiles) {
+    const fileName = fileData[1].split("/").pop();
+
+    _archiver.file(fileData[1], {
+      name: fileName!,
+    });
+  }
+
+  await _archiver.finalize();
+
+  return new Promise((resolve, _reject) => {
+    output.on("close", resolve);
+  });
+}
+
+export async function sendBuild(
+  ctx: any,
+  { workspaceId, token }: { workspaceId: string; token: string },
+) {
+  const { FormData } = await import("formdata-node");
+  const { fileFromPath } = await import("formdata-node/file-from-path");
+
+  const file = await fileFromPath(
+    ctx.client.archiveFile,
+    "embeddable-build.zip",
+  );
+
+  const form = new FormData();
+  form.set("file", file, "embeddable-build.zip");
+
+  await axios.post(`${ctx.pushBaseUrl}/bundle/${workspaceId}/upload`, form, {
+    headers: {
+      "Content-Type": "multipart/form-data",
+      Authorization: `Bearer ${token}`,
+    },
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+  });
+
+  await fs.rm(ctx.client.archiveFile);
+}
+
+async function getWorkspaces(ctx: any, token: string, workspaceSpinner: any) {
+  try {
+    const response = await axios.get(`${ctx.pushBaseUrl}/workspace`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    return response.data?.filter((w: any) => !w.devWorkspace);
+  } catch (e: any) {
+    if (e.response.status === 401) {
+      workspaceSpinner.fail(
+        'Unauthorized. Please login using "embeddable login" command.',
+      );
+    } else {
+      workspaceSpinner.fail("Failed to fetch workspaces");
+    }
+    process.exit(1);
+  }
+}

package/src/rollbar.mjs

@@ -0,0 +1,85 @@
+import * as path from "path";
+import Rollbar from 'rollbar';
+import provideConfig from "./provideConfig";
+import fs from "node:fs/promises";
+import {CREDENTIALS_FILE} from "./credentials";
+import {jwtDecode} from "jwt-decode";
+
+
+const reportErrorToRollbar = async (error) => {
+  const config = await provideConfig();
+
+  const rollbar = new Rollbar({
+    accessToken: config.rollbarAccessToken,
+    captureUncaught: true,
+    captureUnhandledRejections: true,
+    payload: {
+      environment: config.applicationEnvironment,
+      source: "sdk",
+    },
+  });
+
+  const userData = await getUserData()
+
+  rollbar.configure({
+    payload: {
+        person: {
+            id: userData.globalUserId
+        }
+    }
+  })
+
+  rollbar.error(error, {
+    custom: {
+      code_version: getSdkPackageVersionInfo(config)
+    },
+  });
+};
+
+const getSdkPackageVersionInfo = (config) => {
+  try {
+    const packageJsonFilePath = path.resolve(
+      config.client.rootDir,
+      "package.json",
+    );
+
+    const packageJson = require(packageJsonFilePath);
+    const devDependencies = packageJson.devDependencies;
+    const dependencies = packageJson.dependencies;
+
+    const getDependencyVersion = (key, dependencies, devDependencies) => {
+      return dependencies?.[key] || devDependencies?.[key];
+    };
+
+    const packageVersionInfo = {
+      core: getDependencyVersion("@embeddable.com/core", dependencies, devDependencies),
+      sdk_core: getDependencyVersion("@embeddable.com/sdk-core", dependencies, devDependencies),
+      react: getDependencyVersion("@embeddable.com/react", dependencies, devDependencies),
+      sdk_react: getDependencyVersion("@embeddable.com/sdk-react", dependencies, devDependencies),
+    };
+
+    return JSON.stringify(packageVersionInfo);
+  } catch (e) {
+    console.warn("Could not get SDK package version info", e)
+    return "unknown";
+  }
+};
+
+export async function getUserData() {
+  try {
+    const token = await fs
+        .readFile(CREDENTIALS_FILE)
+        .then((data) => JSON.parse(data.toString()));
+
+    const decodedToken = jwtDecode(token.access_token);
+
+    return {
+      globalUserId: `${decodedToken.iss}@${decodedToken.sub}`,
+    };
+  } catch (error) {
+    console.warn("Failed to get user data from credentials file");
+    return { globalUserId: "unknown" };
+  }
+}
+
+export default reportErrorToRollbar;

package/src/utils.ts

@@ -0,0 +1,24 @@
+const oraP = import("ora");
+
+let ora: any;
+export const checkNodeVersion = async () => {
+  ora = (await oraP).default;
+  ora("Checking node version...");
+  const [major, minor] = process.versions.node.split(".").map(Number);
+
+  const engines = require("../package.json").engines.node;
+
+  const [minMajor, minMinor] = engines
+    .split(".")
+    .map((v: string) => v.replace(/[^\d]/g, ""))
+    .map(Number);
+
+  if (major < minMajor || (major === minMajor && minor < minMinor)) {
+    ora({
+      text: `Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`,
+      color: "red",
+    }).fail();
+
+    process.exit(1);
+  }
+};

package/src/validate.ts

@@ -0,0 +1,180 @@
+import * as fs from "node:fs/promises";
+import * as YAML from "yaml";
+import { errorFormatter, findFiles } from "@embeddable.com/sdk-utils";
+import { z } from "zod";
+
+const CUBE_YAML_FILE_REGEX = /^(.*)\.cube\.ya?ml$/;
+const SECURITY_CONTEXT_FILE_REGEX = /^(.*)\.sc\.ya?ml$/;
+
+const checkNodeVersion = () => {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+
+  const engines = require("../package.json").engines.node;
+
+  const [minMajor, minMinor] = engines.split(".").map(Number);
+
+  if (major < minMajor || (major === minMajor && minor < minMinor)) {
+    throw new Error(
+      `Node version ${minMajor}.${minMinor} or higher is required. You are running ${major}.${minor}.`,
+    );
+  }
+};
+
+export default async (ctx: any, exitIfInvalid = true) => {
+  checkNodeVersion();
+  const ora = (await import("ora")).default;
+
+  const spinnerValidate = ora("Data model validation...").start();
+
+  const filesList = await findFiles(ctx.client.srcDir, CUBE_YAML_FILE_REGEX);
+  const securityContextFilesList = await findFiles(
+    ctx.client.srcDir,
+    SECURITY_CONTEXT_FILE_REGEX,
+  );
+
+  const dataModelErrors = await dataModelsValidation(filesList);
+
+  if (dataModelErrors.length) {
+    spinnerValidate.fail("One or more cube.yaml files are invalid:");
+
+    dataModelErrors.forEach((errorMessage) =>
+      spinnerValidate.info(errorMessage),
+    );
+
+    if (exitIfInvalid) {
+      process.exit(1);
+    }
+  }
+
+  spinnerValidate.succeed("Data model validation completed");
+
+  const securityContextErrors = await securityContextValidation(
+    securityContextFilesList,
+  );
+
+  if (securityContextErrors.length) {
+    spinnerValidate.fail("One or more security context files are invalid:");
+
+    securityContextErrors.forEach((errorMessage) =>
+      spinnerValidate.info(errorMessage),
+    );
+
+    if (exitIfInvalid) {
+      process.exit(1);
+    }
+  }
+
+  return dataModelErrors.length === 0 && securityContextErrors.length === 0;
+};
+
+export async function dataModelsValidation(filesList: [string, string][]) {
+  const errors: string[] = [];
+
+  for (const [_, filePath] of filesList) {
+    const fileContentRaw = await fs.readFile(filePath, "utf8");
+
+    const cube = YAML.parse(fileContentRaw);
+
+    const safeParse = cubeModelSchema.safeParse(cube);
+    if (!safeParse.success) {
+      errorFormatter(safeParse.error.issues).forEach((error) => {
+        errors.push(`${filePath}: ${error}`);
+      });
+    }
+  }
+
+  return errors;
+}
+
+async function securityContextValidation(filesList: [string, string][]) {
+  const errors: string[] = [];
+
+  const nameSet = new Set<string>();
+  for (const [_, filePath] of filesList) {
+    const fileContentRaw = await fs.readFile(filePath, "utf8");
+
+    const cube = YAML.parse(fileContentRaw);
+
+    cube.forEach((item: { name: string }) => {
+      if (nameSet.has(item.name)) {
+        errors.push(
+          `${filePath}: security context with name "${item.name}" already exists`,
+        );
+      } else {
+        nameSet.add(item.name);
+      }
+    });
+
+    const safeParse = securityContextSchema.safeParse(cube);
+    if (!safeParse.success) {
+      errorFormatter(safeParse.error.issues).forEach((error) => {
+        errors.push(`${filePath}: ${error}`);
+      });
+    }
+  }
+
+  return errors;
+}
+
+enum MeasureTypeEnum {
+  string = "string",
+  time = "time",
+  boolean = "boolean",
+  number = "number",
+  count = "count",
+  count_distinct = "count_distinct",
+  count_distinct_approx = "count_distinct_approx",
+  sum = "sum",
+  avg = "avg",
+  min = "min",
+  max = "max",
+}
+
+enum DimensionTypeEnum {
+  string = "string",
+  time = "time",
+  boolean = "boolean",
+  number = "number",
+  geo = "geo",
+}
+
+const cubeModelSchema = z
+  .object({
+    cubes: z
+      .object({
+        name: z.string(),
+        dimensions: z
+          .object({
+            name: z.string(),
+            type: z.nativeEnum(DimensionTypeEnum),
+          })
+          .array()
+          .optional(),
+        measures: z
+          .object({
+            name: z.string(),
+            type: z.nativeEnum(MeasureTypeEnum),
+          })
+          .array()
+          .optional(),
+      })
+      .array()
+      .min(1),
+  })
+  .refine(
+    (data) =>
+      data.cubes.every(
+        (cube) => cube.dimensions?.length || cube.measures?.length,
+      ),
+    {
+      message: "At least one measure or dimension must be defined",
+      path: ["cubes"],
+    },
+  );
+
+const securityContextSchema = z.array(
+  z.object({
+    name: z.string(),
+    securityContext: z.object({}), // can be any object
+  }),
+);