@cloudflare/autoconfig 0.0.0 → 0.1.2

package/dist/chunk-6EUZQHAF.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export { __commonJS, __esm, __export, __name, __require, __toCommonJS, __toESM };

package/dist/dot-prop-6SRZBKHT.js

@@ -0,0 +1,270 @@
+import { __name } from './chunk-6EUZQHAF.js';
+
+// ../../node_modules/.pnpm/dot-prop@9.0.0/node_modules/dot-prop/index.js
+var isObject = /* @__PURE__ */ __name((value) => {
+  const type = typeof value;
+  return value !== null && (type === "object" || type === "function");
+}, "isObject");
+var isEmptyObject = /* @__PURE__ */ __name((value) => isObject(value) && Object.keys(value).length === 0, "isEmptyObject");
+var disallowedKeys = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+var digits = new Set("0123456789");
+function getPathSegments(path) {
+  const parts = [];
+  let currentSegment = "";
+  let currentPart = "start";
+  let isIgnoring = false;
+  for (const character of path) {
+    switch (character) {
+      case "\\": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+        if (isIgnoring) {
+          currentSegment += character;
+        }
+        currentPart = "property";
+        isIgnoring = !isIgnoring;
+        break;
+      }
+      case ".": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "property";
+          break;
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += character;
+          break;
+        }
+        if (disallowedKeys.has(currentSegment)) {
+          return [];
+        }
+        parts.push(currentSegment);
+        currentSegment = "";
+        currentPart = "property";
+        break;
+      }
+      case "[": {
+        if (currentPart === "index") {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          currentPart = "index";
+          break;
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += character;
+          break;
+        }
+        if (currentPart === "property") {
+          if (disallowedKeys.has(currentSegment)) {
+            return [];
+          }
+          parts.push(currentSegment);
+          currentSegment = "";
+        }
+        currentPart = "index";
+        break;
+      }
+      case "]": {
+        if (currentPart === "index") {
+          parts.push(Number.parseInt(currentSegment, 10));
+          currentSegment = "";
+          currentPart = "indexEnd";
+          break;
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+      }
+      default: {
+        if (currentPart === "index" && !digits.has(character)) {
+          throw new Error("Invalid character in an index");
+        }
+        if (currentPart === "indexEnd") {
+          throw new Error("Invalid character after an index");
+        }
+        if (currentPart === "start") {
+          currentPart = "property";
+        }
+        if (isIgnoring) {
+          isIgnoring = false;
+          currentSegment += "\\";
+        }
+        currentSegment += character;
+      }
+    }
+  }
+  if (isIgnoring) {
+    currentSegment += "\\";
+  }
+  switch (currentPart) {
+    case "property": {
+      if (disallowedKeys.has(currentSegment)) {
+        return [];
+      }
+      parts.push(currentSegment);
+      break;
+    }
+    case "index": {
+      throw new Error("Index was not closed");
+    }
+    case "start": {
+      parts.push("");
+      break;
+    }
+  }
+  return parts;
+}
+__name(getPathSegments, "getPathSegments");
+function isStringIndex(object, key) {
+  if (typeof key !== "number" && Array.isArray(object)) {
+    const index = Number.parseInt(key, 10);
+    return Number.isInteger(index) && object[index] === object[key];
+  }
+  return false;
+}
+__name(isStringIndex, "isStringIndex");
+function assertNotStringIndex(object, key) {
+  if (isStringIndex(object, key)) {
+    throw new Error("Cannot use string index");
+  }
+}
+__name(assertNotStringIndex, "assertNotStringIndex");
+function getProperty(object, path, value) {
+  if (!isObject(object) || typeof path !== "string") {
+    return value === void 0 ? object : value;
+  }
+  const pathArray = getPathSegments(path);
+  if (pathArray.length === 0) {
+    return value;
+  }
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    if (isStringIndex(object, key)) {
+      object = index === pathArray.length - 1 ? void 0 : null;
+    } else {
+      object = object[key];
+    }
+    if (object === void 0 || object === null) {
+      if (index !== pathArray.length - 1) {
+        return value;
+      }
+      break;
+    }
+  }
+  return object === void 0 ? value : object;
+}
+__name(getProperty, "getProperty");
+function setProperty(object, path, value) {
+  if (!isObject(object) || typeof path !== "string") {
+    return object;
+  }
+  const root = object;
+  const pathArray = getPathSegments(path);
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    assertNotStringIndex(object, key);
+    if (index === pathArray.length - 1) {
+      object[key] = value;
+    } else if (!isObject(object[key])) {
+      object[key] = typeof pathArray[index + 1] === "number" ? [] : {};
+    }
+    object = object[key];
+  }
+  return root;
+}
+__name(setProperty, "setProperty");
+function deleteProperty(object, path) {
+  if (!isObject(object) || typeof path !== "string") {
+    return false;
+  }
+  const pathArray = getPathSegments(path);
+  for (let index = 0; index < pathArray.length; index++) {
+    const key = pathArray[index];
+    assertNotStringIndex(object, key);
+    if (index === pathArray.length - 1) {
+      delete object[key];
+      return true;
+    }
+    object = object[key];
+    if (!isObject(object)) {
+      return false;
+    }
+  }
+}
+__name(deleteProperty, "deleteProperty");
+function hasProperty(object, path) {
+  if (!isObject(object) || typeof path !== "string") {
+    return false;
+  }
+  const pathArray = getPathSegments(path);
+  if (pathArray.length === 0) {
+    return false;
+  }
+  for (const key of pathArray) {
+    if (!isObject(object) || !(key in object) || isStringIndex(object, key)) {
+      return false;
+    }
+    object = object[key];
+  }
+  return true;
+}
+__name(hasProperty, "hasProperty");
+function escapePath(path) {
+  if (typeof path !== "string") {
+    throw new TypeError("Expected a string");
+  }
+  return path.replaceAll(/[\\.[]/g, "\\$&");
+}
+__name(escapePath, "escapePath");
+function entries(value) {
+  const result = Object.entries(value);
+  if (Array.isArray(value)) {
+    return result.map(([key, value2]) => [Number(key), value2]);
+  }
+  return result;
+}
+__name(entries, "entries");
+function stringifyPath(pathSegments) {
+  let result = "";
+  for (let [index, segment] of entries(pathSegments)) {
+    if (typeof segment === "number") {
+      result += `[${segment}]`;
+    } else {
+      segment = escapePath(segment);
+      result += index === 0 ? segment : `.${segment}`;
+    }
+  }
+  return result;
+}
+__name(stringifyPath, "stringifyPath");
+function* deepKeysIterator(object, currentPath = []) {
+  if (!isObject(object) || isEmptyObject(object)) {
+    if (currentPath.length > 0) {
+      yield stringifyPath(currentPath);
+    }
+    return;
+  }
+  for (const [key, value] of entries(object)) {
+    yield* deepKeysIterator(value, [...currentPath, key]);
+  }
+}
+__name(deepKeysIterator, "deepKeysIterator");
+function deepKeys(object) {
+  return [...deepKeysIterator(object)];
+}
+__name(deepKeys, "deepKeys");
+
+export { deepKeys, deleteProperty, escapePath, getProperty, hasProperty, setProperty };

package/dist/index.d.ts

@@ -0,0 +1,340 @@
+import { PackageManager, RawConfig, PackageJSON, Config, FatalError, TelemetryMessage, UserError } from '@cloudflare/workers-utils';
+
+/**
+ * Logger interface for autoconfig output.
+ * Callers provide their own implementation (e.g., wrapping `console` or a custom logger).
+ */
+interface AutoConfigLogger {
+    /** Logs informational output. */
+    log(...args: unknown[]): void;
+    /** Logs an informational message. */
+    info(...args: unknown[]): void;
+    /** Logs a warning message. */
+    warn(...args: unknown[]): void;
+    /** Logs a debug-level message (may be suppressed in production). */
+    debug(...args: unknown[]): void;
+    /** Logs an error message. */
+    error(...args: unknown[]): void;
+}
+/**
+ * Dialog interface for interactive prompts.
+ * Callers provide their own implementation (e.g., using `prompts`, `inquirer`, or a custom UI).
+ */
+interface AutoConfigDialogs {
+    /**
+     * Asks a yes/no confirmation question.
+     *
+     * @param text - The question to display
+     * @param options - Optional defaults and fallback behavior
+     * @returns `true` if confirmed, `false` otherwise
+     */
+    confirm(text: string, options?: {
+        defaultValue?: boolean;
+        fallbackValue?: boolean;
+    }): Promise<boolean>;
+    /**
+     * Prompts the user for a text input.
+     *
+     * @param text - The prompt message
+     * @param options - Optional default value and validation function
+     * @returns The user-provided string
+     */
+    prompt(text: string, options?: {
+        defaultValue?: string;
+        validate?: (value: string) => boolean | string | Promise<boolean | string>;
+    }): Promise<string>;
+    /**
+     * Presents a selection list to the user.
+     *
+     * @param text - The prompt message
+     * @param options - Available choices and optional default selection
+     * @returns The selected value
+     */
+    select(text: string, options: {
+        choices: Array<{
+            title: string;
+            value: string;
+            description?: string;
+        }>;
+        defaultOption?: number;
+    }): Promise<string>;
+}
+/**
+ * Context object that provides external dependencies to the autoconfig system.
+ *
+ * Callers must provide implementations for `logger` and `dialogs`.
+ * All other fields are optional and allow callers to customize behavior
+ * (e.g., error reporting, command execution, CI detection).
+ */
+interface AutoConfigContext {
+    /** Logger used for all autoconfig output. */
+    logger: AutoConfigLogger;
+    /** Dialogs used for interactive prompts. */
+    dialogs: AutoConfigDialogs;
+    /**
+     * Runs a shell command in the given directory.
+     *
+     * @param command - The shell command string to execute
+     * @param cwd - The working directory for the command
+     * @param label - A short label for logging (e.g., "[build]")
+     * @returns A promise that resolves when the command completes
+     */
+    runCommand: (command: string, cwd: string, label: string) => Promise<void>;
+    /**
+     * Returns `true` if running in a non-interactive or CI environment.
+     * Defaults to `() => false` if not provided.
+     *
+     * @returns Whether the current environment is non-interactive
+     */
+    isNonInteractiveOrCI?: () => boolean;
+    /**
+     * Returns a cache folder path used for detecting cached project state,
+     * or `undefined` if not available.
+     *
+     * @returns The cache folder path, or `undefined`
+     */
+    getCacheFolder?: () => string | undefined;
+}
+
+/**
+ * Checks whether a framework is supported by autoconfig.
+ *
+ * @param frameworkId The target framework's id
+ * @returns a boolean indicating wether the framework is supported
+ */
+declare function isFrameworkSupported(frameworkId: FrameworkInfo["id"]): boolean;
+type FrameworkInfo = {
+    id: string;
+    name: string;
+} & ({
+    supported: false;
+} | {
+    supported: true;
+    class: typeof Framework;
+    frameworkPackageInfo: AutoConfigFrameworkPackageInfo;
+});
+/**
+ * AutoConfig information for a package that defines a framework.
+ */
+type AutoConfigFrameworkPackageInfo = {
+    /** The package name (e.g. "astro" for the Astro framework and "@solidjs/start" for the SolidStart framework) */
+    name: string;
+    /** The minimum version (if any) of the package/framework that autoconfig supports */
+    minimumVersion: string;
+    /** The latest major version of the package/framework that autoconfig supports  */
+    maximumKnownMajorVersion: string;
+};
+
+declare abstract class Framework {
+    #private;
+    readonly id: FrameworkInfo["id"];
+    readonly name: FrameworkInfo["name"];
+    get frameworkVersion(): string;
+    constructor(frameworkInfo: Pick<FrameworkInfo, "id" | "name">);
+    isConfigured(_projectPath: string): boolean;
+    abstract configure(options: ConfigurationOptions): Promise<ConfigurationResults> | ConfigurationResults;
+    configurationDescription?: string;
+    /**
+     * Validates the installed framework version against the supported range and
+     * stores it for later access via the `frameworkVersion` getter.
+     * Warns via the context logger if the version exceeds `maximumKnownMajorVersion`.
+     *
+     * @param projectPath - Path to the project root used to resolve the installed version.
+     * @param frameworkPackageInfo - Package metadata including name and version bounds.
+     * @param context - The autoconfig context providing logger and other dependencies.
+     * @throws {AssertionError} If the installed version cannot be determined.
+     * @throws {AutoConfigFrameworkConfigurationError} If the version is below `minimumVersion`.
+     */
+    validateFrameworkVersion(projectPath: string, frameworkPackageInfo: AutoConfigFrameworkPackageInfo, context: AutoConfigContext): void;
+}
+type ConfigurationOptions = {
+    outputDir: string;
+    projectPath: string;
+    workerName: string;
+    dryRun: boolean;
+    packageManager: PackageManager;
+    isWorkspaceRoot: boolean;
+    context: AutoConfigContext;
+};
+type PackageJsonScriptsOverrides = {
+    preview?: string;
+    deploy?: string;
+    typegen?: string;
+};
+type ConfigurationResults = {
+    /** The wrangler configuration that the framework's `configure()` hook should generate. `null` if autoconfig should not create the wrangler file (in case an external tool already does that) */
+    wranglerConfig: RawConfig | null;
+    packageJsonScriptsOverrides?: PackageJsonScriptsOverrides;
+    buildCommandOverride?: string;
+    deployCommandOverride?: string;
+    versionCommandOverride?: string;
+};
+
+/** Makes the specified keys of T optional. */
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+type AutoConfigDetailsBase = {
+    /** The name of the worker */
+    workerName: string;
+    /** The path to the project (defaults to cwd) */
+    projectPath: string;
+    /** The content of the project's package.json file (if any) */
+    packageJson?: PackageJSON;
+    /** Whether the project is already configured (no autoconfig required) */
+    configured: boolean;
+    /** Details about the detected framework. It can be a JS framework or 'Static' if no actual JS framework is used. */
+    framework: Framework;
+    /** The build command used to build the project (if any) */
+    buildCommand?: string;
+    /** The output directory (if no framework is used, points to the raw asset files) */
+    outputDir: string;
+    /** The detected package manager for the project */
+    packageManager: PackageManager;
+    /** Whether the current path is at the root of a workspace */
+    isWorkspaceRoot?: boolean;
+};
+type AutoConfigDetailsForConfiguredProject = Optional<AutoConfigDetailsBase, "framework" | "outputDir"> & {
+    configured: true;
+};
+type AutoConfigDetailsForNonConfiguredProject = AutoConfigDetailsBase & {
+    configured: false;
+};
+type AutoConfigDetails = AutoConfigDetailsForConfiguredProject | AutoConfigDetailsForNonConfiguredProject;
+type AutoConfigOptions = {
+    /** The autoconfig context providing logger, dialogs, and other dependencies. */
+    context: AutoConfigContext;
+    /** Whether to run autoconfig without actually applying any filesystem modification (default: false) */
+    dryRun?: boolean;
+    /**
+     * Whether the build command should be run (default: true)
+     *
+     * Note: When `dryRun` is `true` the build command is never run.
+     */
+    runBuild?: boolean;
+    /**
+     * Whether the confirmation prompts should be skipped (default: false)
+     *
+     * Note: When `dryRun` is `true` the the confirmation prompts are always skipped.
+     */
+    skipConfirmations?: boolean;
+    /**
+     * Whether to install Wrangler during autoconfig
+     */
+    enableWranglerInstallation?: boolean;
+};
+type AutoConfigSummary = {
+    scripts: Record<string, string>;
+    wranglerInstall: boolean;
+    wranglerConfig?: RawConfig;
+    frameworkConfiguration?: string;
+    outputDir: string;
+    frameworkId?: string;
+    buildCommand?: string;
+    deployCommand?: string;
+    versionCommand?: string;
+};
+
+/**
+ * Detects project details needed for autoconfig: framework, package manager,
+ * output directory, worker name, and whether the project is already configured.
+ *
+ * @param options - Detection options including project path, wrangler config, and context.
+ * @returns The detected project details.
+ */
+declare function getDetailsForAutoConfig({ projectPath, wranglerConfig, context, }: {
+    /** The path to the project, defaults to cwd. */
+    projectPath?: string;
+    /** The parsed wrangler configuration for the project (if any). */
+    wranglerConfig?: Config;
+    /** The autoconfig context providing logger, dialogs, and other dependencies. */
+    context: AutoConfigContext;
+}): Promise<AutoConfigDetails>;
+/**
+ * Displays the detected autoconfig details to the user via the context logger.
+ *
+ * @param autoConfigDetails - The detected project details to display.
+ * @param context - The autoconfig context providing the logger.
+ * @param displayOptions - Optional display customization.
+ */
+declare function displayAutoConfigDetails(autoConfigDetails: AutoConfigDetails, context: AutoConfigContext, displayOptions?: {
+    heading?: string;
+}): void;
+/**
+ * Prompts the user to confirm or modify the detected autoconfig details.
+ *
+ * @param autoConfigDetails - The detected project details.
+ * @param context - The autoconfig context providing dialogs.
+ * @returns The (possibly updated) autoconfig details.
+ */
+declare function confirmAutoConfigDetails(autoConfigDetails: AutoConfigDetails, context: AutoConfigContext): Promise<AutoConfigDetails>;
+
+/**
+ * Runs the full autoconfig flow: displays detected settings, confirms with the user,
+ * validates the framework version, runs framework configuration, writes wrangler config,
+ * updates package.json scripts, and optionally runs the build command.
+ *
+ * @param autoConfigDetails - The detected project details from `getDetailsForAutoConfig()`.
+ * @param autoConfigOptions - Options controlling dry-run, confirmations, build, and context.
+ * @returns A summary of all operations performed.
+ */
+declare function runAutoConfig(autoConfigDetails: AutoConfigDetails, autoConfigOptions: AutoConfigOptions): Promise<AutoConfigSummary>;
+/**
+ * Builds a summary of all operations that autoconfig will (or did) perform,
+ * including package installation, package.json script updates, wrangler config
+ * creation, and framework-specific configuration.
+ *
+ * @param autoConfigDetails - The detected project details.
+ * @param wranglerConfigToWrite - The wrangler config object to write, or `null` if not applicable.
+ * @param projectCommands - The build, deploy, and version commands for the project.
+ * @param context - The autoconfig context providing logger and other dependencies.
+ * @param packageJsonScriptsOverrides - Optional overrides for package.json script entries.
+ * @returns A summary object describing all planned operations.
+ */
+declare function buildOperationsSummary(autoConfigDetails: AutoConfigDetailsForNonConfiguredProject & {
+    outputDir: NonNullable<AutoConfigDetails["outputDir"]>;
+}, wranglerConfigToWrite: RawConfig | null, projectCommands: {
+    build?: string;
+    deploy: string;
+    version?: string;
+}, context: AutoConfigContext, packageJsonScriptsOverrides?: PackageJsonScriptsOverrides): Promise<AutoConfigSummary>;
+
+/**
+ * Base class for errors where something in a autoconfig frameworks' configuration goes
+ * something wrong. These are not reported to Sentry.
+ */
+declare class AutoConfigFrameworkConfigurationError extends UserError {
+}
+/**
+ * Error thrown when autoconfig detection fails.
+ * Carries detection metadata (`frameworkId`, `configured`) so that callers can
+ * extract it for telemetry without the autoconfig library needing to know about
+ * the telemetry system.
+ */
+declare class AutoConfigDetectionError extends FatalError {
+    /** The detected framework identifier (if detection got far enough to determine it). */
+    readonly frameworkId: string | undefined;
+    /** Whether the project was already configured at the time of the error. */
+    readonly configured: boolean;
+    /**
+     * @param message - The human-readable error message.
+     * @param options - Error options including telemetry message, optional code, and detection metadata.
+     */
+    constructor(message: string, options: TelemetryMessage & {
+        code?: number;
+        frameworkId?: string;
+        configured: boolean;
+    });
+}
+
+/**
+ * Gets the exact version of a package installed by a project (or undefined if the package is not installed)
+
+ * @param packageName the name of the target package
+ * @param projectPath the path of the project to check
+ * @param opts.stopAtProjectPath flag indicating whether the function should stop looking for the package at the project's path
+ * @returns the version of the package if the package is installed, undefined otherwise
+ */
+declare function getInstalledPackageVersion(packageName: string, projectPath: string, opts?: {
+    stopAtProjectPath?: boolean;
+}): string | undefined;
+
+export { type AutoConfigContext, type AutoConfigDetails, type AutoConfigDetailsForConfiguredProject, type AutoConfigDetailsForNonConfiguredProject, AutoConfigDetectionError, type AutoConfigDialogs, AutoConfigFrameworkConfigurationError, type AutoConfigFrameworkPackageInfo, type AutoConfigLogger, type AutoConfigOptions, type AutoConfigSummary, type ConfigurationOptions, type ConfigurationResults, Framework, type FrameworkInfo, type PackageJsonScriptsOverrides, buildOperationsSummary, confirmAutoConfigDetails, displayAutoConfigDetails, getDetailsForAutoConfig, getInstalledPackageVersion, isFrameworkSupported, runAutoConfig };