payload-auth-plugin/dist/esm/client/index.js

Authentication plugin for Payload CMS

// src/core/errors/consoleErrors.ts
var PluginError = class extends Error {
  constructor(message, cause) {
    super(message);
    this.name = "PAYLOAD_AUTH_PLUGIN_ERROR";
    this.message = message;
    this.cause = cause;
    this.stack = "";
  }
};
var MissingPayloadAuthBaseURL = class extends PluginError {
  constructor() {
    super("Missing or invalid Payload Auth base URL");
  }
};
var WrongClientUsage = class extends PluginError {
  constructor() {
    super("Using client only code in server side");
  }
};

// src/client/password.ts
var passwordSignin = async (opts, payload) => {
  const response = await fetch(`${opts.baseURL}/api/${opts.name}/auth/signin`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
  if (response.redirected) {
    window.location.href = response.url;
    return {
      data: {},
      message: "Redirecting user...",
      kind: "Retrieved" /* Retrieved */,
      isError: false,
      isSuccess: true
    };
  }
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};
var passwordSignup = async (opts, payload) => {
  const response = await fetch(`${opts.baseURL}/api/${opts.name}/auth/signup`, {
    method: "POST",
    body: JSON.stringify(payload)
  });
  if (response.redirected) {
    window.location.href = response.url;
    return {
      data: {},
      message: "Redirecting user...",
      kind: "Retrieved" /* Retrieved */,
      isError: false,
      isSuccess: true
    };
  }
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};
var forgotPassword = async (opts, payload) => {
  const response = await fetch(
    `${opts.baseURL}/api/${opts.name}/auth/forgot-password?stage=init`,
    {
      method: "POST",
      body: JSON.stringify(payload)
    }
  );
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};
var recoverPassword = async (opts, payload) => {
  const response = await fetch(
    `${opts.baseURL}/api/${opts.name}/auth/forgot-password?stage=verify`,
    {
      method: "POST",
      body: JSON.stringify(payload)
    }
  );
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};
var resetPassword = async (opts, payload) => {
  const response = await fetch(
    `${opts.baseURL}/api/${opts.name}/auth/reset-password`,
    {
      method: "POST",
      body: JSON.stringify(payload)
    }
  );
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};

// src/client/refresh.ts
var refresh = async (options) => {
  if (typeof window === "undefined") {
    throw new WrongClientUsage();
  }
  const response = await fetch(
    `${options.baseURL}/api/${options.name}/session/refresh`
  );
  const { message, kind, data, isError, isSuccess } = await response.json();
  return {
    message,
    kind,
    data,
    isError,
    isSuccess
  };
};

// src/client/register.ts
var register = (options) => {
  return {
    password: async (paylaod) => await passwordSignup(options, paylaod)
  };
};

// src/client/session.ts
var getSession = async (opts) => {
  const response = await fetch(
    `${opts.baseURL}/api/${opts.name}/session/user`,
    {
      method: "GET",
      headers: opts.headers
    }
  );
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};
var getClientSession = async (opts) => {
  if (typeof window === "undefined") {
    throw new WrongClientUsage();
  }
  const response = await fetch(`${opts.baseURL}/api/${opts.name}/session/user`);
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};

// src/client/oauth.ts
import Cookies from "js-cookie";
var oauth = (options, provider) => {
  const additionalScope = options.additionalScope || "";
  Cookies.set("oauth_scope", additionalScope, { expires: 1 / 288, path: "/" });
  const oauthURL = `${options.baseURL}/api/${options.name}/oauth/authorization/${provider}`;
  window.location.href = oauthURL;
};

// src/client/signin.ts
var signin = (options) => {
  return {
    oauth: (provider) => oauth(options, provider),
    // passkey: () => passkeyInit(), NEEDS IMPROVEMENT
    password: async (payload) => await passwordSignin(options, payload)
  };
};

// src/client/signout.ts
import * as qs from "qs-esm";
var signout = async (opts) => {
  if (typeof window === "undefined") {
    throw new WrongClientUsage();
  }
  const query = {};
  if (opts.returnTo) {
    query.returnTo = opts.returnTo;
  }
  const response = await fetch(
    `${opts.baseURL}/api/${opts.name}/session/signout?${qs.stringify(query)}`
  );
  if (response.redirected) {
    window.location.href = response.url;
    return {
      data: {},
      message: "Signing out...",
      kind: "Deleted" /* Deleted */,
      isError: false,
      isSuccess: true
    };
  }
  const { data, message, kind, isError, isSuccess } = await response.json();
  return {
    data,
    message,
    kind,
    isError,
    isSuccess
  };
};

// src/client/index.ts
var AuthClient = class {
  constructor(name, options) {
    this.name = name;
    if (!options?.payloadBaseURL && !process.env.NEXT_PUBLIC_PAYLOAD_AUTH_URL) {
      throw new MissingPayloadAuthBaseURL();
    }
    this.baseURL = options?.payloadBaseURL ?? process.env.NEXT_PUBLIC_PAYLOAD_AUTH_URL;
  }
  name;
  baseURL;
  /**
   * Sign in a user
   * @param additionalScope - Additional scope to request
   * @returns The sign in response
   */
  signin(additionalScope) {
    return signin({
      name: this.name,
      baseURL: this.baseURL,
      additionalScope
    });
  }
  register() {
    return register({
      name: this.name,
      baseURL: this.baseURL
    });
  }
  async resetPassword(payload) {
    return await resetPassword(
      {
        name: this.name,
        baseURL: this.baseURL
      },
      payload
    );
  }
  async forgotPassword(payload) {
    return await forgotPassword(
      {
        name: this.name,
        baseURL: this.baseURL
      },
      payload
    );
  }
  async recoverPassword(payload) {
    return await recoverPassword(
      {
        name: this.name,
        baseURL: this.baseURL
      },
      payload
    );
  }
  async getSession({ headers }) {
    return await getSession({
      name: this.name,
      baseURL: this.baseURL,
      headers
    });
  }
  async getClientSession() {
    return await getClientSession({
      name: this.name,
      baseURL: this.baseURL
    });
  }
  async signout({ returnTo }) {
    return await signout({
      name: this.name,
      baseURL: this.baseURL,
      returnTo
    });
  }
  async refreshSession() {
    return await refresh({
      name: this.name,
      baseURL: this.baseURL
    });
  }
};
export {
  AuthClient
};
//# sourceMappingURL=index.js.map