@aura-stack/auth 0.1.0-rc.8 → 0.1.0

package/dist/actions/signOut/signOut.d.ts

@@ -1,8 +1,8 @@
-import * as _aura_stack_router from "@aura-stack/router"
+import * as _aura_stack_router from '@aura-stack/router';
 
 /**
  * @see https://datatracker.ietf.org/doc/html/rfc7009
  */
-declare const signOutAction: _aura_stack_router.RouteEndpoint<"POST", "/signOut", {}>
+declare const signOutAction: _aura_stack_router.RouteEndpoint<"POST", "/signOut", {}>;
 
-export { signOutAction }
+export { signOutAction };

package/dist/actions/signOut/signOut.js

@@ -1,11 +1,15 @@
-import { signOutAction } from "../../chunk-SJPDVKUS.js"
-import "../../chunk-CAKJT3KS.js"
-import "../../chunk-ZV4BH47P.js"
-import "../../chunk-6SM22VVJ.js"
-import "../../chunk-STHEPPUZ.js"
-import "../../chunk-GZU3RBTB.js"
-import "../../chunk-256KIVJL.js"
-import "../../chunk-FJUDBLCP.js"
-import "../../chunk-JAPMIE6S.js"
-import "../../chunk-HMRKN75I.js"
-export { signOutAction }
+import {
+  signOutAction
+} from "../../chunk-SJPDVKUS.js";
+import "../../chunk-CAKJT3KS.js";
+import "../../chunk-ZV4BH47P.js";
+import "../../chunk-6SM22VVJ.js";
+import "../../chunk-STHEPPUZ.js";
+import "../../chunk-GZU3RBTB.js";
+import "../../chunk-256KIVJL.js";
+import "../../chunk-FJUDBLCP.js";
+import "../../chunk-JAPMIE6S.js";
+import "../../chunk-HMRKN75I.js";
+export {
+  signOutAction
+};

package/dist/assert.cjs

@@ -1,45 +1,44 @@
-"use strict"
-var __defProp = Object.defineProperty
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor
-var __getOwnPropNames = Object.getOwnPropertyNames
-var __hasOwnProp = Object.prototype.hasOwnProperty
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-    for (var name in all) __defProp(target, name, { get: all[name], enumerable: true })
-}
+  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)
+  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);
 
 // src/assert.ts
-var assert_exports = {}
+var assert_exports = {};
 __export(assert_exports, {
-    isFalsy: () => isFalsy,
-    isRequest: () => isRequest,
-    isValidURL: () => isValidURL,
-})
-module.exports = __toCommonJS(assert_exports)
+  isFalsy: () => isFalsy,
+  isRequest: () => isRequest,
+  isValidURL: () => isValidURL
+});
+module.exports = __toCommonJS(assert_exports);
 var isFalsy = (value) => {
-    return value === false || value === 0 || value === "" || value === null || value === void 0 || Number.isNaN(value)
-}
+  return value === false || value === 0 || value === "" || value === null || value === void 0 || Number.isNaN(value);
+};
 var isRequest = (value) => {
-    return typeof Request !== "undefined" && value instanceof Request
-}
+  return typeof Request !== "undefined" && value instanceof Request;
+};
 var isValidURL = (value) => {
-    if (value.includes("\r\n") || value.includes("\n") || value.includes("\r")) return false
-    const regex =
-        /^https?:\/\/(?:[a-zA-Z0-9._-]+|localhost|\[[0-9a-fA-F:]+\])(?::\d{1,5})?(?:\/[a-zA-Z0-9._~!$&'()*+,;=:@-]*)*\/?$/
-    return regex.test(value)
-}
+  if (value.includes("\r\n") || value.includes("\n") || value.includes("\r")) return false;
+  const regex = /^https?:\/\/(?:[a-zA-Z0-9._-]+|localhost|\[[0-9a-fA-F:]+\])(?::\d{1,5})?(?:\/[a-zA-Z0-9._~!$&'()*+,;=:@-]*)*\/?$/;
+  return regex.test(value);
+};
 // Annotate the CommonJS export names for ESM import in node:
-0 &&
-    (module.exports = {
-        isFalsy,
-        isRequest,
-        isValidURL,
-    })
+0 && (module.exports = {
+  isFalsy,
+  isRequest,
+  isValidURL
+});

package/dist/assert.d.ts

@@ -1,5 +1,5 @@
-declare const isFalsy: (value: unknown) => boolean
-declare const isRequest: (value: unknown) => value is Request
-declare const isValidURL: (value: string) => boolean
+declare const isFalsy: (value: unknown) => boolean;
+declare const isRequest: (value: unknown) => value is Request;
+declare const isValidURL: (value: string) => boolean;
 
-export { isFalsy, isRequest, isValidURL }
+export { isFalsy, isRequest, isValidURL };

package/dist/assert.js

@@ -1,2 +1,10 @@
-import { isFalsy, isRequest, isValidURL } from "./chunk-6SM22VVJ.js"
-export { isFalsy, isRequest, isValidURL }
+import {
+  isFalsy,
+  isRequest,
+  isValidURL
+} from "./chunk-6SM22VVJ.js";
+export {
+  isFalsy,
+  isRequest,
+  isValidURL
+};

package/dist/chunk-256KIVJL.js

@@ -1,110 +1,99 @@
-import { isAuthError } from "./chunk-FJUDBLCP.js"
+import {
+  isAuthError
+} from "./chunk-FJUDBLCP.js";
 
 // src/utils.ts
-import { isRouterError } from "@aura-stack/router"
+import { isRouterError } from "@aura-stack/router";
 var toSnakeCase = (str) => {
-    return str
-        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2")
-        .toLowerCase()
-        .replace(/^_+/, "")
-}
+  return str.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase().replace(/^_+/, "");
+};
 var toUpperCase = (str) => {
-    return str.toUpperCase()
-}
+  return str.toUpperCase();
+};
 var toCastCase = (obj, type = "snake") => {
-    return Object.entries(obj).reduce((previous, [key, value]) => {
-        const newKey = type === "snake" ? toSnakeCase(key) : toUpperCase(key)
-        return { ...previous, [newKey]: value }
-    }, {})
-}
+  return Object.entries(obj).reduce((previous, [key, value]) => {
+    const newKey = type === "snake" ? toSnakeCase(key) : toUpperCase(key);
+    return { ...previous, [newKey]: value };
+  }, {});
+};
 var equals = (a, b) => {
-    if (a === null || b === null || a === void 0 || b === void 0) return false
-    return a === b
-}
+  if (a === null || b === null || a === void 0 || b === void 0) return false;
+  return a === b;
+};
 var sanitizeURL = (url) => {
-    try {
-        let decodedURL = decodeURIComponent(url).trim()
-        const protocolMatch = decodedURL.match(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)/)
-        let protocol = ""
-        let rest = decodedURL
-        if (protocolMatch) {
-            protocol = protocolMatch[1]
-            rest = decodedURL.slice(protocol.length)
-            const slashIndex = rest.indexOf("/")
-            if (slashIndex === -1) {
-                return protocol + rest
-            }
-            const domain = rest.slice(0, slashIndex)
-            let path = rest
-                .slice(slashIndex)
-                .replace(/\/\.\.\//g, "/")
-                .replace(/\/\.\.$/, "")
-                .replace(/\.{2,}/g, "")
-                .replace(/\/{2,}/g, "/")
-            if (path !== "/" && path.endsWith("/")) {
-                path = path.replace(/\/+$/, "/")
-            } else if (path !== "/") {
-                path = path.replace(/\/+$/, "")
-            }
-            return protocol + domain + path
-        }
-        let sanitized = decodedURL
-            .replace(/\/\.\.\//g, "/")
-            .replace(/\/\.\.$/, "")
-            .replace(/\.{2,}/g, "")
-            .replace(/\/{2,}/g, "/")
-        if (sanitized !== "/" && sanitized.endsWith("/")) {
-            sanitized = sanitized.replace(/\/+$/, "/")
-        } else if (sanitized !== "/") {
-            sanitized = sanitized.replace(/\/+$/, "")
-        }
-        return sanitized
-    } catch {
-        return url.trim()
+  try {
+    let decodedURL = decodeURIComponent(url).trim();
+    const protocolMatch = decodedURL.match(/^([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)/);
+    let protocol = "";
+    let rest = decodedURL;
+    if (protocolMatch) {
+      protocol = protocolMatch[1];
+      rest = decodedURL.slice(protocol.length);
+      const slashIndex = rest.indexOf("/");
+      if (slashIndex === -1) {
+        return protocol + rest;
+      }
+      const domain = rest.slice(0, slashIndex);
+      let path = rest.slice(slashIndex).replace(/\/\.\.\//g, "/").replace(/\/\.\.$/, "").replace(/\.{2,}/g, "").replace(/\/{2,}/g, "/");
+      if (path !== "/" && path.endsWith("/")) {
+        path = path.replace(/\/+$/, "/");
+      } else if (path !== "/") {
+        path = path.replace(/\/+$/, "");
+      }
+      return protocol + domain + path;
     }
-}
+    let sanitized = decodedURL.replace(/\/\.\.\//g, "/").replace(/\/\.\.$/, "").replace(/\.{2,}/g, "").replace(/\/{2,}/g, "/");
+    if (sanitized !== "/" && sanitized.endsWith("/")) {
+      sanitized = sanitized.replace(/\/+$/, "/");
+    } else if (sanitized !== "/") {
+      sanitized = sanitized.replace(/\/+$/, "");
+    }
+    return sanitized;
+  } catch {
+    return url.trim();
+  }
+};
 var isValidRelativePath = (path) => {
-    if (!path || typeof path !== "string") return false
-    if (!path.startsWith("/") || path.includes("://") || path.includes("\r") || path.includes("\n")) return false
-    if (/[\x00-\x1F\x7F]/.test(path) || path.includes("\0")) return false
-    const sanitized = sanitizeURL(path)
-    if (sanitized.includes("..")) return false
-    return true
-}
+  if (!path || typeof path !== "string") return false;
+  if (!path.startsWith("/") || path.includes("://") || path.includes("\r") || path.includes("\n")) return false;
+  if (/[\x00-\x1F\x7F]/.test(path) || path.includes("\0")) return false;
+  const sanitized = sanitizeURL(path);
+  if (sanitized.includes("..")) return false;
+  return true;
+};
 var onErrorHandler = (error) => {
-    if (isRouterError(error)) {
-        const { message, status, statusText } = error
-        return Response.json({ error: "invalid_request", error_description: message }, { status, statusText })
-    }
-    if (isAuthError(error)) {
-        const { type, message } = error
-        return Response.json({ error: type, error_description: message }, { status: 400 })
-    }
-    return Response.json({ error: "server_error", error_description: "An unexpected error occurred" }, { status: 500 })
-}
+  if (isRouterError(error)) {
+    const { message, status, statusText } = error;
+    return Response.json({ error: "invalid_request", error_description: message }, { status, statusText });
+  }
+  if (isAuthError(error)) {
+    const { type, message } = error;
+    return Response.json({ error: type, error_description: message }, { status: 400 });
+  }
+  return Response.json({ error: "server_error", error_description: "An unexpected error occurred" }, { status: 500 });
+};
 var getNormalizedOriginPath = (path) => {
-    try {
-        const url = new URL(path)
-        url.hash = ""
-        url.search = ""
-        return `${url.origin}${url.pathname}`
-    } catch {
-        return sanitizeURL(path)
-    }
-}
+  try {
+    const url = new URL(path);
+    url.hash = "";
+    url.search = "";
+    return `${url.origin}${url.pathname}`;
+  } catch {
+    return sanitizeURL(path);
+  }
+};
 var toISOString = (date) => {
-    return new Date(date).toISOString()
-}
+  return new Date(date).toISOString();
+};
 
 export {
-    toSnakeCase,
-    toUpperCase,
-    toCastCase,
-    equals,
-    sanitizeURL,
-    isValidRelativePath,
-    onErrorHandler,
-    getNormalizedOriginPath,
-    toISOString,
-}
+  toSnakeCase,
+  toUpperCase,
+  toCastCase,
+  equals,
+  sanitizeURL,
+  isValidRelativePath,
+  onErrorHandler,
+  getNormalizedOriginPath,
+  toISOString
+};

package/dist/chunk-42XB3YCW.js

@@ -1,20 +1,22 @@
 // src/oauth/x.ts
 var x = {
-    id: "x",
-    name: "X",
-    authorizeURL: "https://x.com/i/oauth2/authorize",
-    accessToken: "https://api.x.com/2/oauth2/token",
-    userInfo: "https://api.x.com/2/users/me?user.fields=profile_image_url",
-    scope: "users.read users.email tweet.read offline.access",
-    responseType: "code",
-    profile({ data }) {
-        return {
-            sub: data.id,
-            name: data.name,
-            image: data.profile_image_url,
-            email: "",
-        }
-    },
-}
+  id: "x",
+  name: "X",
+  authorizeURL: "https://x.com/i/oauth2/authorize",
+  accessToken: "https://api.x.com/2/oauth2/token",
+  userInfo: "https://api.x.com/2/users/me?user.fields=profile_image_url",
+  scope: "users.read users.email tweet.read offline.access",
+  responseType: "code",
+  profile({ data }) {
+    return {
+      sub: data.id,
+      name: data.name,
+      image: data.profile_image_url,
+      email: ""
+    };
+  }
+};
 
-export { x }
+export {
+  x
+};

package/dist/chunk-6SM22VVJ.js

@@ -1,15 +1,18 @@
 // src/assert.ts
 var isFalsy = (value) => {
-    return value === false || value === 0 || value === "" || value === null || value === void 0 || Number.isNaN(value)
-}
+  return value === false || value === 0 || value === "" || value === null || value === void 0 || Number.isNaN(value);
+};
 var isRequest = (value) => {
-    return typeof Request !== "undefined" && value instanceof Request
-}
+  return typeof Request !== "undefined" && value instanceof Request;
+};
 var isValidURL = (value) => {
-    if (value.includes("\r\n") || value.includes("\n") || value.includes("\r")) return false
-    const regex =
-        /^https?:\/\/(?:[a-zA-Z0-9._-]+|localhost|\[[0-9a-fA-F:]+\])(?::\d{1,5})?(?:\/[a-zA-Z0-9._~!$&'()*+,;=:@-]*)*\/?$/
-    return regex.test(value)
-}
+  if (value.includes("\r\n") || value.includes("\n") || value.includes("\r")) return false;
+  const regex = /^https?:\/\/(?:[a-zA-Z0-9._-]+|localhost|\[[0-9a-fA-F:]+\])(?::\d{1,5})?(?:\/[a-zA-Z0-9._~!$&'()*+,;=:@-]*)*\/?$/;
+  return regex.test(value);
+};
 
-export { isFalsy, isRequest, isValidURL }
+export {
+  isFalsy,
+  isRequest,
+  isValidURL
+};

package/dist/chunk-CAKJT3KS.js

@@ -1,77 +1,92 @@
-import { isValidURL } from "./chunk-6SM22VVJ.js"
-import { equals, getNormalizedOriginPath, sanitizeURL, toCastCase } from "./chunk-256KIVJL.js"
-import { AuthError, ERROR_RESPONSE, InvalidRedirectToError, isAuthError } from "./chunk-FJUDBLCP.js"
-import { OAuthAuthorization } from "./chunk-HMRKN75I.js"
+import {
+  isValidURL
+} from "./chunk-6SM22VVJ.js";
+import {
+  equals,
+  getNormalizedOriginPath,
+  sanitizeURL,
+  toCastCase
+} from "./chunk-256KIVJL.js";
+import {
+  AuthError,
+  ERROR_RESPONSE,
+  InvalidRedirectToError,
+  isAuthError
+} from "./chunk-FJUDBLCP.js";
+import {
+  OAuthAuthorization
+} from "./chunk-HMRKN75I.js";
 
 // src/actions/signIn/authorization.ts
 var createAuthorizationURL = (oauthConfig, redirectURI, state, codeChallenge, codeChallengeMethod) => {
-    const parsed = OAuthAuthorization.safeParse({ ...oauthConfig, redirectURI, state, codeChallenge, codeChallengeMethod })
-    if (!parsed.success) {
-        throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.SERVER_ERROR, "Invalid OAuth configuration")
-    }
-    const { authorizeURL, ...options } = parsed.data
-    const { userInfo, accessToken, clientSecret, ...required } = options
-    const searchParams = new URLSearchParams(toCastCase(required))
-    return `${authorizeURL}?${searchParams}`
-}
+  const parsed = OAuthAuthorization.safeParse({ ...oauthConfig, redirectURI, state, codeChallenge, codeChallengeMethod });
+  if (!parsed.success) {
+    throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.SERVER_ERROR, "Invalid OAuth configuration");
+  }
+  const { authorizeURL, ...options } = parsed.data;
+  const { userInfo, accessToken, clientSecret, ...required } = options;
+  const searchParams = new URLSearchParams(toCastCase(required));
+  return `${authorizeURL}?${searchParams}`;
+};
 var getOriginURL = (request, trustedProxyHeaders) => {
-    const headers = request.headers
-    if (trustedProxyHeaders) {
-        const protocol = headers.get("X-Forwarded-Proto") ?? headers.get("Forwarded")?.match(/proto=([^;]+)/i)?.[1] ?? "http"
-        const host =
-            headers.get("X-Forwarded-Host") ??
-            headers.get("Host") ??
-            headers.get("Forwarded")?.match(/host=([^;]+)/i)?.[1] ??
-            null
-        return new URL(`${protocol}://${host}${getNormalizedOriginPath(new URL(request.url).pathname)}`)
-    } else {
-        return new URL(getNormalizedOriginPath(request.url))
-    }
-}
+  const headers = request.headers;
+  if (trustedProxyHeaders) {
+    const protocol = headers.get("X-Forwarded-Proto") ?? headers.get("Forwarded")?.match(/proto=([^;]+)/i)?.[1] ?? "http";
+    const host = headers.get("X-Forwarded-Host") ?? headers.get("Host") ?? headers.get("Forwarded")?.match(/host=([^;]+)/i)?.[1] ?? null;
+    return new URL(`${protocol}://${host}${getNormalizedOriginPath(new URL(request.url).pathname)}`);
+  } else {
+    return new URL(getNormalizedOriginPath(request.url));
+  }
+};
 var createRedirectURI = (request, oauth, basePath, trustedProxyHeaders) => {
-    const url = getOriginURL(request, trustedProxyHeaders)
-    return `${url.origin}${basePath}/callback/${oauth}`
-}
+  const url = getOriginURL(request, trustedProxyHeaders);
+  return `${url.origin}${basePath}/callback/${oauth}`;
+};
 var createRedirectTo = (request, redirectTo, trustedProxyHeaders) => {
-    try {
-        const headers = request.headers
-        const origin = headers.get("Origin")
-        const referer = headers.get("Referer")
-        let hostedURL = getOriginURL(request, trustedProxyHeaders)
-        if (redirectTo) {
-            if (redirectTo.startsWith("/")) {
-                return sanitizeURL(redirectTo)
-            }
-            const redirectToURL = new URL(sanitizeURL(getNormalizedOriginPath(redirectTo)))
-            if (!isValidURL(redirectTo) || !equals(redirectToURL.origin, hostedURL.origin)) {
-                throw new InvalidRedirectToError()
-            }
-            return sanitizeURL(redirectToURL.pathname)
-        }
-        if (referer) {
-            const refererURL = new URL(sanitizeURL(referer))
-            if (!isValidURL(referer) || !equals(refererURL.origin, hostedURL.origin)) {
-                throw new AuthError(
-                    ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST,
-                    "The referer of the request does not match the hosted origin."
-                )
-            }
-            return sanitizeURL(refererURL.pathname)
-        }
-        if (origin) {
-            const originURL = new URL(sanitizeURL(getNormalizedOriginPath(origin)))
-            if (!isValidURL(origin) || !equals(originURL.origin, hostedURL.origin)) {
-                throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST, "Invalid origin (potential CSRF).")
-            }
-            return sanitizeURL(originURL.pathname)
-        }
-        return "/"
-    } catch (error) {
-        if (isAuthError(error)) {
-            throw error
-        }
-        throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST, "Invalid origin (potential CSRF).")
+  try {
+    const headers = request.headers;
+    const origin = headers.get("Origin");
+    const referer = headers.get("Referer");
+    let hostedURL = getOriginURL(request, trustedProxyHeaders);
+    if (redirectTo) {
+      if (redirectTo.startsWith("/")) {
+        return sanitizeURL(redirectTo);
+      }
+      const redirectToURL = new URL(sanitizeURL(getNormalizedOriginPath(redirectTo)));
+      if (!isValidURL(redirectTo) || !equals(redirectToURL.origin, hostedURL.origin)) {
+        throw new InvalidRedirectToError();
+      }
+      return sanitizeURL(redirectToURL.pathname);
+    }
+    if (referer) {
+      const refererURL = new URL(sanitizeURL(referer));
+      if (!isValidURL(referer) || !equals(refererURL.origin, hostedURL.origin)) {
+        throw new AuthError(
+          ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST,
+          "The referer of the request does not match the hosted origin."
+        );
+      }
+      return sanitizeURL(refererURL.pathname);
+    }
+    if (origin) {
+      const originURL = new URL(sanitizeURL(getNormalizedOriginPath(origin)));
+      if (!isValidURL(origin) || !equals(originURL.origin, hostedURL.origin)) {
+        throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST, "Invalid origin (potential CSRF).");
+      }
+      return sanitizeURL(originURL.pathname);
+    }
+    return "/";
+  } catch (error) {
+    if (isAuthError(error)) {
+      throw error;
     }
-}
+    throw new AuthError(ERROR_RESPONSE.AUTHORIZATION.INVALID_REQUEST, "Invalid origin (potential CSRF).");
+  }
+};
 
-export { createAuthorizationURL, getOriginURL, createRedirectURI, createRedirectTo }
+export {
+  createAuthorizationURL,
+  getOriginURL,
+  createRedirectURI,
+  createRedirectTo
+};

package/dist/chunk-E3OXBRYF.js

@@ -1,20 +1,22 @@
 // src/oauth/spotify.ts
 var spotify = {
-    id: "spotify",
-    name: "Spotify",
-    authorizeURL: "https://accounts.spotify.com/authorize",
-    accessToken: "https://accounts.spotify.com/api/token",
-    userInfo: "https://api.spotify.com/v1/me",
-    scope: "user-read-email user-read-private",
-    responseType: "token",
-    profile(profile) {
-        return {
-            sub: profile.id,
-            name: profile.display_name,
-            email: profile.email,
-            image: profile.images?.[0]?.url,
-        }
-    },
-}
+  id: "spotify",
+  name: "Spotify",
+  authorizeURL: "https://accounts.spotify.com/authorize",
+  accessToken: "https://accounts.spotify.com/api/token",
+  userInfo: "https://api.spotify.com/v1/me",
+  scope: "user-read-email user-read-private",
+  responseType: "token",
+  profile(profile) {
+    return {
+      sub: profile.id,
+      name: profile.display_name,
+      email: profile.email,
+      image: profile.images?.[0]?.url
+    };
+  }
+};
 
-export { spotify }
+export {
+  spotify
+};