@embeddable.com/sdk-core 0.1.1 → 1.0.0

package/scripts/buildTypes.js

@@ -4,49 +4,58 @@ const vite = require("vite");
 
 const { findEmbFiles } = require("./findEmbFiles");
 
-
 const EMB_TYPE_FILE_REGEX = /^(.*)\.type\.emb\.[jt]s$/;
+const EMB_OPTIONS_FILE_REGEX = /^(.*)\.options\.emb\.[jt]s$/;
 
 async function buildTypes(ctx) {
-    await generate(ctx);
+  await generate(ctx);
 
-    await build(ctx);
+  await build(ctx);
 
-    await cleanup(ctx);
+  await cleanup(ctx);
 }
 
 module.exports = { buildTypes };
 
-
 async function generate(ctx) {
-    const typeFiles = await findEmbFiles(ctx.client.srcDir, EMB_TYPE_FILE_REGEX);
-
-    const typeImports = typeFiles.map(([fileName, filePath]) =>
-        `import './${path.relative(ctx.client.rootDir, filePath)}';`
-    ).join('\n');
-
-    await fs.writeFile(
-        path.resolve(ctx.client.rootDir, ctx.outputOptions.typesEntryPointFilename),
-        typeImports
-    );
+  const typeFiles = await findEmbFiles(ctx.client.srcDir, EMB_TYPE_FILE_REGEX);
+  const optionsFiles = await findEmbFiles(
+    ctx.client.srcDir,
+    EMB_OPTIONS_FILE_REGEX,
+  );
+
+  const typeImports = typeFiles
+    .concat(optionsFiles)
+    .map(
+      ([fileName, filePath]) =>
+        `import './${path.relative(ctx.client.rootDir, filePath)}';`,
+    )
+    .join("\n");
+
+  await fs.writeFile(
+    path.resolve(ctx.client.rootDir, ctx.outputOptions.typesEntryPointFilename),
+    typeImports,
+  );
 }
 
 async function build(ctx) {
-    process.chdir(ctx.client.rootDir);
-
-    await vite.build({
-        build: {
-            emptyOutDir: false,
-            lib: {
-                entry: `./${ctx.outputOptions.typesEntryPointFilename}`,
-                formats: ['es'],
-                fileName: 'embeddable-types'
-            },
-            outDir: '.embeddable-build/'
-        },
-    });
+  process.chdir(ctx.client.rootDir);
+
+  await vite.build({
+    build: {
+      emptyOutDir: false,
+      lib: {
+        entry: `./${ctx.outputOptions.typesEntryPointFilename}`,
+        formats: ["es"],
+        fileName: "embeddable-types",
+      },
+      outDir: ".embeddable-build/",
+    },
+  });
 }
 
 async function cleanup(ctx) {
-    await fs.rm(path.resolve(ctx.client.rootDir, 'embeddable-types-entry-point.js'));
+  await fs.rm(
+    path.resolve(ctx.client.rootDir, "embeddable-types-entry-point.js"),
+  );
 }

package/scripts/cleanup.js

@@ -1,30 +1,27 @@
-const fs = require('fs/promises');
+const fs = require("fs/promises");
 const path = require("path");
 
-async function cleanup (ctx) {
-    await extractBuild(ctx);
+async function cleanup(ctx) {
+  await extractBuild(ctx);
 
-    await removeObsoleteDir(ctx.client.buildDir);
+  await removeObsoleteDir(ctx.client.buildDir);
 
-    await moveBuildTOBuildDir(ctx);
+  await moveBuildTOBuildDir(ctx);
 }
 
 module.exports = { cleanup };
 
-
 async function extractBuild(ctx) {
-    await fs.rename(
-        path.resolve(ctx.client.buildDir, ctx.client.stencilBuild),
-        ctx.client.tmpDir
-    );
+  await fs.rename(
+    path.resolve(ctx.client.buildDir, ctx.client.stencilBuild),
+    ctx.client.tmpDir,
+  );
 }
 
-
 async function removeObsoleteDir(dir) {
-    await fs.rm(dir, { recursive: true });
+  await fs.rm(dir, { recursive: true });
 }
 
-
 async function moveBuildTOBuildDir(ctx) {
-    await fs.rename(ctx.client.tmpDir, ctx.client.buildDir);
+  await fs.rename(ctx.client.tmpDir, ctx.client.buildDir);
 }

package/scripts/createContext.js

@@ -1,22 +1,27 @@
-const path = require('path');
+const path = require("path");
 
-function createContext (coreRoot, clientRoot) {
-    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")
-        }
-    }
+function createContext(coreRoot, clientRoot) {
+  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"),
+    },
+  };
 }
 
-module.exports = { createContext };
+module.exports = { createContext };

package/scripts/findEmbFiles.js

@@ -1,33 +1,32 @@
 const fs = require("fs/promises");
 const path = require("path");
 
-async function findEmbFiles (initialSrcDir, regex) {
-    const filesList = [];
+async function findEmbFiles(initialSrcDir, regex) {
+  const filesList = [];
 
-    async function findEmbFilesRec(srcDir) {
-        const allFiles = await fs.readdir(srcDir);
+  async function findEmbFilesRec(srcDir) {
+    const allFiles = await fs.readdir(srcDir);
 
-        for (const file of allFiles) {
-            const filePath = path.join(srcDir, file)
+    for (const file of allFiles) {
+      const filePath = path.join(srcDir, file);
 
-            const status = await fs.lstat(filePath);
+      const status = await fs.lstat(filePath);
 
-            if (status.isDirectory()) {
-                await findEmbFilesRec(filePath)
-            }
+      if (status.isDirectory()) {
+        await findEmbFilesRec(filePath);
+      }
 
-            const fileName = file.match(regex);
+      const fileName = file.match(regex);
 
-            if (fileName) {
-                filesList.push([fileName[1], filePath]);
-            }
-        }
+      if (fileName) {
+        filesList.push([fileName[1], filePath]);
+      }
     }
+  }
 
-    await findEmbFilesRec(initialSrcDir);
+  await findEmbFilesRec(initialSrcDir);
 
-
-    return filesList;
+  return filesList;
 }
 
 module.exports = { findEmbFiles };

package/scripts/generate.js

@@ -4,64 +4,69 @@ const path = require("path");
 const stencilNodeApi = require("@stencil/core/sys/node");
 const stencil = require("@stencil/core/cli");
 
-const STYLE_IMPORTS_TOKEN = '{{STYLES_IMPORT}}';
-const RENDER_IMPORT_TOKEN = '{{RENDER_IMPORT}}';
+const STYLE_IMPORTS_TOKEN = "{{STYLES_IMPORT}}";
+const RENDER_IMPORT_TOKEN = "{{RENDER_IMPORT}}";
 
 const NODE_LOGGER = stencilNodeApi.createNodeLogger({ process: process });
-const NODE_SYS = stencilNodeApi.createNodeSys({ process: process, logger: NODE_LOGGER });
+const NODE_SYS = stencilNodeApi.createNodeSys({
+  process: process,
+  logger: NODE_LOGGER,
+});
 
 async function generate(ctx) {
-    await injectCSS(ctx);
+  await injectCSS(ctx);
 
-    await injectBundleRender(ctx);
+  await injectBundleRender(ctx);
 
-    await runStencil(ctx);
+  await runStencil(ctx);
 }
 
 module.exports = { generate };
 
-async function injectCSS (ctx) {
-    const CUSTOMER_BUILD = path.resolve(ctx.client.buildDir, ctx.pluginOptions.outDir);
-    const allFiles = await fs.readdir(CUSTOMER_BUILD);
-
-    const cssFilesImportsStr = allFiles
-        .filter(fileName => fileName.endsWith('.css'))
-        .map(fileName => `@import '../${ctx.pluginOptions.outDir}/${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 injectCSS(ctx) {
+  const CUSTOMER_BUILD = path.resolve(
+    ctx.client.buildDir,
+    ctx.pluginOptions.outDir,
+  );
+  const allFiles = await fs.readdir(CUSTOMER_BUILD);
+
+  const cssFilesImportsStr = allFiles
+    .filter((fileName) => fileName.endsWith(".css"))
+    .map((fileName) => `@import '../${ctx.pluginOptions.outDir}/${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) {
-    const importStr = `import render from '../${ctx.pluginOptions.outDir}/${ctx.pluginOptions.renderFunctionFileName}';`;
+  const importStr = `import render from '../${ctx.pluginOptions.outDir}/${ctx.pluginOptions.renderFunctionFileName}';`;
 
-    const content = await fs.readFile(
-        path.resolve(ctx.core.templatesDir, 'component.tsx.template'),
-        'utf8'
-    );
+  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)
-    );
+  await fs.writeFile(
+    path.resolve(ctx.client.componentDir, "component.tsx"),
+    content.replace(RENDER_IMPORT_TOKEN, importStr),
+  );
 }
 
-
 async function runStencil(ctx) {
-    process.chdir(ctx.client.buildDir);
-
-    await stencil.run({
-        args: ['build'],
-        logger: NODE_LOGGER,
-        sys: NODE_SYS,
-        checkVersion: stencilNodeApi.checkVersion,
-    });
-}
+  process.chdir(ctx.client.buildDir);
+
+  await stencil.run({
+    args: ["build"],
+    logger: NODE_LOGGER,
+    sys: NODE_SYS,
+    checkVersion: stencilNodeApi.checkVersion,
+  });
+}

package/scripts/globalCleanup.js

@@ -0,0 +1,13 @@
+const fsP = require("node:fs/promises");
+const fs = require("node:fs")
+const path = require("node:path");
+async function globalCleanup(ctx) {
+    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);
+}
+
+module.exports = { globalCleanup };

package/scripts/index.js

@@ -3,11 +3,15 @@ const { buildTypes } = require("./buildTypes");
 const { findEmbFiles } = require("./findEmbFiles");
 const { login } = require("./login");
 const { push } = require("./push");
+const { validate } = require("./validate");
+const { globalCleanup } = require("./globalCleanup");
 
 module.exports = {
-    build,
-    buildTypes,
-    findEmbFiles,
-    login,
-    push
-}
+  build,
+  buildTypes,
+  findEmbFiles,
+  login,
+  push,
+  validate,
+  globalCleanup,
+};

package/scripts/login.js

@@ -1,76 +1,93 @@
 const path = require("path");
 const os = require("os");
 const fs = require("fs/promises");
-const prompt = require('prompt');
-const axios = require('axios');
-
-const CREDENTIALS_DIR = path.resolve(os.homedir(), '.embeddable');
-const CREDENTIALS_FILE = path.resolve(CREDENTIALS_DIR, 'credentials');
-
-const PROMPT_SCHEMA = {
-    properties: {
-        username: {
-            description: 'embeddable user name',
-            type: 'string',
-            required: true
-        },
-        password: {
-            description: 'embeddable user password',
-            type: 'string',
-            hidden: true,
-            replace: '*',
-            required: true
-        }
-    }
-};
+const axios = require("axios");
+const oraP = import("ora");
+const openP = import("open");
 
-async function login () {
-    await resolveFiles();
+const CREDENTIALS_DIR = path.resolve(os.homedir(), ".embeddable");
+const CREDENTIALS_FILE = path.resolve(CREDENTIALS_DIR, "credentials");
 
-    prompt.start();
+const AUTH0_DOMAIN = "embeddable-dev.eu.auth0.com";
+const AUTH0_CLIENT_ID = "xOKco5ztFCpWn54bJbFkAcT8mV4LLcpG";
 
-    const { username, password } = await prompt.get(PROMPT_SCHEMA);
+async function login() {
+  const ora = (await oraP).default;
+  const open = (await openP).default
 
-    const authResponse = await axios.post(
-        'https://metadata.embeddable.com/auth/token', // TODO: hardcoded for now.
-        { username, password }
-    );
+  await resolveFiles();
 
-    const token = authResponse.data;
+  const deviceCodePayload = {
+    client_id: AUTH0_CLIENT_ID,
+    audience: "https://api.embeddable.com/",
+  };
 
-    if (!token) {
-        prompt.stop();
-        console.log('Invalid credentials');
-        process.exit();
-    }
+  const deviceCodeResponse = await axios.post(
+    `https://${AUTH0_DOMAIN}/oauth/device/code`,
+    deviceCodePayload,
+  );
 
-    await fs.writeFile(CREDENTIALS_FILE, JSON.stringify({ token }));
-}
+  const tokenPayload = {
+    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+    device_code: deviceCodeResponse.data["device_code"],
+    client_id: AUTH0_CLIENT_ID,
+  };
 
-async function getToken() {
+  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 rawCredentials = await fs.readFile(CREDENTIALS_FILE, 'utf-8');
-        const credentials = JSON.parse(rawCredentials.toString());
+      const tokenResponse = await axios.post(
+        `https://${AUTH0_DOMAIN}/oauth/token`,
+        tokenPayload,
+      );
+      await fs.writeFile(CREDENTIALS_FILE, JSON.stringify(tokenResponse.data));
+      authenticationSpinner.succeed("you are successfully authenticated now!");
+      break;
+    } catch (e) {
+      if (e.response.data?.error !== "authorization_pending") {
+        authenticationSpinner.fail("authentication failed. please try again.");
+        process.exit(1);
+      }
 
-        return credentials?.token ?? '';
-    }  catch (_e) {
-        return '';
+      await sleep(deviceCodeResponse.data["interval"] * 1000);
     }
+  }
+}
+
+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 "";
+  }
 }
 
 module.exports = { login, getToken };
 
+function sleep(ms) {
+  return new Promise((res) => setTimeout(res, ms));
+}
 
-async function resolveFiles () {
-    try {
-        await fs.access(CREDENTIALS_DIR);
-    } catch (_e) {
-        await fs.mkdir(CREDENTIALS_DIR);
-    }
+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, '');
-    }
+  try {
+    await fs.access(CREDENTIALS_FILE);
+  } catch (e) {
+    await fs.writeFile(CREDENTIALS_FILE, "");
+  }
 }

package/scripts/prepare.js

@@ -1,26 +1,27 @@
-const fsSync = require('fs');
-const fs = require('fs/promises');
+const fsSync = require("fs");
+const fs = require("fs/promises");
 
-async function prepare (ctx) {
-    await removeIfExists(ctx);
+async function prepare(ctx) {
+  await removeIfExists(ctx);
 
-    await copyStencilConfigsToClient(ctx);
+  await copyStencilConfigsToClient(ctx);
 
-    await createComponentDir(ctx.client.componentDir);
+  await createComponentDir(ctx.client.componentDir);
 }
 
-module.exports = { prepare }
+module.exports = { prepare };
 
 async function removeIfExists(ctx) {
-    if (ctx.pluginOptions) return;
+  if (ctx.pluginOptions) return;
 
-    if (fsSync.existsSync(ctx.client.buildDir)) await fs.rm(ctx.client.buildDir, { recursive: true });
+  if (fsSync.existsSync(ctx.client.buildDir))
+    await fs.rm(ctx.client.buildDir, { recursive: true });
 }
 
 async function copyStencilConfigsToClient(ctx) {
-    await fs.cp(ctx.core.configsDir, ctx.client.buildDir, { recursive: true });
+  await fs.cp(ctx.core.configsDir, ctx.client.buildDir, { recursive: true });
 }
 
 async function createComponentDir(dir) {
-    await fs.mkdir(dir);
-}
+  await fs.mkdir(dir);
+}