@coursebuilder/core/dist/lib/init.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/init.ts
var init_exports = {};
__export(init_exports, {
  defaultCallbacks: () => defaultCallbacks,
  init: () => init
});
module.exports = __toCommonJS(init_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;
var _AdapterError = class _AdapterError extends CourseBuilderError {
};
__name(_AdapterError, "AdapterError");
__publicField(_AdapterError, "type", "AdapterError");
var AdapterError = _AdapterError;

// src/lib/utils/cookie.ts
function defaultCookies(useSecureCookies) {
  const cookiePrefix = useSecureCookies ? "__Secure-" : "";
  return {};
}
__name(defaultCookies, "defaultCookies");

// 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/merge.ts
function isObject(item) {
  return item && typeof item === "object" && !Array.isArray(item);
}
__name(isObject, "isObject");
function merge(target, ...sources) {
  if (!sources.length)
    return target;
  const source = sources.shift();
  if (isObject(target) && isObject(source)) {
    for (const key in source) {
      if (isObject(source[key])) {
        if (!target[key])
          Object.assign(target, {
            [key]: {}
          });
        merge(target[key], source[key]);
      } else {
        Object.assign(target, {
          [key]: source[key]
        });
      }
    }
  }
  return merge(target, ...sources);
}
__name(merge, "merge");

// src/lib/utils/providers.ts
function parseProviders(params) {
  const { providerId, options } = params;
  const providers = params.providers.map((p) => {
    const provider = typeof p === "function" ? p() : p;
    const { options: userOptions, ...defaults } = provider;
    if (!userOptions) {
      throw new Error(`Provider ${provider.id} is missing options`);
    }
    const { paymentsAdapter, ...userOptionsWithPaymentsAdapter } = userOptions;
    return {
      ...merge(defaults, userOptionsWithPaymentsAdapter),
      ...paymentsAdapter ? {
        options: paymentsAdapter
      } : {}
    };
  });
  return {
    providers,
    provider: providers.find(({ id }) => id === providerId)
  };
}
__name(parseProviders, "parseProviders");

// src/lib/init.ts
async function init({ url, courseBuilderOptions, providerId, action, isPost, cookies: reqCookies }) {
  const { providers, provider } = parseProviders({
    providers: courseBuilderOptions.providers,
    url,
    providerId,
    options: courseBuilderOptions
  });
  const maxAge = 30 * 24 * 60 * 60;
  const options = {
    debug: false,
    pages: {},
    ...courseBuilderOptions,
    url,
    action,
    // @ts-expect-errors
    provider,
    cookies: merge({}, defaultCookies(courseBuilderOptions.useSecureCookies ?? url.protocol === "https:"), courseBuilderOptions.cookies || {}, reqCookies),
    providers,
    adapter: adapterErrorHandler(courseBuilderOptions.adapter, logger),
    callbacks: {
      ...defaultCallbacks,
      ...courseBuilderOptions.callbacks
    },
    logger,
    getCurrentUser: courseBuilderOptions.getCurrentUser
  };
  const cookies = [];
  return {
    options,
    cookies
  };
}
__name(init, "init");
var defaultCallbacks = {
  session(payload) {
    return payload;
  }
};
function adapterErrorHandler(adapter, logger2) {
  if (!adapter)
    return;
  return Object.keys(adapter).reduce((acc, name) => {
    acc[name] = async (...args) => {
      try {
        logger2.debug(`adapter_${name}`, {
          args
        });
        const method = adapter[name];
        return await method(...args);
      } catch (e) {
        const error = new AdapterError(e);
        logger2.error(error);
        throw error;
      }
    };
    return acc;
  }, {});
}
__name(adapterErrorHandler, "adapterErrorHandler");
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  defaultCallbacks,
  init
});
//# sourceMappingURL=init.cjs.map