@coursebuilder/core/dist/lib/utils/env.cjs

Core package for Course Builder

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};

// src/lib/utils/env.ts
var env_exports = {};
__export(env_exports, {
  createActionURL: () => createActionURL,
  setEnvDefaults: () => setEnvDefaults
});
module.exports = __toCommonJS(env_exports);

// src/errors.ts
var _CourseBuilderError = class _CourseBuilderError extends Error {
  constructor(message, errorOptions) {
    var __super = (...args) => {
      super(...args);
      /** The error type. Used to identify the error in the logs. */
      __publicField(this, "type");
      /**
      * Determines on which page an error should be handled. Typically `signIn` errors can be handled in-page.
      * Default is `"error"`.
      * @internal
      */
      __publicField(this, "kind");
      __publicField(this, "cause");
      return this;
    };
    if (message instanceof Error) {
      __super(void 0, {
        cause: {
          err: message,
          ...message.cause,
          ...errorOptions
        }
      });
    } else if (typeof message === "string") {
      if (errorOptions instanceof Error) {
        errorOptions = {
          err: errorOptions,
          ...errorOptions.cause
        };
      }
      __super(message, errorOptions);
    } else {
      __super(void 0, message);
    }
    this.name = this.constructor.name;
    this.type = this.constructor.type ?? "CourseBuilderError";
    this.kind = this.constructor.kind ?? "error";
    Error.captureStackTrace?.(this, this.constructor);
    const url = `https://errors.authjs.dev#${this.type.toLowerCase()}`;
    this.message += `${this.message ? ". " : ""}Read more at ${url}`;
  }
};
__name(_CourseBuilderError, "CourseBuilderError");
var CourseBuilderError = _CourseBuilderError;

// src/lib/utils/logger.ts
var red = "\x1B[31m";
var yellow = "\x1B[33m";
var grey = "\x1B[38;5;246m";
var reset = "\x1B[0m";
var logger = {
  error(error) {
    const name = error instanceof CourseBuilderError ? error.type : error.name;
    console.error(`${red}[coursebuilder][error]${reset} ${name}: ${error.message}`);
    if (error.cause && typeof error.cause === "object" && "err" in error.cause && error.cause.err instanceof Error) {
      const { err, ...data } = error.cause;
      console.error(`${red}[coursebuilder][cause]${reset}:`, err.stack);
      if (data)
        console.error(`${red}[coursebuilder][details]${reset}:`, JSON.stringify(data, null, 2));
    } else if (error.stack) {
      console.error(error.stack.replace(/.*/, "").substring(1));
    }
  },
  warn(code) {
    const url = `https://warnings.coursebuilder.dev#${code}`;
    console.warn(`${yellow}[coursebuilder][warn][${code}]${reset}`, `Read more: ${url}`);
  },
  debug(message, metadata) {
    console.log(`${grey}[coursebuilder][debug]:${reset} ${message}`, JSON.stringify(metadata, null, 2));
  }
};

// src/lib/utils/env.ts
function setEnvDefaults(envObject, config) {
  try {
    const url = envObject.COURSEBUILDER_URL;
    if (url && !config.basePath)
      config.basePath = new URL(url).pathname;
  } catch {
  } finally {
    config.basePath ?? (config.basePath = `/coursebuilder`);
  }
  config.providers = config.providers.map((p) => {
    const finalProvider = typeof p === "function" ? p({}) : p;
    const ID = finalProvider.id.toUpperCase();
    if (finalProvider.type === "transcription") {
      finalProvider.apiKey ?? (finalProvider.apiKey = envObject[`COURSEBUILDER_${ID}_API_KEY`]);
    }
    return finalProvider;
  });
}
__name(setEnvDefaults, "setEnvDefaults");
function createActionURL(action, protocol, headers, envObject, basePath) {
  let envUrl = envObject.COURSEBUILDER_URL;
  let url;
  if (envUrl) {
    url = new URL(envUrl);
    if (basePath && basePath !== "/" && url.pathname !== "/") {
      logger.debug(url.pathname === basePath ? "env-url-basepath-redundant" : "env-url-basepath-mismatch");
      url.pathname = "/";
    }
  } else {
    const detectedHost = headers.get("x-forwarded-host") ?? headers.get("host");
    const detectedProtocol = headers.get("x-forwarded-proto") ?? protocol ?? "https";
    url = new URL(`${detectedProtocol}://${detectedHost}`);
  }
  const sanitizedUrl = url.toString().replace(/\/$/, "");
  if (basePath) {
    const sanitizedBasePath = basePath?.replace(/(^\/|\/$)/g, "") ?? "";
    return new URL(`${sanitizedUrl}/${sanitizedBasePath}/${action}`);
  }
  return new URL(`${sanitizedUrl}/${action}`);
}
__name(createActionURL, "createActionURL");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  createActionURL,
  setEnvDefaults
});
//# sourceMappingURL=env.cjs.map