@storm-software/config-tools 1.32.4 → 1.33.0

package/src/env/set-env.ts

@@ -0,0 +1,192 @@
+import { LogLevel } from "../types";
+import type { StormConfig } from "@storm-software/config";
+import { getLogLevel } from "../utilities/get-log-level";
+import { correctPaths } from "../utilities/correct-paths";
+
+/**
+ * Get the config for an extension module of Storm workspace from environment variables
+ *
+ * @param extensionName - The name of the extension module
+ * @returns The config for the specified Storm extension module. If the module does not exist, `undefined` is returned.
+ */
+export const setExtensionEnv = <TConfig extends Record<string, any> = Record<string, any>>(
+  extensionName: string,
+  extension: TConfig
+) => {
+  for (const key of Object.keys(extension ?? {})) {
+    if (extension[key]) {
+      const result =
+        key
+          ?.replace(/([A-Z])+/g, (input?: string) =>
+            input ? input[0]?.toUpperCase() + input.slice(1) : ""
+          )
+          .split(/(?=[A-Z])|[.\-\s_]/)
+          .map((x: string) => x.toLowerCase()) ?? [];
+
+      let extensionKey: string;
+      if (result.length === 0) {
+        return;
+      }
+      if (result.length === 1) {
+        extensionKey = result[0]?.toUpperCase() ?? "";
+      } else {
+        extensionKey = result.reduce((ret: string, part: string) => {
+          return `${ret}_${part.toLowerCase()}`;
+        });
+      }
+
+      process.env[`STORM_EXTENSION_${extensionName.toUpperCase()}_${extensionKey.toUpperCase()}`] =
+        extension[key];
+    }
+  }
+};
+
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace from environment variables
+ */
+export const setConfigEnv = (config: StormConfig) => {
+  const prefix = "STORM_";
+
+  if (config.extends) {
+    process.env[`${prefix}EXTENDS`] = config.extends;
+  }
+  if (config.name) {
+    process.env[`${prefix}NAME`] = config.name;
+  }
+  if (config.namespace) {
+    process.env[`${prefix}NAMESPACE`] = config.namespace;
+  }
+  if (config.owner) {
+    process.env[`${prefix}OWNER`] = config.owner;
+  }
+  if (config.worker) {
+    process.env[`${prefix}WORKER`] = config.worker;
+  }
+  if (config.organization) {
+    process.env[`${prefix}ORGANIZATION`] = config.organization;
+  }
+  if (config.packageManager) {
+    process.env[`${prefix}PACKAGE_MANAGER`] = config.packageManager;
+  }
+  if (config.license) {
+    process.env[`${prefix}LICENSE`] = config.license;
+  }
+  if (config.homepage) {
+    process.env[`${prefix}HOMEPAGE`] = config.homepage;
+  }
+  if (config.timezone) {
+    process.env[`${prefix}TIMEZONE`] = config.timezone;
+    process.env.TZ = config.timezone;
+    process.env.DEFAULT_TIMEZONE = config.timezone;
+  }
+  if (config.locale) {
+    process.env[`${prefix}LOCALE`] = config.locale;
+    process.env.LOCALE = config.locale;
+    process.env.DEFAULT_LOCALE = config.locale;
+    process.env.LANG = config.locale
+      ? `${config.locale.replaceAll("-", "_")}.UTF-8`
+      : "en_US.UTF-8";
+  }
+  if (config.configFile) {
+    process.env[`${prefix}CONFIG_FILE`] = correctPaths(config.configFile);
+  }
+  if (config.workspaceRoot) {
+    process.env[`${prefix}WORKSPACE_ROOT`] = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT = correctPaths(config.workspaceRoot);
+    process.env.NX_WORKSPACE_ROOT_PATH = correctPaths(config.workspaceRoot);
+  }
+  if (config.packageDirectory) {
+    process.env[`${prefix}PACKAGE_DIRECTORY`] = correctPaths(config.packageDirectory);
+  }
+  if (config.buildDirectory) {
+    process.env[`${prefix}BUILD_DIRECTORY`] = correctPaths(config.buildDirectory);
+  }
+  if (config.skipCache !== undefined) {
+    process.env[`${prefix}SKIP_CACHE`] = String(config.skipCache);
+    if (config.skipCache) {
+      process.env.NX_SKIP_NX_CACHE ??= String(config.skipCache);
+      process.env.NX_CACHE_PROJECT_GRAPH ??= String(config.skipCache);
+    }
+  }
+  if (!config.skipCache && config.cacheDirectory) {
+    process.env[`${prefix}CACHE_DIRECTORY`] = correctPaths(config.cacheDirectory);
+    // if (config.cacheDirectory.includes("/storm") || config.cacheDirectory.includes("\\storm")) {
+    //   const nxCacheDirectory = join(
+    //     config.cacheDirectory.includes("/storm")
+    //       ? config.cacheDirectory.split("/storm")[0]
+    //       : config.cacheDirectory.split("\\storm")[0],
+    //     "nx"
+    //   );
+    //   process.env.NX_CACHE_DIRECTORY ??= nxCacheDirectory;
+    //   process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??= nxCacheDirectory;
+    // }
+  }
+  if (config.runtimeVersion) {
+    process.env[`${prefix}RUNTIME_VERSION`] = config.runtimeVersion;
+  }
+  if (config.runtimeDirectory) {
+    process.env[`${prefix}RUNTIME_DIRECTORY`] = correctPaths(config.runtimeDirectory);
+  }
+  if (config.env) {
+    process.env[`${prefix}ENV`] = config.env;
+    process.env.NODE_ENV = config.env;
+    process.env.ENVIRONMENT = config.env;
+  }
+  if (config.ci) {
+    process.env[`${prefix}CI`] = String(config.ci);
+    process.env.CI = String(config.ci);
+    process.env.CONTINUOUS_INTEGRATION = String(config.ci);
+  }
+  if (config.colors.primary) {
+    process.env[`${prefix}COLOR_PRIMARY`] = config.colors.primary;
+  }
+  if (config.colors.background) {
+    process.env[`${prefix}COLOR_BACKGROUND`] = config.colors.background;
+  }
+  if (config.colors.success) {
+    process.env[`${prefix}COLOR_SUCCESS`] = config.colors.success;
+  }
+  if (config.colors.info) {
+    process.env[`${prefix}COLOR_INFO`] = config.colors.info;
+  }
+  if (config.colors.warning) {
+    process.env[`${prefix}COLOR_WARNING`] = config.colors.warning;
+  }
+  if (config.colors.error) {
+    process.env[`${prefix}COLOR_ERROR`] = config.colors.error;
+  }
+  if (config.colors.fatal) {
+    process.env[`${prefix}COLOR_FATAL`] = config.colors.fatal;
+  }
+  if (config.repository) {
+    process.env[`${prefix}REPOSITORY`] = config.repository;
+  }
+  if (config.branch) {
+    process.env[`${prefix}BRANCH`] = config.branch;
+  }
+  if (config.preid) {
+    process.env[`${prefix}PRE_ID`] = String(config.preid);
+  }
+  if (config.externalPackagePatterns) {
+    process.env[`${prefix}EXTERNAL_PACKAGE_PATTERNS`] = JSON.stringify(
+      config.externalPackagePatterns
+    );
+  }
+  if (config.logLevel) {
+    process.env[`${prefix}LOG_LEVEL`] = String(config.logLevel);
+    process.env.LOG_LEVEL = String(config.logLevel);
+    process.env.NX_VERBOSE_LOGGING = String(
+      getLogLevel(config.logLevel) >= LogLevel.DEBUG ? true : false
+    );
+    process.env.RUST_BACKTRACE = getLogLevel(config.logLevel) >= LogLevel.DEBUG ? "full" : "none";
+  }
+  process.env[`${prefix}CONFIG`] = JSON.stringify(config);
+
+  for (const key of Object.keys(config.extensions ?? {})) {
+    config.extensions[key] &&
+      Object.keys(config.extensions[key]) &&
+      setExtensionEnv(key, config.extensions[key]);
+  }
+};

package/src/index.ts

@@ -0,0 +1,14 @@
+/**
+ * The config-tools library used by Storm Software for building TypeScript applications.
+ *
+ * @remarks
+ * A package containing various utilities to support custom workspace configurations
+ *
+ * @packageDocumentation
+ */
+
+export * from "./config-file";
+export * from "./create-storm-config";
+export * from "./env";
+export * from "./types";
+export * from "./utilities";

package/src/types.ts

@@ -0,0 +1,45 @@
+import type { StormConfig } from "@storm-software/config";
+
+export type LogLevel = 0 | 10 | 20 | 30 | 35 | 40 | 60 | 70 | 100;
+export const LogLevel = {
+  SILENT: 0 as LogLevel,
+  FATAL: 10 as LogLevel,
+  ERROR: 20 as LogLevel,
+  WARN: 30 as LogLevel,
+  SUCCESS: 35 as LogLevel,
+  INFO: 40 as LogLevel,
+  DEBUG: 60 as LogLevel,
+  TRACE: 70 as LogLevel,
+  ALL: 100 as LogLevel
+} as const;
+
+export type LogLevelLabel =
+  | "silent"
+  | "fatal"
+  | "error"
+  | "warn"
+  | "info"
+  | "debug"
+  | "trace"
+  | "all";
+export const LogLevelLabel = {
+  SILENT: "silent" as LogLevelLabel,
+  FATAL: "fatal" as LogLevelLabel,
+  ERROR: "error" as LogLevelLabel,
+  WARN: "warn" as LogLevelLabel,
+  INFO: "info" as LogLevelLabel,
+  DEBUG: "debug" as LogLevelLabel,
+  TRACE: "trace" as LogLevelLabel,
+  ALL: "all" as LogLevelLabel
+} as const;
+
+export interface BaseTokenizerOptions {
+  workspaceRoot?: string;
+  config?: StormConfig;
+}
+
+export interface ProjectTokenizerOptions extends BaseTokenizerOptions {
+  projectRoot?: string;
+  projectName?: string;
+  sourceRoot?: string;
+}

package/src/utilities/apply-workspace-tokens.ts

@@ -0,0 +1,83 @@
+import type { BaseTokenizerOptions, ProjectTokenizerOptions } from "../../declarations";
+import { findWorkspaceRoot } from "./find-workspace-root";
+
+export const applyWorkspaceBaseTokens = async (
+  option: string,
+  tokenizerOptions: BaseTokenizerOptions
+): Promise<string> => {
+  let result = option;
+  if (!result) {
+    return result;
+  }
+
+  if (tokenizerOptions) {
+    const optionKeys = Object.keys(tokenizerOptions);
+    if (optionKeys.some((optionKey) => result.includes(`{${optionKey}}`))) {
+      for (const optionKey of optionKeys) {
+        if (result.includes(`{${optionKey}}`)) {
+          result = result.replaceAll(`{${optionKey}}`, tokenizerOptions.config?.[optionKey] ?? "");
+        }
+      }
+    }
+  }
+  if (tokenizerOptions.config) {
+    const configKeys = Object.keys(tokenizerOptions.config);
+    if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
+      for (const configKey of configKeys) {
+        if (result.includes(`{${configKey}}`)) {
+          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+        }
+      }
+    }
+  }
+
+  if (result.includes("{workspaceRoot}")) {
+    result = result.replaceAll(
+      "{workspaceRoot}",
+      tokenizerOptions.workspaceRoot ??
+        tokenizerOptions.config?.workspaceRoot ??
+        findWorkspaceRoot()
+    );
+  }
+
+  return result;
+};
+
+export const applyWorkspaceProjectTokens = (
+  option: string,
+  tokenizerOptions: ProjectTokenizerOptions
+): Promise<string> => {
+  return applyWorkspaceBaseTokens(option, tokenizerOptions);
+};
+
+export const applyWorkspaceTokens = async <
+  TConfig extends BaseTokenizerOptions = BaseTokenizerOptions
+>(
+  options: Record<string, any>,
+  config: TConfig,
+  tokenizerFn: (option: string, config: TConfig) => string | Promise<string>
+): Promise<Record<string, any>> => {
+  if (!options) {
+    return {};
+  }
+
+  const result: Record<string, any> = {};
+
+  for (const option of Object.keys(options)) {
+    if (typeof options[option] === "string") {
+      result[option] = await Promise.resolve(tokenizerFn(options[option], config));
+    } else if (Array.isArray(options[option])) {
+      result[option] = await Promise.all(
+        options[option].map(async (item: any) =>
+          typeof item === "string" ? await Promise.resolve(tokenizerFn(item, config)) : item
+        )
+      );
+    } else if (typeof options[option] === "object") {
+      result[option] = await applyWorkspaceTokens(options[option], config, tokenizerFn);
+    } else {
+      result[option] = options[option];
+    }
+  }
+
+  return result;
+};

package/src/utilities/correct-paths.ts

@@ -0,0 +1,12 @@
+export const correctPaths = (path?: string): string => {
+  if (!path) {
+    return "";
+  }
+
+  // Handle Windows absolute paths
+  if (path?.toUpperCase()?.startsWith("C:")) {
+    return path.replaceAll("/", "\\");
+  }
+
+  return path.replaceAll("\\", "/");
+};

package/src/utilities/file-path-utils.ts

@@ -0,0 +1,26 @@
+import { sep } from "node:path";
+
+export const removeExtension = (filePath?: string): string => {
+  const result =
+    !filePath || (filePath.match(/./g) || []).length <= 1
+      ? "."
+      : filePath.lastIndexOf(".")
+        ? filePath.substring(0, filePath.lastIndexOf("."))
+        : filePath;
+
+  if (result.startsWith("./")) {
+    return result.substring(2);
+  }
+  if (result.startsWith(".") || result.startsWith("/")) {
+    return result.substring(1);
+  }
+
+  return result;
+};
+
+export function findFileName(filePath: string): string {
+  return (
+    filePath?.split(filePath?.includes(sep) ? sep : filePath?.includes("/") ? "/" : "\\")?.pop() ??
+    ""
+  );
+}

package/src/utilities/find-up.ts

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+const MAX_PATH_SEARCH_DEPTH = 30;
+let depth = 0;
+
+/**
+ * Gets the nearest "node_modules" folder by walking up from start path.
+ */
+export function findFolderUp(startPath: string, endFileNames: string[]): string | undefined {
+  const _startPath = startPath ?? process.cwd();
+
+  if (endFileNames.some((endFileName) => existsSync(join(_startPath, endFileName)))) {
+    return _startPath;
+  }
+  if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+    const parent = join(_startPath, "..");
+    return findFolderUp(parent, endFileNames);
+  }
+  return undefined;
+}

package/src/utilities/find-workspace-root.ts

@@ -0,0 +1,68 @@
+import { correctPaths } from "./correct-paths";
+import { findFolderUp } from "./find-up";
+
+const rootFiles = [
+  "storm.json",
+  "storm.config.js",
+  "storm.config.ts",
+  ".storm.json",
+  ".storm.yaml",
+  ".storm.yml",
+  ".storm.js",
+  ".storm.ts",
+  "lerna.json",
+  "nx.json",
+  "turbo.json",
+  "npm-workspace.json",
+  "yarn-workspace.json",
+  "pnpm-workspace.json",
+  "npm-workspace.yaml",
+  "yarn-workspace.yaml",
+  "pnpm-workspace.yaml",
+  "npm-workspace.yml",
+  "yarn-workspace.yml",
+  "pnpm-workspace.yml",
+  "npm-lock.json",
+  "yarn-lock.json",
+  "pnpm-lock.json",
+  "npm-lock.yaml",
+  "yarn-lock.yaml",
+  "pnpm-lock.yaml",
+  "npm-lock.yml",
+  "yarn-lock.yml",
+  "pnpm-lock.yml",
+  "bun.lockb"
+];
+
+/**
+ * Find the monorepo root directory, searching upwards from `path`.
+ *
+ * @param pathInsideMonorepo - The path inside the monorepo to start searching from
+ * @returns The monorepo root directory
+ */
+export function findWorkspaceRootSafe(pathInsideMonorepo?: string): string | undefined {
+  if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+    return correctPaths(process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH);
+  }
+
+  return correctPaths(findFolderUp(pathInsideMonorepo ?? process.cwd(), rootFiles));
+}
+
+/**
+ * Find the monorepo root directory, searching upwards from `path`.
+ *
+ * @param pathInsideMonorepo - The path inside the monorepo to start searching from
+ * @returns The monorepo root directory
+ */
+export function findWorkspaceRoot(pathInsideMonorepo?: string): string {
+  const result = findWorkspaceRootSafe(pathInsideMonorepo);
+  if (!result) {
+    throw new Error(
+      `Cannot find workspace root upwards from known path. Files search list includes: \n${rootFiles.join(
+        "\n"
+      )}\nPath: ${pathInsideMonorepo ? pathInsideMonorepo : process.cwd()}`
+    );
+  }
+
+  return result;
+}

package/src/utilities/get-default-config.ts

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { type StormConfig, type ColorConfig, StormConfigSchema } from "@storm-software/config";
+import { findWorkspaceRoot } from "./find-workspace-root";
+
+/**
+ * Storm theme config values used for styling various workspace elements
+ */
+export const DEFAULT_COLOR_CONFIG: ColorConfig = {
+  primary: "#1fb2a6",
+  background: "#1d232a",
+  success: "#087f5b",
+  info: "#0ea5e9",
+  warning: "#fcc419",
+  error: "#990000",
+  fatal: "#7d1a1a"
+};
+
+/**
+ * Storm Workspace config values used during various dev-ops processes
+ */
+export const DEFAULT_STORM_CONFIG: any = {
+  name: "storm",
+  namespace: "storm-software",
+  license: "Apache License 2.0",
+  homepage: "https://stormsoftware.org",
+  owner: "@storm-software/development",
+  worker: "stormie-bot",
+  runtimeDirectory: "node_modules/.storm",
+  cacheDirectory: "node_modules/.cache/storm",
+  skipCache: false,
+  packageManager: "npm",
+  timezone: "America/New_York",
+  locale: "en-US",
+  env: "production",
+  branch: "main",
+  organization: "storm-software",
+  ci: true,
+  configFile: null,
+  runtimeVersion: "1.0.0",
+  colors: { ...DEFAULT_COLOR_CONFIG },
+  extensions: {}
+};
+
+/**
+ * Get the default Storm config values used during various dev-ops processes
+ *
+ * @returns The default Storm config values
+ */
+export const getDefaultConfig = (config: Partial<StormConfig> = {}, root?: string): StormConfig => {
+  let name = "storm-workspace";
+  let namespace = "storm-software";
+  let repository = "https://github.com/storm-software/storm-ops";
+
+  let license = DEFAULT_STORM_CONFIG.license;
+  let homepage = DEFAULT_STORM_CONFIG.homepage;
+
+  const workspaceRoot = findWorkspaceRoot(root);
+  if (existsSync(join(workspaceRoot, "package.json"))) {
+    const file = readFileSync(join(workspaceRoot, "package.json"), {
+      encoding: "utf-8"
+    });
+    if (file) {
+      const packageJson = JSON.parse(file);
+
+      if (packageJson.name) {
+        name = packageJson.name;
+      }
+      if (packageJson.namespace) {
+        namespace = packageJson.namespace;
+      }
+      if (packageJson.repository?.url) {
+        repository = packageJson.repository?.url;
+      }
+      if (packageJson.license) {
+        license = packageJson.license;
+      }
+      if (packageJson.homepage) {
+        homepage = packageJson.homepage;
+      }
+    }
+  }
+
+  return StormConfigSchema.parse({
+    ...(DEFAULT_STORM_CONFIG as Required<StormConfig>),
+    ...config,
+    colors: { ...DEFAULT_COLOR_CONFIG, ...config.colors },
+    workspaceRoot,
+    name,
+    namespace,
+    repository,
+    license: license ?? DEFAULT_STORM_CONFIG.license,
+    homepage: homepage ?? DEFAULT_STORM_CONFIG.homepage,
+    extensions: {
+      ...config.extensions
+    }
+  }) as StormConfig;
+};

package/src/utilities/get-log-level.ts

@@ -0,0 +1,64 @@
+import { LogLevel, LogLevelLabel } from "../types";
+
+/**
+ * Convert the log level label to a log level
+ *
+ * @param label - The log level label to convert
+ * @returns The log level
+ */
+export const getLogLevel = (label?: string): LogLevel => {
+  switch (label) {
+    case "all":
+      return LogLevel.ALL;
+    case "trace":
+      return LogLevel.TRACE;
+    case "debug":
+      return LogLevel.DEBUG;
+    case "info":
+      return LogLevel.INFO;
+    case "warn":
+      return LogLevel.WARN;
+    case "error":
+      return LogLevel.ERROR;
+    case "fatal":
+      return LogLevel.FATAL;
+    case "silent":
+      return LogLevel.SILENT;
+    default:
+      return LogLevel.INFO;
+  }
+};
+
+/**
+ * Convert the log level to a log level label
+ *
+ * @param logLevel - The log level to convert
+ * @returns The log level label
+ */
+export const getLogLevelLabel = (logLevel: number = LogLevel.INFO): LogLevelLabel => {
+  if (logLevel >= LogLevel.ALL) {
+    return LogLevelLabel.ALL;
+  }
+  if (logLevel >= LogLevel.TRACE) {
+    return LogLevelLabel.TRACE;
+  }
+  if (logLevel >= LogLevel.DEBUG) {
+    return LogLevelLabel.DEBUG;
+  }
+  if (logLevel >= LogLevel.INFO) {
+    return LogLevelLabel.INFO;
+  }
+  if (logLevel >= LogLevel.WARN) {
+    return LogLevelLabel.WARN;
+  }
+  if (logLevel >= LogLevel.ERROR) {
+    return LogLevelLabel.ERROR;
+  }
+  if (logLevel >= LogLevel.FATAL) {
+    return LogLevelLabel.FATAL;
+  }
+  if (logLevel <= LogLevel.SILENT) {
+    return LogLevelLabel.SILENT;
+  }
+  return LogLevelLabel.INFO;
+};

package/src/utilities/index.ts

@@ -0,0 +1,9 @@
+export * from "./find-workspace-root";
+export * from "./get-default-config";
+export * from "./get-log-level";
+export * from "./logger";
+export * from "./process-handler";
+export * from "./run";
+export * from "./correct-paths";
+export * from "./file-path-utils";
+export * from "./apply-workspace-tokens";