@storm-software/config-tools 1.21.5 → 1.22.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 1.22.0 (2024-01-26)
+
+
+### 🚀 Features
+
+- **workspace-tools:** Added custom `npm-publish` executor ([3e6292dd](https://github.com/storm-software/storm-ops/commit/3e6292dd))
+
+
+### ❤️  Thank You
+
+- Patrick Sullivan
+
 
 
 

package/jest.config.ts

@@ -0,0 +1,3 @@
+import { getJestConfig } from "@storm-software/testing-tools";
+
+export default getJestConfig("packages/config-tools", true, "config-tools");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storm-software/config-tools",
-  "version": "1.21.5",
+  "version": "1.22.0",
   "private": false,
   "description": "⚡The Storm-Ops monorepo contains utility applications, tools, and various libraries to create modern and scalable web applications.",
   "repository": {

package/project.json

@@ -0,0 +1,60 @@
+{
+  "name": "config-tools",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "projectType": "library",
+  "sourceRoot": "packages/config-tools/src",
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "main": "packages/config-tools/src/index.ts",
+        "additionalEntryPoints": [
+          "packages/config-tools/src/utilities/find-workspace-root.ts",
+          "packages/config-tools/src/utilities/logger.ts"
+        ],
+        "outputPath": "dist/packages/config-tools",
+        "tsConfig": "packages/config-tools/tsconfig.json",
+        "project": "packages/config-tools/package.json",
+        "defaultConfiguration": "production",
+        "platform": "node",
+        "deleteOutputPath": true,
+        "bundle": true,
+        "thirdParty": true,
+        "skipTypeCheck": true,
+        "metafile": true,
+        "minify": true,
+        "format": ["cjs", "esm"],
+        "assets": [
+          {
+            "input": "./packages/config-tools",
+            "glob": "*.md",
+            "output": "."
+          },
+          {
+            "input": "",
+            "glob": "LICENSE",
+            "output": "."
+          },
+          {
+            "input": "./packages/config-tools",
+            "glob": "declarations.d.ts",
+            "output": "."
+          }
+        ],
+        "configurations": {
+          "production": {
+            "debug": false,
+            "verbose": false
+          },
+          "development": {
+            "debug": true,
+            "verbose": true
+          }
+        }
+      }
+    },
+    "lint": {},
+    "test": {}
+  }
+}

package/src/config-file/define-config.ts

@@ -0,0 +1,9 @@
+import type { StormConfigInput } from "../types";
+
+/**
+ * Type the config values for the current Storm workspace
+ *
+ * @param input - The config values for the current Storm workspace
+ * @returns The config values for the current Storm workspace
+ */
+export const defineConfig = (input: StormConfigInput) => input;

package/src/config-file/get-config-file.ts

@@ -0,0 +1,56 @@
+import { type CosmiconfigResult, cosmiconfig } from "cosmiconfig";
+import type { StormConfigInput } from "../types";
+
+let _static_cache: StormConfigInput | undefined = undefined;
+
+/**
+ * Get the config file for the current Storm workspace
+ *
+ * @param fileName - The name of the config file to search for
+ * @param filePath - The path to search for the config file in
+ * @returns The config file for the current Storm workspace
+ */
+export const getConfigFileByName = async (
+  fileName: string,
+  filePath?: string
+): Promise<CosmiconfigResult> => cosmiconfig(fileName, { cache: true }).search(filePath);
+
+/**
+ * Get the config file for the current Storm workspace
+ *
+ * @returns The config file for the current Storm workspace
+ */
+export const getConfigFile = async (filePath?: string): Promise<StormConfigInput> => {
+  if (_static_cache) {
+    return _static_cache as StormConfigInput;
+  }
+
+  let cosmiconfigResult = await getConfigFileByName("storm", filePath);
+  if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+    cosmiconfigResult = await getConfigFileByName("storm-software", filePath);
+    if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+      cosmiconfigResult = await getConfigFileByName("storm-stack", filePath);
+      if (!cosmiconfigResult || cosmiconfigResult.isEmpty) {
+        cosmiconfigResult = await getConfigFileByName("storm-cloud", filePath);
+      }
+    }
+  }
+
+  if (
+    !cosmiconfigResult ||
+    Object.keys(cosmiconfigResult).length === 0 ||
+    cosmiconfigResult.isEmpty ||
+    !cosmiconfigResult.filepath
+  ) {
+    return undefined;
+  }
+
+  const config: Partial<StormConfigInput> = cosmiconfigResult.config ?? {};
+  if (cosmiconfigResult.filepath) {
+    config.configFile = cosmiconfigResult.filepath;
+  }
+  config.runtimeVersion = "0.0.1";
+
+  _static_cache = config;
+  return config;
+};

package/src/config-file/index.ts

@@ -0,0 +1,2 @@
+export * from "./get-config-file";
+export * from "./define-config";

package/src/create-storm-config.ts

@@ -0,0 +1,129 @@
+import type { ZodTypeAny } from "zod";
+import { getConfigFile } from "./config-file/get-config-file";
+import { getConfigEnv, getExtensionEnv } from "./env/get-env";
+import { setConfigEnv } from "./env/set-env";
+import { StormConfigSchema } from "./schema";
+import type { StormConfig } from "./types";
+import { findWorkspaceRoot, writeWarning } from "./utilities";
+import { getDefaultConfig } from "./utilities/get-default-config";
+
+const _extension_cache = new WeakMap<{ extensionName: string }, any>();
+let _static_cache: StormConfig | undefined = undefined;
+
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace
+ */
+export const createConfig = (workspaceRoot?: string): StormConfig => {
+  return createStormConfig(undefined, undefined, workspaceRoot);
+};
+
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace
+ */
+export const createStormConfig = <
+  TExtensionName extends keyof StormConfig["extensions"] = keyof StormConfig["extensions"],
+  TExtensionConfig = any,
+  TExtensionSchema extends ZodTypeAny = ZodTypeAny
+>(
+  extensionName?: TExtensionName,
+  schema?: TExtensionSchema,
+  workspaceRoot?: string
+): StormConfig<TExtensionName, TExtensionConfig> => {
+  let result!: StormConfig<TExtensionName, TExtensionConfig>;
+  if (!_static_cache) {
+    const config = getConfigEnv() as StormConfig & {
+      [extensionName in TExtensionName]: TExtensionConfig;
+    };
+    const defaultConfig = getDefaultConfig(config, workspaceRoot);
+
+    result = StormConfigSchema.parse({
+      ...defaultConfig,
+      ...config,
+      colors: {
+        ...defaultConfig?.colors,
+        ...config.colors
+      }
+    }) as StormConfig<TExtensionName, TExtensionConfig>;
+  } else {
+    result = _static_cache as StormConfig<TExtensionName, TExtensionConfig>;
+  }
+
+  if (schema && extensionName) {
+    result.extensions = {
+      ...result.extensions,
+      [extensionName]: createConfigExtension<TExtensionName, TExtensionConfig, TExtensionSchema>(
+        extensionName,
+        schema
+      )
+    };
+  }
+
+  _static_cache = result;
+  return result;
+};
+
+/**
+ * Get the config for a specific Storm config Extension
+ *
+ * @param extensionName - The name of the config extension
+ * @param options - The options for the config extension
+ * @returns The config for the specified Storm config extension. If the extension does not exist, `undefined` is returned.
+ */
+export const createConfigExtension = <
+  TExtensionName extends keyof StormConfig["extensions"] = keyof StormConfig["extensions"],
+  TExtensionConfig = any,
+  TExtensionSchema extends ZodTypeAny = ZodTypeAny
+>(
+  extensionName: TExtensionName,
+  schema: TExtensionSchema
+): TExtensionConfig => {
+  const extension_cache_key = { extensionName };
+  if (_extension_cache.has(extension_cache_key)) {
+    return _extension_cache.get(extension_cache_key) as TExtensionConfig;
+  }
+
+  let extension = getExtensionEnv(extensionName);
+  if (schema) {
+    extension = schema.parse(extension);
+  }
+
+  _extension_cache.set(extension_cache_key, extension);
+  return extension as TExtensionConfig;
+};
+
+/**
+ * Load the config file values for the current Storm workspace into environment variables
+ */
+export const loadStormConfig = async (workspaceRoot?: string): Promise<StormConfig> => {
+  let config = {} as StormConfig;
+
+  let _workspaceRoot = workspaceRoot;
+  if (!_workspaceRoot) {
+    _workspaceRoot = findWorkspaceRoot();
+  }
+
+  const configFile = await getConfigFile(_workspaceRoot);
+  if (!configFile) {
+    writeWarning(
+      { logLevel: "all" },
+      "No Storm config file found in the current workspace. Please ensure this is the expected behavior - you can add a `storm.config.js` file to the root of your workspace if it is not.\n"
+    );
+  }
+
+  config = StormConfigSchema.parse(
+    await getDefaultConfig(
+      {
+        ...configFile,
+        ...getConfigEnv()
+      },
+      _workspaceRoot
+    )
+  );
+  setConfigEnv(config);
+
+  return config;
+};

package/src/env/get-env.ts

@@ -0,0 +1,115 @@
+import type { LogLevelLabel, StormConfig } from "../types";
+import { getLogLevelLabel } from "../utilities";
+
+/**
+ * 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 getExtensionEnv = <TConfig extends Record<string, any> = Record<string, any>>(
+  extensionName: string
+): TConfig | undefined => {
+  const prefix = `STORM_EXTENSION_${extensionName.toUpperCase()}_`;
+  return Object.keys(process.env)
+    .filter((key) => key.startsWith(prefix))
+    .reduce((ret: Record<string, any>, key: string) => {
+      const name = key
+        .replace(prefix, "")
+        .split("_")
+        .map((i) => (i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : ""))
+        .join("");
+      if (name) {
+        ret[name] = process.env[key];
+      }
+
+      return ret;
+    }, {}) as TConfig;
+};
+
+/**
+ * Get the config for the current Storm workspace
+ *
+ * @returns The config for the current Storm workspace from environment variables
+ */
+export const getConfigEnv = (): Partial<StormConfig> => {
+  const prefix = "STORM_";
+
+  let config: Partial<StormConfig> = {
+    name: process.env[`${prefix}NAME`],
+    namespace: process.env[`${prefix}NAMESPACE`],
+    owner: process.env[`${prefix}OWNER`],
+    worker: process.env[`${prefix}WORKER`],
+    organization: process.env[`${prefix}ORGANIZATION`],
+    packageManager: process.env[`${prefix}PACKAGE_MANAGER`] as StormConfig["packageManager"],
+    license: process.env[`${prefix}LICENSE`],
+    homepage: process.env[`${prefix}HOMEPAGE`],
+    timezone: process.env[`${prefix}TIMEZONE`] ?? process.env.TZ,
+    locale: process.env[`${prefix}LOCALE`] ?? process.env.LOCALE,
+    configFile: process.env[`${prefix}CONFIG_FILE`],
+    workspaceRoot: process.env[`${prefix}WORKSPACE_ROOT`],
+    packageDirectory: process.env[`${prefix}PACKAGE_DIRECTORY`],
+    buildDirectory: process.env[`${prefix}BUILD_DIRECTORY`],
+    runtimeVersion: process.env[`${prefix}RUNTIME_VERSION`],
+    runtimeDirectory: process.env[`${prefix}RUNTIME_DIRECTORY`],
+    env: (process.env[`${prefix}ENV`] ??
+      process.env.NODE_ENV ??
+      process.env.ENVIRONMENT) as StormConfig["env"],
+    ci:
+      process.env[`${prefix}CI`] !== undefined
+        ? Boolean(
+            process.env[`${prefix}CI`] ?? process.env.CI ?? process.env.CONTINUOUS_INTEGRATION
+          )
+        : undefined,
+    colors: {
+      primary: process.env[`${prefix}COLOR_PRIMARY`],
+      background: process.env[`${prefix}COLOR_BACKGROUND`],
+      success: process.env[`${prefix}COLOR_SUCCESS`],
+      info: process.env[`${prefix}COLOR_INFO`],
+      warning: process.env[`${prefix}COLOR_WARNING`],
+      error: process.env[`${prefix}COLOR_ERROR`],
+      fatal: process.env[`${prefix}COLOR_FATAL`]
+    },
+    repository: process.env[`${prefix}REPOSITORY`],
+    branch: process.env[`${prefix}BRANCH`],
+    preMajor:
+      process.env[`${prefix}PRE_MAJOR`] !== undefined
+        ? Boolean(process.env[`${prefix}PRE_MAJOR`])
+        : undefined,
+    logLevel:
+      process.env[`${prefix}LOG_LEVEL`] !== null && process.env[`${prefix}LOG_LEVEL`] !== undefined
+        ? Number.isSafeInteger(Number.parseInt(process.env[`${prefix}LOG_LEVEL`]))
+          ? getLogLevelLabel(Number.parseInt(process.env[`${prefix}LOG_LEVEL`]))
+          : (process.env[`${prefix}LOG_LEVEL`] as LogLevelLabel)
+        : undefined
+  };
+
+  const serializedConfig = process.env[`${prefix}CONFIG`];
+  if (serializedConfig) {
+    const parsed = JSON.parse(serializedConfig);
+    config = {
+      ...config,
+      ...parsed,
+      colors: { ...config.colors, ...parsed.colors },
+      extensions: { ...config.extensions, ...parsed.extensions }
+    };
+  }
+
+  return config;
+
+  /*const extensionPrefix = `${prefix}EXTENSION_`;
+  return Object.keys(process.env)
+    .filter((key) => key.startsWith(extensionPrefix))
+    .reduce((ret: StormConfig, key: string) => {
+      const extensionName = key
+        .substring(prefix.length, key.indexOf("_", prefix.length))
+        .split("_")
+        .map((i) => (i.length > 0 ? i.trim().charAt(0).toUpperCase() + i.trim().slice(1) : ""))
+        .join("");
+      if (extensionName) {
+        ret.extensions[extensionName] = getExtensionEnv(extensionName);
+      }
+
+      return ret;
+    }, config);*/
+};

package/src/env/index.ts

@@ -0,0 +1,2 @@
+export * from "./get-env";
+export * from "./set-env";

package/src/env/set-env.ts

@@ -0,0 +1,162 @@
+import { LogLevel, type StormConfig } from "../types";
+import { getLogLevel } from "../utilities/get-log-level";
+
+/**
+ * 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.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`] = config.configFile;
+  }
+  if (config.workspaceRoot) {
+    process.env[`${prefix}WORKSPACE_ROOT`] = config.workspaceRoot;
+    process.env.NX_WORKSPACE_ROOT = config.workspaceRoot;
+    process.env.NX_WORKSPACE_ROOT_PATH = config.workspaceRoot;
+  }
+  if (config.packageDirectory) {
+    process.env[`${prefix}PACKAGE_DIRECTORY`] = config.packageDirectory;
+  }
+  if (config.buildDirectory) {
+    process.env[`${prefix}BUILD_DIRECTORY`] = config.buildDirectory;
+  }
+  if (config.runtimeVersion) {
+    process.env[`${prefix}RUNTIME_VERSION`] = config.runtimeVersion;
+  }
+  if (config.runtimeDirectory) {
+    process.env[`${prefix}RUNTIME_DIRECTORY`] = 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.preMajor) {
+    process.env[`${prefix}PRE_MAJOR`] = String(config.preMajor);
+  }
+  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,15 @@
+/**
+ * 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 "./schema";
+export * from "./types";
+export * from "./utilities";