@logbrew/sdk 0.1.38 → 0.1.39

package/vite-release-artifacts.cjs

@@ -1,6 +1,6 @@
 "use strict";
 
-const fs = require("node:fs");
+const { mkdir, writeFile } = require("node:fs/promises");
 const path = require("node:path");
 
 const {
@@ -8,25 +8,74 @@ const {
   formatReleaseArtifactUploadSummary,
   normalizeReleaseArtifactProjectId,
   normalizeReleaseArtifactUploadOptions,
-  runReleaseArtifactCli,
+  runReleaseArtifactCli
 } = require("./release-artifacts-build.cjs");
+const { viteConfigChanges } = require("./vite-release-artifacts-config.cjs");
+
+/**
+ * @import { ReleaseArtifactUploadOptions } from "./release-artifacts-build.cjs"
+ * @import { ViteConfigChanges, ViteUserConfig } from "./vite-release-artifacts-config.cjs"
+ * @typedef {{ readonly info: (message: string) => void }} ViteLogger
+ * @typedef {{
+ *   readonly build?: { readonly outDir?: string | null } | null,
+ *   readonly logger?: ViteLogger | null,
+ *   readonly root?: string | null
+ * }} ViteResolvedConfig
+ * @typedef {{
+ *   readonly commitSha: string | undefined,
+ *   readonly enableSourceMaps: boolean,
+ *   readonly environment: string,
+ *   readonly explicitBuildDir: string | undefined,
+ *   readonly explicitManifestPath: string | undefined,
+ *   readonly minifiedPathPrefix: string,
+ *   readonly projectId: string | undefined,
+ *   readonly release: string,
+ *   readonly repositoryUrl: string | undefined,
+ *   readonly service: string,
+ *   readonly stripSourcesContent: boolean,
+ *   readonly upload: ReleaseArtifactUploadOptions | undefined,
+ *   readonly userSourcePrefixes: readonly string[]
+ * }} PluginSettings
+ * @typedef {{ readonly logger: ViteLogger | undefined, readonly outDir: string, readonly root: string }} ViteBuildContext
+ */
 
 const PACKAGE_DIR = path.dirname(require.resolve("./package.json"));
 const CLI_PATH = path.join(PACKAGE_DIR, "release-artifacts.js");
 const DEFAULT_MANIFEST_NAME = "logbrew-release-artifacts.json";
+const DEFAULT_OUT_DIR = "dist";
+const NO_PREFIXES = 0;
+
+/**
+ * @param {unknown} value
+ * @param {string} key
+ * @returns {unknown}
+ */
+function field(value, key) {
+  return (typeof value === "object" && value !== null) || typeof value === "function" ? Reflect.get(value, key) : undefined;
+}
 
+/**
+ * @param {unknown} options
+ * @param {string} name
+ * @returns {string}
+ */
 function requiredString(options, name) {
-  const value = options?.[name];
+  const value = field(options, name);
   if (typeof value !== "string" || value.trim() === "") {
     throw new Error(`LogBrew Vite release-artifact plugin requires ${name}`);
   }
   return value.trim();
 }
 
+/**
+ * @param {unknown} options
+ * @param {string} name
+ * @returns {string | undefined}
+ */
 function optionalString(options, name) {
-  const value = options?.[name];
+  const value = field(options, name);
   if (value === undefined || value === null) {
-    return null;
+    return undefined;
   }
   if (typeof value !== "string" || value.trim() === "") {
     throw new Error(`LogBrew Vite release-artifact plugin option ${name} must be a non-empty string`);
@@ -34,130 +83,181 @@ function optionalString(options, name) {
   return value.trim();
 }
 
+/**
+ * @param {unknown} value
+ * @param {string} name
+ * @returns {string[]}
+ */
 function normalizeStringArray(value, name) {
   if (value === undefined || value === null) {
     return [];
   }
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.trim() === "")) {
+  /** @type {readonly unknown[]} */
+  const items = Array.isArray(value) ? value : [value];
+  const valid = Array.isArray(value) && items.every((item) => typeof item === "string" && item.trim() !== "");
+  if (!valid) {
     throw new Error(`LogBrew Vite release-artifact plugin option ${name} must be an array of non-empty strings`);
   }
-  return value.map((item) => item.trim());
+  return items.map((item) => String(item).trim());
 }
 
+/**
+ * @param {string} root
+ * @param {string} value
+ * @returns {string}
+ */
 function resolvePathFromRoot(root, value) {
   return path.isAbsolute(value) ? path.resolve(value) : path.resolve(root, value);
 }
 
-function resolveBuildDir(root, outDir, explicitBuildDir) {
-  if (explicitBuildDir) {
-    return resolvePathFromRoot(root, explicitBuildDir);
-  }
-  return resolvePathFromRoot(root, outDir || "dist");
-}
-
-function viteMajorVersion(root) {
-  try {
-    const manifestPath = require.resolve("vite/package.json", { paths: [path.resolve(root || process.cwd())] });
-    const version = JSON.parse(fs.readFileSync(manifestPath, "utf8")).version;
-    return Number.parseInt(version, 10) || 0;
-  } catch {
-    return 0;
-  }
-}
-
-function createLogBrewViteReleaseArtifactsPlugin(options) {
+/**
+ * @param {unknown} options
+ * @returns {Pick<PluginSettings, "environment" | "minifiedPathPrefix" | "projectId" | "release" | "service">}
+ */
+function releaseIdentity(options) {
   const release = requiredString(options, "release");
   const environment = requiredString(options, "environment");
   const service = requiredString(options, "service");
-  const projectId = normalizeReleaseArtifactProjectId(options?.projectId, "Vite");
+  const projectId = normalizeReleaseArtifactProjectId(field(options, "projectId"), "Vite");
   const minifiedPathPrefix = requiredString(options, "minifiedPathPrefix");
+  return { environment, minifiedPathPrefix, projectId, release, service };
+}
+
+/**
+ * @param {unknown} options
+ * @returns {PluginSettings}
+ */
+function pluginSettings(options) {
+  const identity = releaseIdentity(options);
   const repositoryUrl = optionalString(options, "repositoryUrl");
   const commitSha = optionalString(options, "commitSha");
   const explicitBuildDir = optionalString(options, "buildDir");
   const explicitManifestPath = optionalString(options, "manifestPath");
-  const stripSourcesContent = options?.stripSourcesContent !== false;
-  const enableSourceMaps = options?.enableSourceMaps !== false;
-  const userSourcePrefixes = normalizeStringArray(options?.stripSourcePrefix, "stripSourcePrefix");
-  const upload = normalizeReleaseArtifactUploadOptions(options?.upload, { integration: "Vite", projectId });
-  let viteRoot = process.cwd();
-  let viteOutDir = "dist";
-  let viteLogger = null;
+  const stripSourcesContent = field(options, "stripSourcesContent") !== false;
+  const enableSourceMaps = field(options, "enableSourceMaps") !== false;
+  const userSourcePrefixes = normalizeStringArray(field(options, "stripSourcePrefix"), "stripSourcePrefix");
+  return {
+    ...identity,
+    commitSha,
+    enableSourceMaps,
+    explicitBuildDir,
+    explicitManifestPath,
+    repositoryUrl,
+    stripSourcesContent,
+    upload: normalizeReleaseArtifactUploadOptions(field(options, "upload"), { integration: "Vite", projectId: identity.projectId }),
+    userSourcePrefixes
+  };
+}
 
+/**
+ * @param {PluginSettings} settings
+ * @param {string} buildDir
+ * @param {string} root
+ * @returns {string[]}
+ */
+function prepareArgs({ stripSourcesContent, userSourcePrefixes }, buildDir, root) {
+  const sourcePrefixes = userSourcePrefixes.length > NO_PREFIXES ? userSourcePrefixes : [root];
+  return [
+    "--build-dir",
+    buildDir,
+    "--write",
+    ...(stripSourcesContent ? ["--strip-sources-content"] : []),
+    ...sourcePrefixes.flatMap((prefix) => ["--strip-source-prefix", prefix])
+  ];
+}
+
+/**
+ * @param {PluginSettings} settings
+ * @param {string} buildDir
+ * @returns {string[]}
+ */
+function manifestArgs({ commitSha, environment, minifiedPathPrefix, projectId, release, repositoryUrl, service }, buildDir) {
+  return [
+    "--build-dir",
+    buildDir,
+    "--release",
+    release,
+    "--environment",
+    environment,
+    "--service",
+    service,
+    "--minified-path-prefix",
+    minifiedPathPrefix,
+    ...(repositoryUrl === undefined ? [] : ["--repository-url", repositoryUrl]),
+    ...(commitSha === undefined ? [] : ["--commit-sha", commitSha]),
+    ...(projectId === undefined ? [] : ["--project-id", projectId])
+  ];
+}
+
+/**
+ * @param {PluginSettings} settings
+ * @param {ViteBuildContext} context
+ * @returns {Promise<void>}
+ */
+async function writeReleaseArtifacts(settings, { logger, outDir, root }) {
+  const buildDir = resolvePathFromRoot(root, settings.explicitBuildDir ?? outDir);
+  const manifestPath = settings.explicitManifestPath === undefined
+    ? path.join(buildDir, DEFAULT_MANIFEST_NAME)
+    : resolvePathFromRoot(root, settings.explicitManifestPath);
+  runReleaseArtifactCli(CLI_PATH, "prepare-js", prepareArgs(settings, buildDir, root));
+  const { stdout } = runReleaseArtifactCli(CLI_PATH, "manifest-js", manifestArgs(settings, buildDir));
+  await mkdir(path.dirname(manifestPath), { recursive: true });
+  await writeFile(manifestPath, stdout, "utf8");
+  if (settings.upload !== undefined) {
+    const { report } = runReleaseArtifactCli(
+      CLI_PATH,
+      "upload-js",
+      createReleaseArtifactUploadArgs(buildDir, manifestPath, settings.upload)
+    );
+    logger?.info(formatReleaseArtifactUploadSummary(report));
+  }
+}
+
+/**
+ * @param {ViteResolvedConfig | null | undefined} config
+ * @returns {ViteBuildContext}
+ */
+function resolvedContext(config) {
+  const root = config?.root;
+  const outDir = config?.build?.outDir;
+  const logger = config?.logger;
+  return {
+    logger: typeof logger?.info === "function" ? logger : undefined,
+    outDir: outDir === undefined || outDir === null || outDir === "" ? DEFAULT_OUT_DIR : outDir,
+    root: root === undefined || root === null || root === "" ? process.cwd() : path.resolve(root)
+  };
+}
+
+/**
+ * @param {unknown} options
+ * @returns {{
+ *   readonly apply: "build",
+ *   readonly config: (config?: ViteUserConfig) => ViteConfigChanges | null,
+ *   readonly configResolved: (config: ViteResolvedConfig | null | undefined) => void,
+ *   readonly enforce: "post",
+ *   readonly name: "logbrew-vite-release-artifacts",
+ *   readonly writeBundle: () => Promise<void>
+ * }}
+ */
+function createLogBrewViteReleaseArtifactsPlugin(options) {
+  const settings = pluginSettings(options);
+  /** @type {ViteBuildContext} */
+  let context = { logger: undefined, outDir: DEFAULT_OUT_DIR, root: process.cwd() };
   return {
     name: "logbrew-vite-release-artifacts",
+
     apply: "build",
+
     enforce: "post",
+
     config(config = {}) {
-      const sourceMap = enableSourceMaps && config.build?.sourcemap === undefined;
-      const keepNames = config.build?.minify === undefined;
-      const output = config.build?.rolldownOptions?.output;
-      const viteMajor = viteMajorVersion(config.root);
-      const modernNames = keepNames && viteMajor >= 8
-        && !Array.isArray(output) && output?.keepNames === undefined;
-      const legacyNames = keepNames && viteMajor < 8
-        && config.esbuild !== false && config.esbuild?.keepNames === undefined;
-      return sourceMap || modernNames || legacyNames ? {
-        ...(sourceMap || modernNames ? { build: {
-          ...(sourceMap ? { sourcemap: "hidden" } : {}),
-          ...(modernNames ? { rolldownOptions: { output: { keepNames: true } } } : {})
-        } } : {}),
-        ...(legacyNames ? { esbuild: { keepNames: true } } : {})
-      } : null;
+      return viteConfigChanges(config, settings.enableSourceMaps);
     },
     configResolved(config) {
-      viteRoot = config?.root ? path.resolve(config.root) : process.cwd();
-      viteOutDir = config?.build?.outDir || "dist";
-      viteLogger = config?.logger && typeof config.logger.info === "function" ? config.logger : null;
+      context = resolvedContext(config);
     },
     async writeBundle() {
-      const buildDir = resolveBuildDir(viteRoot, viteOutDir, explicitBuildDir);
-      const manifestPath = explicitManifestPath
-        ? resolvePathFromRoot(viteRoot, explicitManifestPath)
-        : path.join(buildDir, DEFAULT_MANIFEST_NAME);
-      const sourcePrefixes = userSourcePrefixes.length > 0 ? userSourcePrefixes : [viteRoot];
-      const prepareArgs = ["--build-dir", buildDir, "--write"];
-      if (stripSourcesContent) {
-        prepareArgs.push("--strip-sources-content");
-      }
-      for (const prefix of sourcePrefixes) {
-        prepareArgs.push("--strip-source-prefix", prefix);
-      }
-
-      runReleaseArtifactCli(CLI_PATH, "prepare-js", prepareArgs);
-
-      const manifestArgs = [
-        "--build-dir",
-        buildDir,
-        "--release",
-        release,
-        "--environment",
-        environment,
-        "--service",
-        service,
-        "--minified-path-prefix",
-        minifiedPathPrefix
-      ];
-      if (repositoryUrl) {
-        manifestArgs.push("--repository-url", repositoryUrl);
-      }
-      if (commitSha) {
-        manifestArgs.push("--commit-sha", commitSha);
-      }
-      if (projectId) {
-        manifestArgs.push("--project-id", projectId);
-      }
-
-      const { stdout } = runReleaseArtifactCli(CLI_PATH, "manifest-js", manifestArgs);
-      fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
-      fs.writeFileSync(manifestPath, stdout, "utf8");
-      if (upload) {
-        const { report } = runReleaseArtifactCli(
-          CLI_PATH,
-          "upload-js",
-          createReleaseArtifactUploadArgs(buildDir, manifestPath, upload)
-        );
-        viteLogger?.info(formatReleaseArtifactUploadSummary(report));
-      }
+      await writeReleaseArtifacts(settings, context);
     }
   };
 }

package/vite-release-artifacts.d.cts

@@ -1,44 +1,69 @@
-export interface LogBrewViteReleaseArtifactUploadOptions {
-  endpoint: string;
-  allowHostedUpload?: boolean;
-  tokenEnv?: string;
-  dryRun?: boolean;
-  maxRetries?: number;
-  retryDelay?: number;
-  timeout?: number;
-}
-
-export interface LogBrewViteReleaseArtifactsPluginOptions {
-  release: string;
-  environment: string;
-  service: string;
-  projectId?: string;
-  minifiedPathPrefix: string;
-  buildDir?: string;
-  manifestPath?: string;
-  repositoryUrl?: string;
-  commitSha?: string;
-  stripSourcesContent?: boolean;
-  stripSourcePrefix?: string[];
-  enableSourceMaps?: boolean;
-  upload?: LogBrewViteReleaseArtifactUploadOptions;
-}
-
-export interface LogBrewViteReleaseArtifactsPlugin {
-  name: "logbrew-vite-release-artifacts";
-  apply: "build";
-  enforce: "post";
-  config(config?: { root?: string; build?: { sourcemap?: unknown; minify?: unknown; rolldownOptions?: { output?: { keepNames?: boolean } | Array<{ keepNames?: boolean }> } }; esbuild?: false | { keepNames?: boolean } }): null | { build?: { sourcemap?: "hidden"; rolldownOptions?: { output: { keepNames: true } } }; esbuild?: { keepNames: true } };
-  configResolved(config: {
-    root?: string;
-    build?: { outDir?: string };
-    logger?: { info(message: string): void };
-  }): void;
-  writeBundle(): Promise<void>;
-}
-
-export declare function createLogBrewViteReleaseArtifactsPlugin(
+type LogBrewViteReleaseArtifactUploadOptions = {
+  readonly endpoint: string;
+  readonly allowHostedUpload?: boolean;
+  readonly tokenEnv?: string;
+  readonly dryRun?: boolean;
+  readonly maxRetries?: number;
+  readonly retryDelay?: number;
+  readonly timeout?: number;
+};
+
+type LogBrewViteReleaseArtifactsPluginOptions = {
+  readonly release: string;
+  readonly environment: string;
+  readonly service: string;
+  readonly projectId?: string;
+  readonly minifiedPathPrefix: string;
+  readonly buildDir?: string;
+  readonly manifestPath?: string;
+  readonly repositoryUrl?: string;
+  readonly commitSha?: string;
+  readonly stripSourcesContent?: boolean;
+  readonly stripSourcePrefix?: readonly string[];
+  readonly enableSourceMaps?: boolean;
+  readonly upload?: LogBrewViteReleaseArtifactUploadOptions;
+};
+
+type ViteKeepNamesOutput = { readonly keepNames?: boolean };
+
+type ViteUserConfigInput = {
+  readonly root?: string;
+  readonly build?: {
+    readonly sourcemap?: unknown;
+    readonly minify?: unknown;
+    readonly rolldownOptions?: { readonly output?: ViteKeepNamesOutput | readonly ViteKeepNamesOutput[] };
+  };
+  readonly esbuild?: false | { readonly keepNames?: boolean };
+};
+
+type ViteConfigChanges = {
+  build?: { sourcemap?: "hidden"; rolldownOptions?: { output: { keepNames: true } } };
+  esbuild?: { keepNames: true };
+};
+
+type ViteResolvedConfigInput = {
+  readonly root?: string;
+  readonly build?: { readonly outDir?: string };
+  readonly logger?: { readonly info: (message: string) => void };
+};
+
+type LogBrewViteReleaseArtifactsPlugin = {
+  readonly name: "logbrew-vite-release-artifacts";
+  readonly apply: "build";
+  readonly enforce: "post";
+  readonly config: (config?: ViteUserConfigInput) => null | ViteConfigChanges;
+  readonly configResolved: (config: ViteResolvedConfigInput) => void;
+  readonly writeBundle: () => Promise<void>;
+};
+
+declare function createLogBrewViteReleaseArtifactsPlugin(
   options: LogBrewViteReleaseArtifactsPluginOptions
 ): LogBrewViteReleaseArtifactsPlugin;
 
+export type {
+  LogBrewViteReleaseArtifactsPlugin,
+  LogBrewViteReleaseArtifactsPluginOptions,
+  LogBrewViteReleaseArtifactUploadOptions
+};
+export { createLogBrewViteReleaseArtifactsPlugin };
 export default createLogBrewViteReleaseArtifactsPlugin;

package/vite-release-artifacts.d.ts

@@ -1,44 +1,69 @@
-export interface LogBrewViteReleaseArtifactUploadOptions {
-  endpoint: string;
-  allowHostedUpload?: boolean;
-  tokenEnv?: string;
-  dryRun?: boolean;
-  maxRetries?: number;
-  retryDelay?: number;
-  timeout?: number;
-}
-
-export interface LogBrewViteReleaseArtifactsPluginOptions {
-  release: string;
-  environment: string;
-  service: string;
-  projectId?: string;
-  minifiedPathPrefix: string;
-  buildDir?: string;
-  manifestPath?: string;
-  repositoryUrl?: string;
-  commitSha?: string;
-  stripSourcesContent?: boolean;
-  stripSourcePrefix?: string[];
-  enableSourceMaps?: boolean;
-  upload?: LogBrewViteReleaseArtifactUploadOptions;
-}
-
-export interface LogBrewViteReleaseArtifactsPlugin {
-  name: "logbrew-vite-release-artifacts";
-  apply: "build";
-  enforce: "post";
-  config(config?: { root?: string; build?: { sourcemap?: unknown; minify?: unknown; rolldownOptions?: { output?: { keepNames?: boolean } | Array<{ keepNames?: boolean }> } }; esbuild?: false | { keepNames?: boolean } }): null | { build?: { sourcemap?: "hidden"; rolldownOptions?: { output: { keepNames: true } } }; esbuild?: { keepNames: true } };
-  configResolved(config: {
-    root?: string;
-    build?: { outDir?: string };
-    logger?: { info(message: string): void };
-  }): void;
-  writeBundle(): Promise<void>;
-}
-
-export declare function createLogBrewViteReleaseArtifactsPlugin(
+type LogBrewViteReleaseArtifactUploadOptions = {
+  readonly endpoint: string;
+  readonly allowHostedUpload?: boolean;
+  readonly tokenEnv?: string;
+  readonly dryRun?: boolean;
+  readonly maxRetries?: number;
+  readonly retryDelay?: number;
+  readonly timeout?: number;
+};
+
+type LogBrewViteReleaseArtifactsPluginOptions = {
+  readonly release: string;
+  readonly environment: string;
+  readonly service: string;
+  readonly projectId?: string;
+  readonly minifiedPathPrefix: string;
+  readonly buildDir?: string;
+  readonly manifestPath?: string;
+  readonly repositoryUrl?: string;
+  readonly commitSha?: string;
+  readonly stripSourcesContent?: boolean;
+  readonly stripSourcePrefix?: readonly string[];
+  readonly enableSourceMaps?: boolean;
+  readonly upload?: LogBrewViteReleaseArtifactUploadOptions;
+};
+
+type ViteKeepNamesOutput = { readonly keepNames?: boolean };
+
+type ViteUserConfigInput = {
+  readonly root?: string;
+  readonly build?: {
+    readonly sourcemap?: unknown;
+    readonly minify?: unknown;
+    readonly rolldownOptions?: { readonly output?: ViteKeepNamesOutput | readonly ViteKeepNamesOutput[] };
+  };
+  readonly esbuild?: false | { readonly keepNames?: boolean };
+};
+
+type ViteConfigChanges = {
+  build?: { sourcemap?: "hidden"; rolldownOptions?: { output: { keepNames: true } } };
+  esbuild?: { keepNames: true };
+};
+
+type ViteResolvedConfigInput = {
+  readonly root?: string;
+  readonly build?: { readonly outDir?: string };
+  readonly logger?: { readonly info: (message: string) => void };
+};
+
+type LogBrewViteReleaseArtifactsPlugin = {
+  readonly name: "logbrew-vite-release-artifacts";
+  readonly apply: "build";
+  readonly enforce: "post";
+  readonly config: (config?: ViteUserConfigInput) => null | ViteConfigChanges;
+  readonly configResolved: (config: ViteResolvedConfigInput) => void;
+  readonly writeBundle: () => Promise<void>;
+};
+
+declare function createLogBrewViteReleaseArtifactsPlugin(
   options: LogBrewViteReleaseArtifactsPluginOptions
 ): LogBrewViteReleaseArtifactsPlugin;
 
+export type {
+  LogBrewViteReleaseArtifactsPlugin,
+  LogBrewViteReleaseArtifactsPluginOptions,
+  LogBrewViteReleaseArtifactUploadOptions
+};
+export { createLogBrewViteReleaseArtifactsPlugin };
 export default createLogBrewViteReleaseArtifactsPlugin;

package/vite-release-artifacts.js

@@ -1,6 +1,6 @@
 import viteReleaseArtifacts from "./vite-release-artifacts.cjs";
 
-export const createLogBrewViteReleaseArtifactsPlugin =
-  viteReleaseArtifacts.createLogBrewViteReleaseArtifactsPlugin;
+const { createLogBrewViteReleaseArtifactsPlugin } = viteReleaseArtifacts;
 
+export { createLogBrewViteReleaseArtifactsPlugin };
 export default createLogBrewViteReleaseArtifactsPlugin;