@superblocksteam/util 2.0.162 → 2.0.163-next.0

package/src/component-configs.ts

@@ -1,163 +0,0 @@
-import { execFile } from "node:child_process";
-import os from "node:os";
-import path from "node:path";
-import * as util from "node:util";
-
-import fs from "fs-extra";
-import mimeTypes from "mime-types";
-
-import { CUSTOM_COMPONENTS_PATH } from "./constants.js";
-import { generateComponentTypesFile } from "./generate-component-types.js";
-import { validateCustomComponents } from "./validation.js";
-
-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",
-        "es2022",
-        "--strict",
-        "true",
-        "--skipLibCheck",
-        "true",
-      ]);
-      if (result.stdout || result.stderr) {
-        return {
-          output: result.stdout || result.stderr,
-        };
-      }
-    }
-  } catch (error: any) {
-    return {
-      output: error.stdout || error.stderr,
-    };
-  }
-  return {};
-}
-
-async function getFolderPaths() {
-  try {
-    const folderPaths = await fs.readdir(CUSTOM_COMPONENTS_PATH, {
-      withFileTypes: true,
-    });
-    // filter out any non-directory items
-    const directories = folderPaths.filter(
-      (dirent) =>
-        dirent.isDirectory() ||
-        (dirent.isSymbolicLink() &&
-          fs
-            .statSync(path.join(CUSTOM_COMPONENTS_PATH, dirent.name))
-            .isDirectory()),
-    );
-    // map each directory to its path
-    const folderPathsArray = directories.map((dirent) =>
-      path.join(CUSTOM_COMPONENTS_PATH, dirent.name),
-    );
-    return folderPathsArray;
-  } catch {
-    throw new Error(
-      "Could not access component directory, check your permissions",
-    );
-  }
-}
-
-export async function getComponentConfigs(
-  generateTypesFiles: boolean,
-): Promise<{
-  configs: Record<string, any>;
-  hasError: boolean;
-}> {
-  const folderPaths = await getFolderPaths();
-  let hasError = false;
-  const promiseConfigFiles = folderPaths.map(async (ccpath) => {
-    const absPath = path.resolve(ccpath);
-    try {
-      const config = await fs.readJSON(`${absPath}/config.json`);
-      console.log(`Found component in ${absPath}`);
-      return { ccpath, config };
-    } catch {
-      // Noop because there is a fallback
-    }
-    // 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'",
-        );
-      }
-      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) {
-    for (const { config, ccpath } of configFiles) {
-      const typesFileContents = generateComponentTypesFile(config);
-      await fs.writeFile(`${ccpath}/types.ts`, typesFileContents);
-      console.log(`Generated ${ccpath}/types.ts`);
-    }
-  }
-  const configs = configFiles
-    .filter((component) => component.config !== null)
-    .reduce((acc: Record<string, any>, { config }) => {
-      acc[config.id] = config;
-      return acc;
-    }, {});
-  return {
-    configs,
-    hasError,
-  };
-}
-
-export const getContentType = (filename: string): string => {
-  const mimeType = mimeTypes.lookup(filename);
-  if (!mimeType) {
-    return "";
-  }
-  return mimeType as string;
-};

package/src/constants.ts

@@ -1,34 +0,0 @@
-export const SUPERBLOCKS_HOME_FOLDER_NAME = ".superblocks";
-export const TOKEN_CONFIG_PATH = ".superblocks/auth.json";
-export const RESOURCE_CONFIG_PATH = ".superblocks/superblocks.json";
-export const DEV_ENVIRONMENT_CONFIG_PATH = ".superblocks/dev-environment.json";
-
-export const CUSTOM_COMPONENTS_PATH = "components";
-
-export class FileAccessError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "FileAccessError";
-  }
-}
-
-export class NotFoundError extends Error {
-  constructor(message: string) {
-    super(message);
-    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/data-types.ts

@@ -1,25 +0,0 @@
-export type DataType = "string" | "number" | "boolean" | "any";
-
-interface TypeInfo {
-  tsType: string;
-  prompt: string;
-}
-
-export const dataTypeDefinions: Record<DataType, TypeInfo> = {
-  string: {
-    tsType: "string",
-    prompt: "string",
-  },
-  number: {
-    tsType: "number",
-    prompt: "number",
-  },
-  boolean: {
-    tsType: "boolean",
-    prompt: "boolean",
-  },
-  any: {
-    tsType: "any",
-    prompt: "any (raw js expression)",
-  },
-};

package/src/events.ts

@@ -1,12 +0,0 @@
-export enum ComponentEvent {
-  CREATE = "create",
-  INIT = "init",
-  LOGIN = "login",
-  MIGRATE = "migrate",
-  PULL = "pull",
-  COMMITS = "commits",
-  PUSH = "push",
-  REGISTER = "register",
-  UPLOAD = "upload",
-  DEPLOY = "deploy",
-}

package/src/file-uploader.test.ts

@@ -1,69 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-import { getBucketeerUrlFromSuperblocksUrl } from "./file-uploader.js";
-
-describe("getBucketeerUrlFromSuperblocksUrl", () => {
-  let originalUrl: string | undefined;
-
-  beforeEach(() => {
-    originalUrl = process.env.SUPERBLOCKS_BUCKETEER_URL;
-    delete process.env.SUPERBLOCKS_BUCKETEER_URL;
-  });
-
-  afterEach(() => {
-    if (originalUrl === undefined) {
-      delete process.env.SUPERBLOCKS_BUCKETEER_URL;
-    } else {
-      process.env.SUPERBLOCKS_BUCKETEER_URL = originalUrl;
-    }
-  });
-
-  it("returns the default localhost bucketeer URL for localhost servers", () => {
-    expect(getBucketeerUrlFromSuperblocksUrl("http://localhost:8080")).toBe(
-      "http://localhost:8030",
-    );
-    expect(getBucketeerUrlFromSuperblocksUrl("http://127.0.0.1:8080")).toBe(
-      "http://localhost:8030",
-    );
-  });
-
-  it("honors SUPERBLOCKS_BUCKETEER_URL for localhost servers (slot-aware worktrees)", () => {
-    process.env.SUPERBLOCKS_BUCKETEER_URL = "http://localhost:8330";
-    expect(getBucketeerUrlFromSuperblocksUrl("http://localhost:8380")).toBe(
-      "http://localhost:8330",
-    );
-    expect(getBucketeerUrlFromSuperblocksUrl("http://127.0.0.1:8380")).toBe(
-      "http://localhost:8330",
-    );
-  });
-
-  it("falls back to localhost default when the input URL is unparseable", () => {
-    expect(getBucketeerUrlFromSuperblocksUrl("not a url")).toBe(
-      "http://localhost:8030",
-    );
-  });
-
-  it("uses SUPERBLOCKS_BUCKETEER_URL when the input URL is unparseable", () => {
-    process.env.SUPERBLOCKS_BUCKETEER_URL = "http://localhost:8330";
-    expect(getBucketeerUrlFromSuperblocksUrl("not a url")).toBe(
-      "http://localhost:8330",
-    );
-  });
-
-  it("ignores SUPERBLOCKS_BUCKETEER_URL for non-localhost hostnames", () => {
-    process.env.SUPERBLOCKS_BUCKETEER_URL = "http://localhost:8330";
-
-    expect(
-      getBucketeerUrlFromSuperblocksUrl("https://app.superblocks.com"),
-    ).toBe("https://bucketeer.superblocks.com");
-    expect(
-      getBucketeerUrlFromSuperblocksUrl("https://staging.superblocks.com"),
-    ).toBe("https://bucketeer.staging.superblocks.com");
-    expect(
-      getBucketeerUrlFromSuperblocksUrl("https://eu.superblocks.com"),
-    ).toBe("https://bucketeer.eu.superblocks.com");
-    expect(
-      getBucketeerUrlFromSuperblocksUrl("https://pr-123.superblocks.dev"),
-    ).toBe("https://bucketeer.dev.superblocks.com");
-  });
-});

package/src/file-uploader.ts

@@ -1,42 +0,0 @@
-export const COMPONENT_EVENT_HEADER = "x-superblocks-component-event";
-
-// SUPERBLOCKS_BUCKETEER_URL lets slot-N Tilt worktrees override the default
-// localhost bucketeer URL (http://localhost:8030) when the server runs on a
-// different slot offset. The local-orch Tilt profile injects this variable
-// for the server's serve env.
-const localhostBucketeerUrl = (): string =>
-  process.env.SUPERBLOCKS_BUCKETEER_URL ?? "http://localhost:8030";
-
-// retrieves bucketeer base URL given the superblocks server base URL
-export const getBucketeerUrlFromSuperblocksUrl = (
-  superblocksBaseUrl: string,
-): string => {
-  let hostname: string;
-  try {
-    hostname = new URL(superblocksBaseUrl).hostname;
-  } catch {
-    return localhostBucketeerUrl();
-  }
-
-  if (/^pr-.*\.superblocks\.dev$/u.test(hostname)) {
-    return "https://bucketeer.dev.superblocks.com";
-  }
-
-  switch (hostname) {
-    case "eu.superblocks.com":
-    case "prod-eu.superblocks.com":
-      return "https://bucketeer.eu.superblocks.com";
-    case "app.staging.superblocks.com":
-    case "staging.superblocks.com":
-      return "https://bucketeer.staging.superblocks.com";
-    case "app.superblocks.com":
-    case "app.superblockshq.com":
-      return "https://bucketeer.superblocks.com";
-    case "dev.superblocks.com":
-      return "https://bucketeer.dev.superblocks.com";
-    case "127.0.0.1":
-    case "localhost":
-    default:
-      return localhostBucketeerUrl();
-  }
-};

package/src/generate-component-types.ts

@@ -1,53 +0,0 @@
-import { dataTypeDefinions, type DataType } from "./data-types.js";
-import type { ComponentConfig } from "./types.js";
-
-const indent = (str: string, spaces: number) => {
-  const spacesString = " ".repeat(spaces);
-
-  return str
-    .split("\n")
-    .map((line) => `${spacesString}${line}`)
-    .join("\n");
-};
-
-function renderInputTypeAsTS(
-  name: string,
-  type: DataType,
-  trailingChars: string,
-  indentSpaces: number,
-) {
-  let { tsType } = dataTypeDefinions[type];
-  if (["number", "string"].includes(type)) {
-    tsType += " | null";
-  }
-  return indent(`${name}: ${tsType}${trailingChars}`, indentSpaces);
-}
-
-export function generateComponentTypesFile(config: ComponentConfig) {
-  const properties = config.properties ?? [];
-  const eventHandlers = config.events ?? [];
-  return `// GENERATED CODE -- DO NOT EDIT!
-//
-// This file is automatically generated by the Superblocks CLI
-// Use the \`superblocks components watch\` command to regenerate this file from its source in config.ts
-
-// All properties of your component are defined here.
-// These are the properties which are surfaced in the Superblocks properties panel
-// and can be referenced throughout your Superblocks Application
-export type Props = {
-${properties
-  .map((v) => renderInputTypeAsTS(v.path, v.dataType, ";", 2) + "\n")
-  .join("")}};
-
-export type EventTriggers = {
-  // Call the subsequent function(s) to trigger event(s) in Superblocks from your component.
-  // These events can be wired up to event handlers in your Superblocks App
-${
-  eventHandlers.length === 0
-    ? "  // Note: no event handlers defined\n"
-    : eventHandlers
-        .map((v: any) => indent(v.path, 2) + ": () => void;" + "\n")
-        .join("")
-}};
-`;
-}

package/src/identifiers.ts

@@ -1,70 +0,0 @@
-// convert a string to upper camel case, e.g. "123 & this is my component, foo-bar" -> "123ThisIsMyComponentFooBar"
-function wordsToUpperCamelCase(str: string) {
-  return str
-    .split(/[^A-Za-z0-9_]+/)
-    .filter(Boolean)
-    .map((word) => word[0].toUpperCase() + word.slice(1))
-    .join("");
-}
-
-const digits = "Zero One Two Three Four Five Six Seven Eight Nine".split(" ");
-
-// convert digits to words, e.g. "123" -> "OneTwoThree"
-function digitsToWords(str: string) {
-  return str.replace(/\d/g, (char) => digits[parseInt(char, 10)] ?? char);
-}
-
-/**
- * Suggest an identifier based on a label, e.g. `My Component` -> `myComponent`.
- * @param label The label to suggest an identifier for.
- * @param capitalizeFirst Whether to capitalize the first letter of the identifier.
- */
-export function suggestIdentifier(label: string, capitalizeFirst = false) {
-  const upperCamelCase = wordsToUpperCamelCase(label)
-    // convert any digits at the start of the string to words as these are not valid in identifiers
-    .replace(/^\d+/, digitsToWords);
-  if (capitalizeFirst) {
-    return upperCamelCase;
-  } else {
-    return upperCamelCase[0].toLowerCase() + upperCamelCase.slice(1);
-  }
-}
-
-const IdentifierRegex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-
-export function isValidIdentifier(str: string) {
-  return IdentifierRegex.test(str);
-}
-
-const reservedPropertyNames = new Set<string>([
-  "ENTITY_TYPE",
-  "bindingPaths",
-  "bottomRow",
-  "dynamicBindingPathList",
-  "dynamicTriggerPathList",
-  "gridColumns",
-  "gridRows",
-  "height",
-  "isLoading",
-  "isVisible",
-  "leftColumn",
-  "parentId",
-  "rightColumn",
-  "snapColumns",
-  "snapRows",
-  "top",
-  "topRow",
-  "type",
-  "widgetId",
-  "widgetLastChange",
-  "widgetName",
-  "width",
-]);
-
-export function isReservedPropertyName(str: string) {
-  return (
-    reservedPropertyNames.has(str) ||
-    // also treat any property name starting with "default_" as reserved since we use this prefix for default properties
-    str.startsWith("default_")
-  );
-}

package/src/localGitRepoState.ts

@@ -1,20 +0,0 @@
-import type { ComponentEvent } from "./events.js";
-
-export type LocalGitRepoState =
-  | { status: "NO_GIT" }
-  | { status: "DETACHED" }
-  | {
-      status: "IN_A_BRANCH";
-      localBranchName: string;
-      upstream?: {
-        remoteName: string;
-        url: string;
-        pushUrl?: string | null;
-        branchName: string;
-      };
-    };
-
-export interface ValidateGitSetupRequestBody {
-  gitState: LocalGitRepoState;
-  event?: ComponentEvent;
-}

package/src/login.ts

@@ -1,82 +0,0 @@
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-import fs from "fs-extra";
-
-import { FileAccessError, TOKEN_CONFIG_PATH } from "./constants.js";
-
-type BaseUrl = {
-  superblocksBaseUrl: string;
-};
-
-type TokenWithBaseUrl = BaseUrl & {
-  token: string;
-};
-
-/**
- * Returns the resolved auth file path, honoring the SUPERBLOCKS_AUTH_FILE
- * environment variable. Both reads and writes MUST use this so the CLI
- * never writes to one file and reads from another.
- */
-export function resolveAuthFilePath(): string {
-  return (
-    process.env.SUPERBLOCKS_AUTH_FILE || join(homedir(), TOKEN_CONFIG_PATH)
-  );
-}
-
-export async function saveApiToken(superblocksBaseUrl: string, token?: string) {
-  try {
-    const authFile = resolveAuthFilePath();
-    await fs.ensureDir(dirname(authFile));
-    if (token) {
-      const tokenConfig: TokenWithBaseUrl = {
-        superblocksBaseUrl,
-        token,
-      };
-      await fs.writeJSON(authFile, tokenConfig);
-    } else {
-      const tokenConfig: BaseUrl = {
-        superblocksBaseUrl,
-      };
-      await fs.writeJSON(authFile, tokenConfig);
-    }
-  } catch {
-    throw new FileAccessError("Could not save token");
-  }
-}
-
-export async function getLocalTokenWithUrlIfExists(): Promise<
-  TokenWithBaseUrl | BaseUrl | undefined
-> {
-  try {
-    return await getLocalTokenWithUrl();
-  } catch {
-    return undefined;
-  }
-}
-
-export async function getLocalTokenWithUrl(): Promise<
-  TokenWithBaseUrl | BaseUrl
-> {
-  try {
-    const tokenConfig: TokenWithBaseUrl = await fs.readJSON(
-      resolveAuthFilePath(),
-    );
-    const superblocksBaseUrl =
-      process.env.SUPERBLOCKS_BASE_URL || tokenConfig.superblocksBaseUrl;
-    if (tokenConfig.token) {
-      // user logged in
-      return {
-        token: tokenConfig.token,
-        superblocksBaseUrl,
-      };
-    } else {
-      // user not logged in, but set domain
-      return {
-        superblocksBaseUrl,
-      };
-    }
-  } catch {
-    throw new Error("No local API key found");
-  }
-}

package/src/mask-unix-signals.ts

@@ -1,86 +0,0 @@
-const unixSignalsToMask: NodeJS.Signals[] = ["SIGINT", "SIGTERM", "SIGHUP"];
-
-// The exit code that is used when the process is aborted due to a unix signal
-const exitCode = 254;
-
-type ActionResult<T> =
-  | { success: true; returnValue: T }
-  | { success: false; error: unknown };
-
-/**
- * Runs an action with some unix signals being masked. This is useful for actions that should not be interrupted and need
- * to be allowed to complete or perform some cleanup. If a signal is received, the action will be notified that it should
- * abort via the `AbortSignal` that is passed to it. The action may or may not choose to abort immediately. The cleanup
- * action is called after the main action and this happens unconditionally, i.e. regardless of whether a signal was received,
- * the main action threw an error, or the main action returned a value. The cleanup action is passed the abort signal and the
- * error (if any) that was thrown by the main action. If a signal was received, the process will exit after the cleanup
- * action has completed. If the main action threw an error, that error will be thrown again. Otherwise, the main action's
- * return value is returned. This function can be thought of as a (unix) signal aware version of `try { … } finally { … }`
- * and `try { … } catch { … } catch { … }`.
- *
- * *Note*: This function registers listeners for some unix signals, so it affects the global behavior of the process. Be
- * careful when using this function in a library.
- *
- * @param action - The main action to execute.
- * @param cleanup - An optional cleanup action to execute when the process is aborted.
- * @returns The result of the `action`.
- */
-export async function maskUnixSignals<T>(
-  action: (aborted: AbortSignal) => Promise<T>,
-  cleanup?: (
-    aborted: AbortSignal,
-    actionResult: ActionResult<T>,
-  ) => Promise<void>,
-): Promise<T> {
-  const abortController = new AbortController();
-  const abortSignal = abortController.signal;
-
-  const onUnixSignal = (unixSignal: NodeJS.Signals) => {
-    console.log(`${unixSignal} received, will abort after cleanup`);
-    if (unixSignal === "SIGINT") {
-      if (!abortSignal.aborted) {
-        console.log("Press Ctrl+C again to force abort");
-      } else {
-        console.log("Second SIGINT received, will abort immediately");
-        process.exit(exitCode);
-      }
-    }
-    // Pass the signal as the reason for aborting so that `action` and `cleanup` can know which signal was received
-    abortController.abort(unixSignal);
-  };
-
-  for (const signal of unixSignalsToMask) {
-    process.on(signal, onUnixSignal);
-  }
-  try {
-    let result: ActionResult<T>;
-    try {
-      const returnValue = await action(abortSignal);
-      result = { success: true, returnValue };
-    } catch (err) {
-      result = { success: false, error: err };
-    }
-    try {
-      await cleanup?.(abortSignal, result);
-    } finally {
-      // If the process received a (unix) signal, this takes precedence over any error that was thrown by `action` or
-      // `cleanup`. So we exit here. Otherwise, we let standard JS error handling take over, e.g. an exception
-      // thrown by `cleanup` shadows any exception that was thrown by `action`.
-      if (abortSignal.aborted) {
-        // The process received a (unix) signal, so we exit here.
-        process.exit(exitCode);
-      }
-    }
-    if (!result.success) {
-      // `action` threw an error
-      throw result.error;
-    } else {
-      // `action` threw an error
-      return result.returnValue;
-    }
-  } finally {
-    for (const signal of unixSignalsToMask) {
-      process.off(signal, onUnixSignal);
-    }
-  }
-}