@superblocksteam/util 1.13.0 → 1.14.0

package/dist/component-configs.js

@@ -41,55 +41,51 @@ exports.getComponentConfigs = getComponentConfigs;
 const node_child_process_1 = require("node:child_process");
 const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
+const util = __importStar(require("node:util"));
 const fs = __importStar(require("fs-extra"));
 const mimeTypes = __importStar(require("mime-types"));
 const constants_1 = require("./constants");
 const generate_component_types_1 = require("./generate-component-types");
 const validation_1 = require("./validation");
-const compileTypeScript = (inputFilePath, outputDir) => {
-    return new Promise((resolve, reject) => {
-        try {
-            const tscPath = require.resolve("typescript/bin/tsc");
-            if (tscPath) {
-                (0, node_child_process_1.execFile)("node", [
-                    tscPath,
-                    node_path_1.default.resolve(inputFilePath),
-                    "--outDir",
-                    outputDir,
-                    "--jsx",
-                    "react-jsx",
-                    "--target",
-                    "es2019",
-                    "--esModuleInterop",
-                    "true",
-                    "--moduleResolution",
-                    "node",
-                    "--module",
-                    "commonjs",
-                    "--strict",
-                    "true",
-                    "--skipLibCheck",
-                    "true",
-                ], (error, stdout, stderr) => {
-                    if (error) {
-                        // Print any Typescript output to the user, such as errors
-                        console.log(stdout);
-                        reject(`Compilation failed: ${error.message}`);
-                        return;
-                    }
-                    if (stderr) {
-                        reject(`Error during compilation: ${stderr}`);
-                        return;
-                    }
-                    resolve("Compilation successful!");
-                });
+const asyncExecFile = util.promisify(node_child_process_1.execFile);
+async function compileTypeScript(inputFilePath, outputDir) {
+    try {
+        const tscPath = require.resolve("typescript/bin/tsc");
+        if (tscPath) {
+            const result = await asyncExecFile("node", [
+                tscPath,
+                node_path_1.default.resolve(inputFilePath),
+                "--outDir",
+                outputDir,
+                "--jsx",
+                "react-jsx",
+                "--target",
+                "es2019",
+                "--esModuleInterop",
+                "true",
+                "--moduleResolution",
+                "node",
+                "--module",
+                "commonjs",
+                "--strict",
+                "true",
+                "--skipLibCheck",
+                "true",
+            ]);
+            if (result.stdout || result.stderr) {
+                return {
+                    output: result.stdout || result.stderr,
+                };
             }
         }
-        catch {
-            reject(new Error("Could not find TypeScript, please install it globally (npm install -g typescript)"));
-        }
-    });
-};
+    }
+    catch (error) {
+        return {
+            output: error.stdout || error.stderr,
+        };
+    }
+    return {};
+}
 async function getFolderPaths() {
     try {
         const folderPaths = await fs.readdir(constants_1.CUSTOM_COMPONENTS_PATH, {
@@ -122,35 +118,35 @@ async function getComponentConfigs(generateTypesFiles) {
         catch {
             // Noop because there is a fallback
         }
-        try {
-            // This is a tad complex to explain this hack but here's the context:
-            // We want to be able to hot reload the config.ts file, but we can't import it directly
-            // because it is going to get cached in the module cache and we dont have access to it to clear it
-            // so instead we copy the file to a new location with a random name and import that
-            // this is technically a memory leak, but you shouldnt really have a hot module server running forever
-            const rawPath = `${ccpath}/config.ts`;
-            const fileName = node_path_1.default.resolve(rawPath);
-            const outputDirectory = node_path_1.default.resolve(`${node_os_1.default.tmpdir()}/superblocks/${ccpath}/config.timestamp-${Date.now()}-${Math.random()
-                .toString(16)
-                .slice(2)}`);
-            await fs.ensureDir(outputDirectory);
-            await compileTypeScript(fileName, outputDirectory);
-            console.log(`Typescript compiled to ${ccpath}`);
-            const config = (await Promise.resolve(`${outputDirectory + "/config.js"}`).then(s => __importStar(require(s)))).default;
-            const isValid = (0, validation_1.validateCustomComponents)(config);
-            if (!isValid.valid) {
-                // Not throwing because we don't need a stack trace here
-                console.log(`Invalid config.ts file found`);
-                console.log(isValid.message);
-                hasError = true;
+        // This is a tad complex to explain this hack but here's the context:
+        // We want to be able to hot reload the config.ts file, but we can't import it directly
+        // because it is going to get cached in the module cache and we dont have access to it to clear it
+        // so instead we copy the file to a new location with a random name and import that
+        // this is technically a memory leak, but you shouldnt really have a hot module server running forever
+        const rawPath = `${ccpath}/config.ts`;
+        const fileName = node_path_1.default.resolve(rawPath);
+        const outputDirectory = node_path_1.default.resolve(`${node_os_1.default.tmpdir()}/superblocks/${ccpath}/config.timestamp-${Date.now()}-${Math.random()
+            .toString(16)
+            .slice(2)}`);
+        await fs.ensureDir(outputDirectory);
+        const compilationResult = await compileTypeScript(fileName, outputDirectory);
+        if (compilationResult.output) {
+            hasError = true;
+            if (compilationResult.output.includes(`Cannot find module`)) {
+                throw new Error("Could not find a module in node_modules. You likely need to run 'npm install'");
             }
-            return { ccpath, config };
+            throw new Error(compilationResult.output);
         }
-        catch (e) {
-            console.error(e);
-            console.error(e.message);
-            throw e;
+        console.log(`Typescript compiled to ${ccpath}`);
+        const config = (await Promise.resolve(`${outputDirectory + "/config.js"}`).then(s => __importStar(require(s)))).default;
+        const isValid = (0, validation_1.validateCustomComponents)(config);
+        if (!isValid.valid) {
+            // Not throwing because we don't need a stack trace here
+            console.log(`Invalid config.ts file found`);
+            console.log(isValid.message);
+            hasError = true;
         }
+        return { ccpath, config };
     });
     const configFiles = await Promise.all(promiseConfigFiles);
     if (generateTypesFiles) {

package/dist/constants.d.ts

@@ -9,3 +9,9 @@ export declare class FileAccessError extends Error {
 export declare class NotFoundError extends Error {
     constructor(message: string);
 }
+export declare class BadRequestError extends Error {
+    constructor(message: string);
+}
+export declare class ForbiddenError extends Error {
+    constructor(message: string);
+}

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotFoundError = exports.FileAccessError = exports.CUSTOM_COMPONENTS_PATH = exports.ROOT_CONFIG_RELATIVE_PATH = exports.RESOURCE_CONFIG_PATH = exports.TOKEN_CONFIG_PATH = exports.SUPERBLOCKS_HOME_FOLDER_NAME = void 0;
+exports.ForbiddenError = exports.BadRequestError = exports.NotFoundError = exports.FileAccessError = exports.CUSTOM_COMPONENTS_PATH = exports.ROOT_CONFIG_RELATIVE_PATH = exports.RESOURCE_CONFIG_PATH = exports.TOKEN_CONFIG_PATH = exports.SUPERBLOCKS_HOME_FOLDER_NAME = void 0;
 exports.SUPERBLOCKS_HOME_FOLDER_NAME = ".superblocks";
 exports.TOKEN_CONFIG_PATH = ".superblocks/auth.json";
 exports.RESOURCE_CONFIG_PATH = ".superblocks/superblocks.json";
@@ -33,3 +33,17 @@ class NotFoundError extends Error {
     }
 }
 exports.NotFoundError = NotFoundError;
+class BadRequestError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BadRequestError";
+    }
+}
+exports.BadRequestError = BadRequestError;
+class ForbiddenError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ForbiddenError";
+    }
+}
+exports.ForbiddenError = ForbiddenError;

package/dist/events.d.ts

@@ -7,5 +7,6 @@ export declare enum ComponentEvent {
     COMMITS = "commits",
     PUSH = "push",
     REGISTER = "register",
-    UPLOAD = "upload"
+    UPLOAD = "upload",
+    DEPLOY = "deploy"
 }

package/dist/events.js

@@ -12,4 +12,5 @@ var ComponentEvent;
     ComponentEvent["PUSH"] = "push";
     ComponentEvent["REGISTER"] = "register";
     ComponentEvent["UPLOAD"] = "upload";
+    ComponentEvent["DEPLOY"] = "deploy";
 })(ComponentEvent || (exports.ComponentEvent = ComponentEvent = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superblocksteam/util",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "main": "dist/index.js",
   "homepage": "https://www.superblocks.com",
   "license": "Superblocks Community Software License",

package/src/component-configs.ts

@@ -1,63 +1,55 @@
 import { execFile } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
+import * as util from "node:util";
 import * as fs from "fs-extra";
 import * as mimeTypes from "mime-types";
 import { CUSTOM_COMPONENTS_PATH } from "./constants";
 import { generateComponentTypesFile } from "./generate-component-types";
 import { validateCustomComponents } from "./validation";
 
-const compileTypeScript = (inputFilePath: string, outputDir: string) => {
-  return new Promise((resolve, reject) => {
-    try {
-      const tscPath = require.resolve("typescript/bin/tsc");
-      if (tscPath) {
-        execFile(
-          "node",
-          [
-            tscPath,
-            path.resolve(inputFilePath),
-            "--outDir",
-            outputDir,
-            "--jsx",
-            "react-jsx",
-            "--target",
-            "es2019",
-            "--esModuleInterop",
-            "true",
-            "--moduleResolution",
-            "node",
-            "--module",
-            "commonjs",
-            "--strict",
-            "true",
-            "--skipLibCheck",
-            "true",
-          ],
-          (error, stdout, stderr) => {
-            if (error) {
-              // Print any Typescript output to the user, such as errors
-              console.log(stdout);
-              reject(`Compilation failed: ${error.message}`);
-              return;
-            }
-            if (stderr) {
-              reject(`Error during compilation: ${stderr}`);
-              return;
-            }
-            resolve("Compilation successful!");
-          },
-        );
+const asyncExecFile = util.promisify(execFile);
+
+async function compileTypeScript(
+  inputFilePath: string,
+  outputDir: string,
+): Promise<{ output?: string }> {
+  try {
+    const tscPath = require.resolve("typescript/bin/tsc");
+    if (tscPath) {
+      const result = await asyncExecFile("node", [
+        tscPath,
+        path.resolve(inputFilePath),
+        "--outDir",
+        outputDir,
+        "--jsx",
+        "react-jsx",
+        "--target",
+        "es2019",
+        "--esModuleInterop",
+        "true",
+        "--moduleResolution",
+        "node",
+        "--module",
+        "commonjs",
+        "--strict",
+        "true",
+        "--skipLibCheck",
+        "true",
+      ]);
+      if (result.stdout || result.stderr) {
+        return {
+          output: result.stdout || result.stderr,
+        };
       }
-    } catch {
-      reject(
-        new Error(
-          "Could not find TypeScript, please install it globally (npm install -g typescript)",
-        ),
-      );
     }
-  });
-};
+  } catch (error: any) {
+    return {
+      output: error.stdout || error.stderr,
+    };
+  }
+  return {};
+}
 
 async function getFolderPaths() {
   try {
@@ -102,38 +94,43 @@ export async function getComponentConfigs(
     } catch {
       // Noop because there is a fallback
     }
-
-    try {
-      // This is a tad complex to explain this hack but here's the context:
-      // We want to be able to hot reload the config.ts file, but we can't import it directly
-      // because it is going to get cached in the module cache and we dont have access to it to clear it
-      // so instead we copy the file to a new location with a random name and import that
-      // this is technically a memory leak, but you shouldnt really have a hot module server running forever
-      const rawPath = `${ccpath}/config.ts`;
-      const fileName = path.resolve(rawPath);
-      const outputDirectory = path.resolve(
-        `${os.tmpdir()}/superblocks/${ccpath}/config.timestamp-${Date.now()}-${Math.random()
-          .toString(16)
-          .slice(2)}`,
-      );
-      await fs.ensureDir(outputDirectory);
-      await compileTypeScript(fileName, outputDirectory);
-      console.log(`Typescript compiled to ${ccpath}`);
-      const config = (await import(outputDirectory + "/config.js")).default;
-
-      const isValid = validateCustomComponents(config);
-      if (!isValid.valid) {
-        // Not throwing because we don't need a stack trace here
-        console.log(`Invalid config.ts file found`);
-        console.log(isValid.message);
-        hasError = true;
+    // This is a tad complex to explain this hack but here's the context:
+    // We want to be able to hot reload the config.ts file, but we can't import it directly
+    // because it is going to get cached in the module cache and we dont have access to it to clear it
+    // so instead we copy the file to a new location with a random name and import that
+    // this is technically a memory leak, but you shouldnt really have a hot module server running forever
+    const rawPath = `${ccpath}/config.ts`;
+    const fileName = path.resolve(rawPath);
+    const outputDirectory = path.resolve(
+      `${os.tmpdir()}/superblocks/${ccpath}/config.timestamp-${Date.now()}-${Math.random()
+        .toString(16)
+        .slice(2)}`,
+    );
+    await fs.ensureDir(outputDirectory);
+    const compilationResult = await compileTypeScript(
+      fileName,
+      outputDirectory,
+    );
+    if (compilationResult.output) {
+      hasError = true;
+      if (compilationResult.output.includes(`Cannot find module`)) {
+        throw new Error(
+          "Could not find a module in node_modules. You likely need to run 'npm install'",
+        );
       }
-      return { ccpath, config };
-    } catch (e: any) {
-      console.error(e);
-      console.error(e.message);
-      throw e;
+      throw new Error(compilationResult.output);
+    }
+    console.log(`Typescript compiled to ${ccpath}`);
+    const config = (await import(outputDirectory + "/config.js")).default;
+
+    const isValid = validateCustomComponents(config);
+    if (!isValid.valid) {
+      // Not throwing because we don't need a stack trace here
+      console.log(`Invalid config.ts file found`);
+      console.log(isValid.message);
+      hasError = true;
     }
+    return { ccpath, config };
   });
   const configFiles = await Promise.all(promiseConfigFiles);
   if (generateTypesFiles) {

package/src/constants.ts

@@ -32,3 +32,17 @@ export class NotFoundError extends Error {
     this.name = "FileNotFoundError";
   }
 }
+
+export class BadRequestError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "BadRequestError";
+  }
+}
+
+export class ForbiddenError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ForbiddenError";
+  }
+}

package/src/events.ts

@@ -8,4 +8,5 @@ export enum ComponentEvent {
   PUSH = "push",
   REGISTER = "register",
   UPLOAD = "upload",
+  DEPLOY = "deploy",
 }