@embeddable.com/sdk-core 0.2.0 → 2.0.0

package/bin/embeddable

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 'use strict';
 
-const COMMANDS_MAP = require("../scripts");
+const COMMANDS_MAP = require("../dist");
 
 async function main () {
     const command = process.argv[2];

package/configs/stencil.config.ts

@@ -1,11 +1,11 @@
-import { Config } from '@stencil/core';
+import { Config } from "@stencil/core";
 
 export const config: Config = {
-  namespace: 'embeddable-wrapper',
-  srcDir: 'component',
+  namespace: "embeddable-wrapper",
+  srcDir: "component",
   outputTargets: [
     {
-      type: 'dist'
+      type: "dist",
     },
   ],
-};
+};

package/dist/build.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/dist/buildTypes.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (ctx: any) => Promise<void>;
+export default _default;

package/dist/cleanup.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (ctx: any) => Promise<void>;
+export default _default;

package/dist/createContext.d.ts

@@ -0,0 +1,20 @@
+declare const _default: (coreRoot: string, clientRoot: string) => {
+    core: {
+        rootDir: string;
+        templatesDir: string;
+        configsDir: string;
+    };
+    client: {
+        rootDir: string;
+        buildDir: string;
+        srcDir: string;
+        tmpDir: string;
+        componentDir: string;
+        stencilBuild: string;
+        archiveFile: string;
+    };
+    outputOptions: {
+        typesEntryPointFilename: string;
+    };
+};
+export default _default;

package/dist/generate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (ctx: any, pluginName: string) => Promise<void>;
+export default _default;

package/dist/globalCleanup.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (ctx: any) => Promise<void>;
+export default _default;

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,416 @@
+'use strict';
+
+var fs = require('node:fs/promises');
+var path = require('node:path');
+var vite = require('vite');
+var sdkUtils = require('@embeddable.com/sdk-utils');
+var fsSync = require('node:fs');
+var stencilNodeApi = require('@stencil/core/sys/node');
+var stencil = require('@stencil/core/cli');
+var fs$1 = require('fs/promises');
+var path$1 = require('path');
+var YAML = require('yaml');
+var os = require('node:os');
+var axios = require('axios');
+var archiver = require('archiver');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var vite__namespace = /*#__PURE__*/_interopNamespaceDefault(vite);
+var fsSync__namespace = /*#__PURE__*/_interopNamespaceDefault(fsSync);
+var stencilNodeApi__namespace = /*#__PURE__*/_interopNamespaceDefault(stencilNodeApi);
+var stencil__namespace = /*#__PURE__*/_interopNamespaceDefault(stencil);
+var fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$1);
+var path__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(path$1);
+var YAML__namespace = /*#__PURE__*/_interopNamespaceDefault(YAML);
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
+var archiver__namespace = /*#__PURE__*/_interopNamespaceDefault(archiver);
+
+const oraP$2 = import('ora');
+const EMB_TYPE_FILE_REGEX = /^(.*)\.type\.emb\.[jt]s$/;
+const EMB_OPTIONS_FILE_REGEX = /^(.*)\.options\.emb\.[jt]s$/;
+var buildTypes = async (ctx) => {
+    const ora = (await oraP$2).default;
+    const progress = ora("building types...").start();
+    await generate$1(ctx);
+    await build$1(ctx);
+    await cleanup$1(ctx);
+    progress.succeed("types built completed");
+};
+async function generate$1(ctx) {
+    const typeFiles = await sdkUtils.findFiles(ctx.client.srcDir, EMB_TYPE_FILE_REGEX);
+    const optionsFiles = await sdkUtils.findFiles(ctx.client.srcDir, EMB_OPTIONS_FILE_REGEX);
+    const typeImports = typeFiles
+        .concat(optionsFiles)
+        .map(([_fileName, filePath]) => `import './${path__namespace.relative(ctx.client.rootDir, filePath)}';`)
+        .join("\n");
+    await fs__namespace.writeFile(path__namespace.resolve(ctx.client.rootDir, ctx.outputOptions.typesEntryPointFilename), typeImports);
+}
+async function build$1(ctx) {
+    process.chdir(ctx.client.rootDir);
+    await vite__namespace.build({
+        logLevel: "error",
+        build: {
+            emptyOutDir: false,
+            lib: {
+                entry: `./${ctx.outputOptions.typesEntryPointFilename}`,
+                formats: ["es"],
+                fileName: "embeddable-types",
+            },
+            outDir: ".embeddable-build/",
+        },
+    });
+}
+async function cleanup$1(ctx) {
+    await fs__namespace.rm(path__namespace.resolve(ctx.client.rootDir, "embeddable-types-entry-point.js"));
+}
+
+var prepare = async (ctx) => {
+    await removeIfExists(ctx);
+    await copyStencilConfigsToClient(ctx);
+    await createComponentDir(ctx.client.componentDir);
+};
+async function removeIfExists(ctx) {
+    if (fsSync__namespace.existsSync(ctx.client.buildDir))
+        await fs__namespace.rm(ctx.client.buildDir, { recursive: true });
+}
+async function copyStencilConfigsToClient(ctx) {
+    await fs__namespace.cp(ctx.core.configsDir, ctx.client.buildDir, { recursive: true });
+}
+async function createComponentDir(dir) {
+    await fs__namespace.mkdir(dir);
+}
+
+const STYLE_IMPORTS_TOKEN = "{{STYLES_IMPORT}}";
+const RENDER_IMPORT_TOKEN = "{{RENDER_IMPORT}}";
+const NODE_LOGGER = stencilNodeApi__namespace.createNodeLogger({ process: process });
+const NODE_SYS = stencilNodeApi__namespace.createNodeSys({
+    process: process,
+    // @ts-ignore
+    logger: NODE_LOGGER,
+});
+var generate = async (ctx, pluginName) => {
+    await injectCSS(ctx, pluginName);
+    await injectBundleRender(ctx, pluginName);
+    await runStencil(ctx);
+};
+async function injectCSS(ctx, pluginName) {
+    const CUSTOMER_BUILD = path__namespace.resolve(ctx.client.buildDir, ctx[pluginName].outputOptions.buildName);
+    const allFiles = await fs__namespace.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__namespace.readFile(path__namespace.resolve(ctx.core.templatesDir, "style.css.template"), "utf8");
+    await fs__namespace.writeFile(path__namespace.resolve(ctx.client.componentDir, "style.css"), content.replace(STYLE_IMPORTS_TOKEN, cssFilesImportsStr));
+}
+async function injectBundleRender(ctx, pluginName) {
+    const importStr = `import render from '../${ctx[pluginName].outputOptions.buildName}/${ctx[pluginName].outputOptions.fileName}';`;
+    const content = await fs__namespace.readFile(path__namespace.resolve(ctx.core.templatesDir, "component.tsx.template"), "utf8");
+    await fs__namespace.writeFile(path__namespace.resolve(ctx.client.componentDir, "component.tsx"), content.replace(RENDER_IMPORT_TOKEN, importStr));
+}
+async function runStencil(ctx) {
+    process.chdir(ctx.client.buildDir);
+    await stencil__namespace.run({
+        args: ["build"],
+        logger: NODE_LOGGER,
+        sys: NODE_SYS,
+        // @ts-ignore
+        checkVersion: stencilNodeApi__namespace.checkVersion,
+    });
+}
+
+var cleanup = async (ctx) => {
+    await extractBuild(ctx);
+    await removeObsoleteDir(ctx.client.buildDir);
+    await moveBuildTOBuildDir(ctx);
+};
+async function extractBuild(ctx) {
+    await fs__namespace$1.rename(path__namespace$1.resolve(ctx.client.buildDir, ctx.client.stencilBuild), ctx.client.tmpDir);
+    await fs__namespace$1.rename(path__namespace$1.resolve(ctx.client.buildDir, "embeddable-types.js"), path__namespace$1.join(ctx.client.tmpDir, "embeddable-types.js"));
+    await fs__namespace$1.rename(path__namespace$1.resolve(ctx.client.buildDir, "embeddable-components-meta.js"), path__namespace$1.join(ctx.client.tmpDir, "embeddable-components-meta.js"));
+    await fs__namespace$1.rename(path__namespace$1.resolve(ctx.client.buildDir, "embeddable-editors-meta.js"), path__namespace$1.join(ctx.client.tmpDir, "embeddable-editors-meta.js"));
+}
+async function removeObsoleteDir(dir) {
+    await fs__namespace$1.rm(dir, { recursive: true });
+}
+async function moveBuildTOBuildDir(ctx) {
+    await fs__namespace$1.rename(ctx.client.tmpDir, ctx.client.buildDir);
+}
+
+const EMB_YAML_FILE_REGEX$1 = /^(.*)\.emb\.ya?ml$/;
+var validate = async (ctx) => {
+    const ora = (await import('ora')).default;
+    const spinnerValidate = ora("validation...").start();
+    const filesList = await sdkUtils.findFiles(ctx.client.srcDir, EMB_YAML_FILE_REGEX$1);
+    const componentConfigErrors = await componentConfigValidation(filesList);
+    if (componentConfigErrors.length) {
+        spinnerValidate.fail("One or more component.emb.yaml files are invalid:");
+        componentConfigErrors.forEach((errorMessage) => spinnerValidate.info(errorMessage));
+        process.exit(1);
+    }
+    spinnerValidate.succeed("validation completed");
+};
+async function componentConfigValidation(filesList) {
+    const ARRAY_ALLOWED_TYPES = ["Dimension", "Measure"];
+    const errors = [];
+    for (const [fileName, filePath] of filesList) {
+        if (!fileName.endsWith(".component"))
+            continue;
+        const fileContentRaw = await fs__namespace.readFile(filePath, "utf8");
+        const config = YAML__namespace.parse(fileContentRaw);
+        if (!("inputs" in config) || config.inputs.length === 0)
+            continue;
+        config.inputs
+            .filter((inputConfig) => inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.array)
+            .forEach((inputConfig) => {
+            if (!ARRAY_ALLOWED_TYPES.includes(inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.type)) {
+                const errorMessage = `${fileName} contains invalid type value for \x1b[33m${inputConfig.name}\x1b[0m input.
+\x1b[33m${inputConfig.name}\x1b[0m is marked as \x1b[33marray\x1b[0m. Inputs marked as array support the following types: ${ARRAY_ALLOWED_TYPES.join(", ")}.
+Specified \x1b[33m${inputConfig === null || inputConfig === void 0 ? void 0 : inputConfig.type}\x1b[0m type is not supported.
+Please check the following file: \x1b[33m${filePath}\x1b[0m\n`;
+                errors.push(errorMessage);
+            }
+        });
+    }
+    return errors;
+}
+
+var build = async () => {
+    const config = (await import(`${process.cwd()}/embeddable.config.js`))
+        .default;
+    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);
+};
+
+const oraP$1 = import('ora');
+const openP = import('open');
+const CREDENTIALS_DIR = path__namespace.resolve(os__namespace.homedir(), ".embeddable");
+const CREDENTIALS_FILE = path__namespace.resolve(CREDENTIALS_DIR, "credentials");
+const AUTH0_DOMAIN = "embeddable-dev.eu.auth0.com";
+const AUTH0_CLIENT_ID = "xOKco5ztFCpWn54bJbFkAcT8mV4LLcpG";
+var login = async () => {
+    var _a;
+    const ora = (await oraP$1).default;
+    const open = (await openP).default;
+    await resolveFiles();
+    const deviceCodePayload = {
+        client_id: AUTH0_CLIENT_ID,
+        audience: "https://api.embeddable.com/",
+    };
+    const deviceCodeResponse = await axios.post(`https://${AUTH0_DOMAIN}/oauth/device/code`, deviceCodePayload);
+    const tokenPayload = {
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: deviceCodeResponse.data["device_code"],
+        client_id: AUTH0_CLIENT_ID,
+    };
+    const authenticationSpinner = ora("waiting for code verification...").start();
+    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://${AUTH0_DOMAIN}/oauth/token`, tokenPayload);
+            await fs__namespace.writeFile(CREDENTIALS_FILE, JSON.stringify(tokenResponse.data));
+            authenticationSpinner.succeed("you are successfully authenticated now!");
+            break;
+        }
+        catch (e) {
+            if (((_a = e.response.data) === null || _a === void 0 ? void 0 : _a.error) !== "authorization_pending") {
+                authenticationSpinner.fail("authentication failed. please try again.");
+                process.exit(1);
+            }
+            await sleep(deviceCodeResponse.data["interval"] * 1000);
+        }
+    }
+};
+async function getToken() {
+    var _a;
+    try {
+        const rawCredentials = await fs__namespace.readFile(CREDENTIALS_FILE, "utf-8");
+        const credentials = JSON.parse(rawCredentials.toString());
+        return (_a = credentials === null || credentials === void 0 ? void 0 : credentials.access_token) !== null && _a !== void 0 ? _a : "";
+    }
+    catch (_e) {
+        return "";
+    }
+}
+function sleep(ms) {
+    return new Promise((res) => setTimeout(res, ms));
+}
+async function resolveFiles() {
+    try {
+        await fs__namespace.access(CREDENTIALS_DIR);
+    }
+    catch (_e) {
+        await fs__namespace.mkdir(CREDENTIALS_DIR);
+    }
+    try {
+        await fs__namespace.access(CREDENTIALS_FILE);
+    }
+    catch (e) {
+        await fs__namespace.writeFile(CREDENTIALS_FILE, "");
+    }
+}
+
+var createContext = (coreRoot, clientRoot) => ({
+    core: {
+        rootDir: coreRoot,
+        templatesDir: path__namespace.resolve(coreRoot, "templates"),
+        configsDir: path__namespace.resolve(coreRoot, "configs"),
+    },
+    client: {
+        rootDir: clientRoot,
+        buildDir: path__namespace.resolve(clientRoot, ".embeddable-build"),
+        srcDir: path__namespace.resolve(clientRoot, "src"),
+        tmpDir: path__namespace.resolve(clientRoot, ".embeddable-tmp"),
+        componentDir: path__namespace.resolve(clientRoot, ".embeddable-build", "component"),
+        stencilBuild: path__namespace.resolve(clientRoot, ".embeddable-build", "dist", "embeddable-wrapper"),
+        archiveFile: path__namespace.resolve(clientRoot, "embeddable-build.zip"),
+    },
+    outputOptions: {
+        typesEntryPointFilename: "embeddable-types-entry-point.js",
+    },
+});
+
+const oraP = import('ora');
+const inquirerSelect = import('@inquirer/select');
+const EMB_YAML_FILE_REGEX = /^(.*)\.emb\.ya?ml$/;
+let ora;
+var push = async () => {
+    ora = (await oraP).default;
+    const ctx = createContext(path__namespace.resolve(__dirname, ".."), process.cwd());
+    const token = await verify(ctx);
+    const { workspaceId, name: workspaceName } = await selectWorkspace(token);
+    const spinnerArchive = ora("archivation...").start();
+    const filesList = await sdkUtils.findFiles(ctx.client.srcDir, EMB_YAML_FILE_REGEX);
+    await archive(ctx, filesList);
+    spinnerArchive.succeed("archivation competed");
+    const spinnerPushing = ora("publishing...").start();
+    await sendBuild(ctx, { workspaceId, token });
+    spinnerPushing.succeed(`published to ${workspaceName}`);
+};
+async function selectWorkspace(token) {
+    const workspaceSpinner = ora({
+        text: "Fetching workspaces...",
+        color: "green",
+        discardStdin: false,
+    }).start();
+    const availableWorkspaces = await getWorkspaces(token);
+    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) => ({
+                name: `${workspace.name} (${workspace.workspaceId})`,
+                value: workspace,
+            })),
+        });
+    }
+    workspaceSpinner.succeed(`Workspace: ${selectedWorkspace.name} (${selectedWorkspace.workspaceId})`);
+    return selectedWorkspace;
+}
+async function verify(ctx) {
+    try {
+        await fs__namespace.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;
+}
+async function archive(ctx, yamlFiles) {
+    const output = fsSync__namespace.createWriteStream(ctx.client.archiveFile);
+    const _archiver = archiver__namespace.create("zip", {
+        zlib: { level: 9 },
+    });
+    _archiver.pipe(output);
+    _archiver.directory(ctx.client.buildDir, false);
+    for (const fileData of yamlFiles) {
+        _archiver.file(fileData[1], { name: `${fileData[0]}.emb.yaml` });
+    }
+    await _archiver.finalize();
+    return new Promise((resolve, _reject) => {
+        output.on("close", resolve);
+    });
+}
+async function sendBuild(ctx, { workspaceId, token }) {
+    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(`https://api.embeddable.com/sdk/upload-files?workspaceId=${workspaceId}`, form, {
+        headers: {
+            "Content-Type": "multipart/form-data",
+            Authorization: `Bearer ${token}`,
+        },
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+    });
+    await fs__namespace.rm(ctx.client.archiveFile);
+}
+async function getWorkspaces(token) {
+    try {
+        return axios
+            .get("https://api.embeddable.com/workspace", {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        })
+            .then((res) => res.data);
+    }
+    catch (e) {
+        console.error(e);
+        return [];
+    }
+}
+
+exports.build = build;
+exports.login = login;
+exports.push = push;

package/dist/login.d.ts

@@ -0,0 +1,3 @@
+declare const _default: () => Promise<void>;
+export default _default;
+export declare function getToken(): Promise<any>;

package/dist/prepare.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (ctx: any) => Promise<void>;
+export default _default;

package/dist/push.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/dist/validate.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (ctx: any) => Promise<void>;
+export default _default;

package/lib/defineConfig.d.ts

@@ -0,0 +1,22 @@
+export declare const defineConfig: ({ plugins }: {
+    plugins: any;
+}) => {
+    core: {
+        rootDir: string;
+        templatesDir: string;
+        configsDir: string;
+    };
+    client: {
+        rootDir: string;
+        buildDir: string;
+        srcDir: string;
+        tmpDir: string;
+        componentDir: string;
+        stencilBuild: string;
+        archiveFile: string;
+    };
+    outputOptions: {
+        typesEntryPointFilename: string;
+    };
+    plugins: any;
+};

package/lib/embedType.d.ts

@@ -1,4 +1,17 @@
-export declare const embedType: (typeName: string, typeConfig: {
+export declare const embedType: (typeName: string, typeConfig: TypeConfig) => {
+    toString: () => string;
+    typeConfig: TypeConfig;
+};
+export type TypeConfig = {
     label: string;
+    embeddableDataType?: typeof STRING | typeof NUMBER | typeof BOOLEAN | typeof DATE | typeof DATE_RANGE;
     toString: (_: any) => string;
-}) => void;
+    deserialize?: (_: any) => any;
+    toEmbeddableDataType?: (_: any) => any;
+};
+declare const STRING = "string";
+declare const NUMBER = "number";
+declare const BOOLEAN = "boolean";
+declare const DATE = "date";
+declare const DATE_RANGE = "dateRange";
+export {};