@storm-software/config-tools 1.21.5 → 1.22.1

package/src/schema.ts

@@ -0,0 +1,182 @@
+import * as z from "zod";
+
+/**
+ * Storm theme color config values used for styling various workspace elements
+ */
+export const ColorConfigSchema = z
+  .object({
+    primary: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .regex(/^#([0-9a-f]{3}){1,2}$/i)
+      .length(7)
+      .default("#0ea5e9")
+      .describe("The primary color of the workspace"),
+    background: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .regex(/^#([0-9a-f]{3}){1,2}$/i)
+      .length(7)
+      .default("#1d232a")
+      .describe("The background color of the workspace"),
+    success: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .regex(/^#([0-9a-f]{3}){1,2}$/i)
+      .length(7)
+      .default("#087f5b")
+      .describe("The success color of the workspace"),
+    info: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .regex(/^#([0-9a-f]{3}){1,2}$/i)
+      .length(7)
+      .default("#0ea5e9")
+      .describe("The informational color of the workspace"),
+    warning: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .regex(/^#([0-9a-f]{3}){1,2}$/i)
+      .length(7)
+      .default("#fcc419")
+      .describe("The warning color of the workspace"),
+    error: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .regex(/^#([0-9a-f]{3}){1,2}$/i)
+      .length(7)
+      .default("#990000")
+      .describe("The error color of the workspace"),
+    fatal: z
+      .string()
+      .trim()
+      .toLowerCase()
+      .regex(/^#([0-9a-f]{3}){1,2}$/i)
+      .length(7)
+      .default("#7d1a1a")
+      .describe("The fatal color of the workspace")
+  })
+  .describe("Colors used for various workspace elements");
+
+/**
+ * Storm Workspace config values used during various dev-ops processes. It represents the config of the entire monorepo.
+ */
+export const StormConfigSchema = z
+  .object({
+    name: z.string().trim().toLowerCase().optional().describe("The name of the package"),
+    namespace: z.string().trim().toLowerCase().optional().describe("The namespace of the package"),
+    organization: z
+      .string()
+      .trim()
+      .default("storm-software")
+      .describe("The organization of the workspace"),
+    repository: z
+      .string()
+      .trim()
+      .url()
+      .optional()
+      .describe("The repo URL of the workspace (i.e. GitHub)"),
+    license: z
+      .string()
+      .trim()
+      .default("Apache License 2.0")
+      .describe("The root directory of the package"),
+    homepage: z
+      .string()
+      .trim()
+      .url()
+      .default("https://stormsoftware.org")
+      .describe("The homepage of the workspace"),
+    branch: z.string().trim().default("main").describe("The branch of the workspace"),
+    preMajor: z
+      .boolean()
+      .default(false)
+      .describe("An indicator specifying if the package is still in it's pre-major version"),
+    owner: z
+      .string()
+      .trim()
+      .default("@storm-software/development")
+      .describe("The owner of the package"),
+    worker: z
+      .string()
+      .trim()
+      .default("stormie-bot")
+      .describe(
+        "The worker of the package (this is the bot that will be used to perform various tasks)"
+      ),
+    env: z
+      .enum(["development", "staging", "production"])
+      .default("production")
+      .describe("The current runtime environment of the package"),
+    ci: z
+      .boolean()
+      .default(true)
+      .describe("An indicator specifying if the current environment is a CI environment"),
+    workspaceRoot: z.string().trim().optional().describe("The root directory of the workspace"),
+    packageDirectory: z.string().trim().optional().describe("The root directory of the package"),
+    externalPackagePatterns: z
+      .array(z.string())
+      .default([])
+      .describe(
+        "The build will use these package patterns to determine if they should be external to the bundle"
+      ),
+    buildDirectory: z
+      .string()
+      .trim()
+      .default("dist")
+      .describe("The build directory for the workspace"),
+    runtimeDirectory: z
+      .string()
+      .trim()
+      .default("node_modules/.storm")
+      .describe("The runtime directory of Storm"),
+    runtimeVersion: z
+      .string()
+      .trim()
+      .regex(
+        /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/
+      )
+      .default("1.0.0")
+      .describe("The global version of the Storm runtime"),
+    packageManager: z
+      .enum(["npm", "yarn", "pnpm", "bun"])
+      .default("npm")
+      .describe("The package manager used by the repository"),
+    timezone: z
+      .string()
+      .trim()
+      .default("America/New_York")
+      .describe("The default timezone of the workspace"),
+    locale: z.string().trim().default("en-US").describe("The default locale of the workspace"),
+    logLevel: z
+      .enum(["silent", "fatal", "error", "warn", "info", "debug", "trace", "all"])
+      .default("debug")
+      .describe(
+        "The log level used to filter out lower priority log messages. If not provided, this is defaulted using the `environment` config value (if `environment` is set to `production` then `level` is `error`, else `level` is `debug`)."
+      ),
+    configFile: z
+      .string()
+      .trim()
+      .nullable()
+      .default(null)
+      .describe(
+        "The filepath of the Storm config. When this field is null, no config file was found in the current workspace."
+      ),
+    colors: ColorConfigSchema.describe(
+      "Storm theme config values used for styling various package elements"
+    ),
+    extensions: z
+      .record(z.any())
+      .optional()
+      .default({})
+      .describe("Configuration of each used extension")
+  })
+  .describe(
+    "Storm Workspace config values used during various dev-ops processes. This type is a combination of the StormPackageConfig and StormProject types. It represents the config of the entire monorepo."
+  );

package/src/types.ts

@@ -0,0 +1,53 @@
+import type * as z from "zod";
+import type { ColorConfigSchema, StormConfigSchema } from "./schema";
+
+export type ColorConfig = z.infer<typeof ColorConfigSchema>;
+export type ColorConfigInput = z.input<typeof ColorConfigSchema>;
+
+type TStormConfig = z.infer<typeof StormConfigSchema>;
+export type StormConfigInput = z.input<typeof StormConfigSchema>;
+
+export type StormConfig<
+  TExtensionName extends keyof TStormConfig["extensions"] = keyof TStormConfig["extensions"],
+  TExtensionConfig extends
+    TStormConfig["extensions"][TExtensionName] = TStormConfig["extensions"][TExtensionName]
+> = TStormConfig & {
+  extensions?:
+    | (TStormConfig["extensions"] & {
+        [extensionName in TExtensionName]: TExtensionConfig;
+      })
+    | Record<string, any>;
+};
+
+export type LogLevel = 0 | 10 | 20 | 30 | 40 | 45 | 60 | 70 | 100;
+export const LogLevel = {
+  SILENT: 0 as LogLevel,
+  FATAL: 10 as LogLevel,
+  ERROR: 20 as LogLevel,
+  WARN: 30 as LogLevel,
+  INFO: 40 as LogLevel,
+  SUCCESS: 45 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;

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,66 @@
+import { findFolderUp } from "./find-up";
+
+const rootFiles = [
+  "lerna.json",
+  "storm.config.js",
+  "storm.config.ts",
+  ".storm.json",
+  ".storm.yaml",
+  ".storm.yml",
+  ".storm.js",
+  ".storm.ts",
+  "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 process.env.STORM_WORKSPACE_ROOT ?? process.env.NX_WORKSPACE_ROOT_PATH;
+  }
+
+  return 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 { StormConfigSchema } from "../schema";
+import type { ColorConfig, StormConfig } from "../types";
+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: StormConfig = {
+  name: "storm",
+  namespace: "storm-software",
+  license: "Apache License 2.0",
+  homepage: "https://stormsoftware.org",
+  preMajor: false,
+  owner: "@storm-software/development",
+  worker: "stormie-bot",
+  runtimeDirectory: "node_modules/.storm",
+  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): 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,6 @@
+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";