@sst-community/sst 0.0.0-placeholder.0 → 4.17.2

package/README.md

@@ -0,0 +1,86 @@
+<h1 align="center">sst-community</h1>
+
+<p align="center">A community-maintained fork of <a href="https://github.com/anomalyco/sst">SST</a></p>
+
+---
+
+Build full-stack apps on your own infrastructure.
+
+> [!NOTE]
+> **sst-community** is a community-maintained fork of [SST](https://github.com/anomalyco/sst). It is not affiliated with SST or Anomaly. It tracks upstream releases and carries fixes that haven't landed upstream yet.
+>
+> Releases are numbered after the upstream line they're based on: `4.17.x` is based on upstream 4.17. Each release's notes list what it changes. Telemetry is off. The [SST docs](https://sst.dev/docs/) apply to the fork, except for installing it.
+
+## Installation
+
+For JavaScript projects, install the fork locally under the name `sst`, so the CLI version is tracked with your app and `import ... from "sst"` keeps working. You can then run the CLI with the same package manager.
+
+```bash
+npm install sst@npm:@sst-community/sst
+# pnpm add sst@npm:@sst-community/sst
+# bun add sst@npm:@sst-community/sst
+# yarn add sst@npm:@sst-community/sst
+```
+
+To switch an existing project from SST, change its dependency to `"sst": "npm:@sst-community/sst@<version>"` and reinstall. `sst upgrade` keeps it pointing at the fork.
+
+If you are not using JavaScript, you can install the CLI globally.
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/sst-community/sst/main/install | bash
+```
+
+To install a specific version.
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/sst-community/sst/main/install | VERSION=4.17.2 bash
+```
+
+#### Manually
+
+Download the pre-compiled binaries from the [releases](https://github.com/sst-community/sst/releases/latest) page and copy to the desired location. On Linux, the `.deb` and `.rpm` packages there install with `sudo dpkg -i` and `sudo rpm -i`.
+
+## Get Started
+
+Get started with your favorite framework:
+
+- [Next.js](https://sst.dev/docs/start/aws/nextjs)
+- [Remix](https://sst.dev/docs/start/aws/remix)
+- [Astro](https://sst.dev/docs/start/aws/astro)
+- [API](https://sst.dev/docs/start/aws/api)
+
+## Learn More
+
+Learn more about some of the key concepts:
+
+- [Live](https://sst.dev/docs/live)
+- [Linking](https://sst.dev/docs/linking)
+- [Console](https://sst.dev/docs/console)
+- [Components](https://sst.dev/docs/components)
+
+## Contributing
+
+Here's how you can contribute:
+
+- Help us improve our docs
+- Find a bug? Open an issue
+- Feature request? Submit a PR 
+
+## Running Locally
+
+Run `bun run setup`. You need [Go](https://go.dev/) and [Bun](https://bun.sh/) installed.
+
+Now you can run the CLI locally on any of the `examples/` apps.
+
+```bash
+cd examples/aws-api
+go run ../../cmd/sst <command>
+```
+
+If you want to build the CLI binary, run `bun run build:cli`. This will create a `sst` binary that you can use.
+
+For building the docs, run `bun run docs:generate` and `bun run docs:dev`.
+
+---
+
+**Found a bug or have a question about the fork?** [Open an issue](https://github.com/sst-community/sst/issues). For SST itself, see [anomalyco/sst](https://github.com/anomalyco/sst).

package/bin/sst.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+import { execFileSync } from "child_process";
+
+let resolved = process.env.SST_BIN_PATH;
+
+if (!resolved) {
+  // The binary packages are named after this package (see scripts/release.ts),
+  // which may be scoped, so read the name rather than assume "sst".
+  const { name: pkgName } = require("../package.json");
+  const name = `${pkgName}-${process.platform}-${process.arch}`;
+  const binary = process.platform === "win32" ? "sst.exe" : "sst";
+
+  try {
+    resolved = require.resolve(`${name}/bin/${binary}`);
+  } catch (ex) {
+    console.error(
+      `It seems that your package manager failed to install the right version of the SST CLI for your platform. You can try manually installing the "${name}" package.`,
+    );
+    process.exit(1);
+  }
+}
+
+process.on("SIGINT", () => {});
+
+try {
+  execFileSync(resolved, process.argv.slice(2), {
+    stdio: "inherit",
+  });
+} catch (ex) {
+  process.exit(1);
+}

package/dist/auth/adapter/adapter.d.ts

@@ -0,0 +1,23 @@
+import type { Context, Hono } from "hono";
+import { KeyLike } from "jose";
+export type Adapter<Properties = any> = (route: AdapterRoute, options: AdapterOptions<Properties>) => void;
+export type AdapterRoute = Hono;
+export interface AdapterOptions<Properties> {
+    name: string;
+    algorithm: string;
+    encryption: {
+        publicKey: () => Promise<KeyLike>;
+        privateKey: () => Promise<KeyLike>;
+    };
+    signing: {
+        publicKey: () => Promise<KeyLike>;
+        privateKey: () => Promise<KeyLike>;
+    };
+    success: (ctx: Context, properties: Properties) => Promise<Response>;
+    forward: (ctx: Context, response: Response) => Response;
+    cookie: (ctx: Context, key: string, value: string, maxAge: number) => void;
+}
+export declare class AdapterError extends Error {
+}
+export declare class AdapterUnknownError extends AdapterError {
+}

package/dist/auth/adapter/adapter.js

@@ -0,0 +1,4 @@
+export class AdapterError extends Error {
+}
+export class AdapterUnknownError extends AdapterError {
+}

package/dist/auth/adapter/apple.d.ts

@@ -0,0 +1,5 @@
+import { OauthBasicConfig } from "./oauth.js";
+export declare const AppleAdapter: (config: OauthBasicConfig) => (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: import("openid-client").TokenSet;
+    client: import("openid-client").BaseClient;
+}>) => Promise<void>;

package/dist/auth/adapter/apple.js

@@ -0,0 +1,22 @@
+import { Issuer } from "openid-client";
+import { OauthAdapter } from "./oauth.js";
+// This adapter support the OAuth flow with the response_mode "form_post" for now.
+// More details about the flow:
+// https://developer.apple.com/documentation/devicemanagement/user_enrollment/onboarding_users_with_account_sign-in/implementing_the_oauth2_authentication_user-enrollment_flow
+//
+// Also note that Apple's discover uri does not work for the OAuth flow, as the
+// userinfo_endpoint are not included in the response.
+// await Issuer.discover("https://appleid.apple.com/.well-known/openid-configuration/");
+const issuer = await Issuer.discover("https://appleid.apple.com/.well-known/openid-configuration");
+export const AppleAdapter = 
+/* @__PURE__ */
+(config) => {
+    return OauthAdapter({
+        issuer,
+        ...config,
+        params: {
+            ...config.params,
+            response_mode: "form_post",
+        },
+    });
+};

package/dist/auth/adapter/code.d.ts

@@ -0,0 +1,7 @@
+export declare function CodeAdapter(config: {
+    length?: number;
+    onCodeRequest: (code: string, claims: Record<string, any>, req: Request) => Promise<Response>;
+    onCodeInvalid: (code: string, claims: Record<string, any>, req: Request) => Promise<Response>;
+}): (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    claims: Record<string, string>;
+}>) => void;

package/dist/auth/adapter/code.js

@@ -0,0 +1,47 @@
+import { deleteCookie, getCookie } from "hono/cookie";
+import { UnknownStateError } from "../index.js";
+import { CompactEncrypt, compactDecrypt } from "jose";
+export function CodeAdapter(config) {
+    const length = config.length || 6;
+    function generate() {
+        const buffer = crypto.getRandomValues(new Uint8Array(length));
+        const otp = Array.from(buffer)
+            .map((byte) => byte % 10)
+            .join("");
+        return otp;
+    }
+    return function (routes, ctx) {
+        routes.get("/authorize", async (c) => {
+            const code = generate();
+            const claims = c.req.query();
+            delete claims["client_id"];
+            delete claims["redirect_uri"];
+            delete claims["response_type"];
+            delete claims["provider"];
+            const authorization = await new CompactEncrypt(new TextEncoder().encode(JSON.stringify({
+                claims,
+                code,
+            })))
+                .setProtectedHeader({ alg: "RSA-OAEP-512", enc: "A256GCM" })
+                .encrypt(await ctx.encryption.publicKey());
+            ctx.cookie(c, "authorization", authorization, 60 * 10);
+            return ctx.forward(c, await config.onCodeRequest(code, claims, c.req.raw));
+        });
+        routes.get("/callback", async (c) => {
+            const authorization = getCookie(c, "authorization");
+            if (!authorization)
+                throw new UnknownStateError();
+            const { code, claims } = JSON.parse(new TextDecoder().decode(await compactDecrypt(authorization, await ctx.encryption.privateKey()).then((value) => value.plaintext)));
+            if (!code || !claims) {
+                return ctx.forward(c, await config.onCodeInvalid(code, claims, c.req.raw));
+            }
+            const compare = c.req.query("code");
+            console.log("comparing", code, "to", compare);
+            if (code !== compare) {
+                return ctx.forward(c, await config.onCodeInvalid(code, claims, c.req.raw));
+            }
+            deleteCookie(c, "authorization");
+            return ctx.forward(c, await ctx.success(c, { claims }));
+        });
+    };
+}

package/dist/auth/adapter/facebook.d.ts

@@ -0,0 +1,5 @@
+import { OauthBasicConfig } from "./oauth.js";
+export declare const FacebookAdapter: (config: OauthBasicConfig) => (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: import("openid-client").TokenSet;
+    client: import("openid-client").BaseClient;
+}>) => Promise<void>;

package/dist/auth/adapter/facebook.js

@@ -0,0 +1,27 @@
+import { Issuer } from "openid-client";
+import { OauthAdapter } from "./oauth.js";
+// Facebook's OIDC flow returns "id_token" as uri hash in redirect uri. Hashes
+// are not passed to Lambda event object. It is likely that Facebook only wants
+// to support redirecting to a frontend uri.
+//
+// We are only going to support the OAuth flow for now. More details about the flow:
+// https://developers.facebook.com/docs/facebook-login/guides/advanced/oidc-token
+//
+// Also note that Facebook's discover uri does not work for the OAuth flow, as the
+// token_endpoint and userinfo_endpoint are not included in the response.
+// await Issuer.discover("https://www.facebook.com/.well-known/openid-configuration/");
+const issuer = new Issuer({
+    issuer: "https://www.facebook.com",
+    authorization_endpoint: "https://facebook.com/dialog/oauth/",
+    jwks_uri: "https://www.facebook.com/.well-known/oauth/openid/jwks/",
+    token_endpoint: "https://graph.facebook.com/oauth/access_token",
+    userinfo_endpoint: "https://graph.facebook.com/oauth/access_token",
+});
+export const FacebookAdapter = 
+/* @__PURE__ */
+(config) => {
+    return OauthAdapter({
+        issuer,
+        ...config,
+    });
+};

package/dist/auth/adapter/github.d.ts

@@ -0,0 +1,7 @@
+import { OauthBasicConfig } from "./oauth.js";
+type Config = OauthBasicConfig;
+export declare const GithubAdapter: (config: Config) => (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: import("openid-client").TokenSet;
+    client: import("openid-client").BaseClient;
+}>) => Promise<void>;
+export {};

package/dist/auth/adapter/github.js

@@ -0,0 +1,15 @@
+import { Issuer } from "openid-client";
+import { OauthAdapter } from "./oauth.js";
+const issuer = new Issuer({
+    issuer: "https://github.com",
+    authorization_endpoint: "https://github.com/login/oauth/authorize",
+    token_endpoint: "https://github.com/login/oauth/access_token",
+});
+export const GithubAdapter = 
+/* @__PURE__ */
+(config) => {
+    return OauthAdapter({
+        issuer,
+        ...config,
+    });
+};

package/dist/auth/adapter/google.d.ts

@@ -0,0 +1,17 @@
+import { OidcBasicConfig } from "./oidc.js";
+import { OauthBasicConfig } from "./oauth.js";
+type GooglePrompt = "none" | "consent" | "select_account";
+type GoogleAccessType = "offline" | "online";
+type GoogleConfig = (OauthBasicConfig & {
+    mode: "oauth";
+    prompt?: GooglePrompt;
+    accessType?: GoogleAccessType;
+}) | (OidcBasicConfig & {
+    mode: "oidc";
+    prompt?: GooglePrompt;
+});
+export declare function GoogleAdapter(config: GoogleConfig): (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: import("openid-client").TokenSet;
+    client: import("openid-client").BaseClient;
+}>) => Promise<void>;
+export {};

package/dist/auth/adapter/google.js

@@ -0,0 +1,22 @@
+import { Issuer } from "openid-client";
+import { OidcAdapter } from "./oidc.js";
+import { OauthAdapter } from "./oauth.js";
+const issuer = await Issuer.discover("https://accounts.google.com");
+export function GoogleAdapter(config) {
+    /* @__PURE__ */
+    if (config.mode === "oauth") {
+        return OauthAdapter({
+            issuer,
+            ...config,
+            params: {
+                ...(config.accessType && { access_type: config.accessType }),
+                ...config.params,
+            },
+        });
+    }
+    return OidcAdapter({
+        issuer,
+        scope: "openid email profile",
+        ...config,
+    });
+}

package/dist/auth/adapter/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./oidc.js";
+export * from "./google.js";
+export * from "./link.js";
+export * from "./github.js";
+export * from "./facebook.js";
+export * from "./microsoft.js";
+export * from "./oauth.js";
+export * from "./spotify.js";
+export * from "./code.js";
+export * from "./apple.js";
+export type { Adapter } from "./adapter.js";

package/dist/auth/adapter/index.js

@@ -0,0 +1,10 @@
+export * from "./oidc.js";
+export * from "./google.js";
+export * from "./link.js";
+export * from "./github.js";
+export * from "./facebook.js";
+export * from "./microsoft.js";
+export * from "./oauth.js";
+export * from "./spotify.js";
+export * from "./code.js";
+export * from "./apple.js";

package/dist/auth/adapter/link.d.ts

@@ -0,0 +1,5 @@
+export declare function LinkAdapter(config: {
+    onLink: (link: string, claims: Record<string, any>) => Promise<Response>;
+}): (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    claims: Record<string, string>;
+}>) => void;

package/dist/auth/adapter/link.js

@@ -0,0 +1,27 @@
+import { SignJWT, jwtVerify } from "jose";
+export function LinkAdapter(config) {
+    return function (routes, ctx) {
+        routes.get("/authorize", async (c) => {
+            const token = await new SignJWT(c.req.query())
+                .setProtectedHeader({ alg: ctx.algorithm })
+                .setExpirationTime("10m")
+                .sign(await ctx.signing.privateKey());
+            const url = new URL(new URL(c.req.url).origin);
+            url.pathname = `/${ctx.name}/callback`;
+            for (const key of url.searchParams.keys()) {
+                url.searchParams.delete(key);
+            }
+            url.searchParams.set("token", token);
+            const resp = ctx.forward(c, await config.onLink(url.toString(), c.req.query()));
+            return resp;
+        });
+        routes.get("/callback", async (c) => {
+            const token = c.req.query("token");
+            if (!token)
+                throw new Error("Missing token parameter");
+            const verified = await jwtVerify(token, await ctx.signing.publicKey());
+            const resp = await ctx.success(c, { claims: verified.payload });
+            return resp;
+        });
+    };
+}

package/dist/auth/adapter/microsoft.d.ts

@@ -0,0 +1,11 @@
+import { OidcBasicConfig } from "./oidc.js";
+type MicrosoftConfig = OidcBasicConfig & {
+    mode: "oidc";
+    prompt?: "login" | "none" | "consent" | "select_account";
+    tenantID?: string;
+};
+export declare function MicrosoftAdapter(config: MicrosoftConfig): (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: import("openid-client").TokenSet;
+    client: import("openid-client").BaseClient;
+}>) => Promise<void>;
+export {};

package/dist/auth/adapter/microsoft.js

@@ -0,0 +1,16 @@
+import { Issuer } from "openid-client";
+import { OidcAdapter } from "./oidc.js";
+export function MicrosoftAdapter(config) {
+    const authority = config?.tenantID ?? "common";
+    const issuer = `https://login.microsoftonline.com/${authority}`;
+    return OidcAdapter({
+        issuer: new Issuer({
+            issuer: `${issuer}/v2.0`,
+            authorization_endpoint: `${issuer}/oauth2/v2.0/authorize`,
+            token_endpoint: `${issuer}/oauth2/v2.0/token`,
+            jwks_uri: `${issuer}/discovery/v2.0/keys`,
+        }),
+        scope: "openid email profile",
+        ...config,
+    });
+}

package/dist/auth/adapter/oauth.d.ts

@@ -0,0 +1,33 @@
+import { BaseClient, Issuer, TokenSet } from "openid-client";
+import { AdapterError } from "./adapter.js";
+export interface OauthBasicConfig {
+    /**
+     * The clientID provided by the third party oauth service
+     */
+    clientID: string;
+    /**
+     * The clientSecret provided by the third party oauth service
+     */
+    clientSecret: string;
+    /**
+     * Various scopes requested for the access token
+     */
+    scope: string;
+    /**
+     * Determines whether users will be prompted for reauthentication and consent
+     */
+    prompt?: string;
+    /**
+     * Additional parameters to be passed to the authorization endpoint
+     */
+    params?: Record<string, string>;
+}
+export interface OauthConfig extends OauthBasicConfig {
+    issuer: Issuer;
+}
+export declare class OauthError extends AdapterError {
+}
+export declare const OauthAdapter: (config: OauthConfig) => (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: TokenSet;
+    client: BaseClient;
+}>) => Promise<void>;

package/dist/auth/adapter/oauth.js

@@ -0,0 +1,82 @@
+import { generators } from "openid-client";
+import { AdapterError } from "./adapter.js";
+import { getCookie } from "hono/cookie";
+export class OauthError extends AdapterError {
+}
+export const OauthAdapter = 
+/* @__PURE__ */
+(config) => {
+    return async function (routes, ctx) {
+        function getClient(c) {
+            const callback = new URL(c.req.url);
+            callback.pathname = callback.pathname.replace(/authorize.*$/, "callback");
+            callback.search = "";
+            callback.host = c.req.header("x-forwarded-host") || callback.host;
+            return [
+                callback,
+                new config.issuer.Client({
+                    client_id: config.clientID,
+                    client_secret: config.clientSecret,
+                    redirect_uris: [callback.toString()],
+                    response_types: ["code"],
+                }),
+            ];
+        }
+        routes.get("/authorize", async (c) => {
+            const [_, client] = getClient(c);
+            const code_verifier = generators.codeVerifier();
+            const state = generators.state();
+            const code_challenge = generators.codeChallenge(code_verifier);
+            const url = client.authorizationUrl({
+                scope: config.scope,
+                code_challenge: code_challenge,
+                code_challenge_method: "S256",
+                state,
+                prompt: config.prompt,
+                ...config.params,
+            });
+            ctx.cookie(c, "auth_code_verifier", code_verifier, 60 * 10);
+            ctx.cookie(c, "auth_state", state, 60 * 10);
+            return c.redirect(url);
+        });
+        routes.get("/callback", async (c) => {
+            const [callback, client] = getClient(c);
+            const query = c.req.query();
+            if (query.error) {
+                throw new OauthError(query.error);
+            }
+            const code_verifier = getCookie(c, "auth_code_verifier");
+            const state = getCookie(c, "auth_state");
+            const tokenset = await client[config.issuer.metadata.userinfo_endpoint
+                ? "callback"
+                : "oauthCallback"](callback.toString(), query, {
+                code_verifier,
+                state,
+            });
+            return ctx.success(c, {
+                client,
+                tokenset,
+            });
+        });
+        // response_mode=form_post
+        routes.post("/callback", async (c) => {
+            const [callback, client] = getClient(c);
+            const form = await c.req.formData();
+            if (form.get("error")) {
+                throw new OauthError(form.get("error").toString());
+            }
+            const code_verifier = getCookie(c, "auth_code_verifier");
+            const state = getCookie(c, "auth_state");
+            const tokenset = await client[config.issuer.metadata.userinfo_endpoint
+                ? "callback"
+                : "oauthCallback"](callback.toString(), Object.fromEntries(form), {
+                code_verifier,
+                state,
+            });
+            return ctx.success(c, {
+                client,
+                tokenset,
+            });
+        });
+    };
+};

package/dist/auth/adapter/oidc.d.ts

@@ -0,0 +1,19 @@
+import { BaseClient, Issuer, TokenSet } from "openid-client";
+export interface OidcBasicConfig {
+    /**
+     * The clientID provided by the third party oauth service
+     */
+    clientID: string;
+    /**
+     * Determines whether users will be prompted for reauthentication and consent
+     */
+    prompt?: string;
+}
+export interface OidcConfig extends OidcBasicConfig {
+    issuer: Issuer;
+    scope: string;
+}
+export declare const OidcAdapter: (config: OidcConfig) => (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: TokenSet;
+    client: BaseClient;
+}>) => Promise<void>;

package/dist/auth/adapter/oidc.js

@@ -0,0 +1,48 @@
+import { generators } from "openid-client";
+import { getCookie } from "hono/cookie";
+export const OidcAdapter = /* @__PURE__ */ (config) => {
+    return async function (routes, ctx) {
+        routes.get("/authorize", async (c) => {
+            const callback = new URL(c.req.url);
+            callback.pathname = callback.pathname.replace(/authorize.*$/, "callback");
+            callback.search = "";
+            callback.host = c.req.header("x-forwarded-host") || callback.host;
+            const client = new config.issuer.Client({
+                client_id: config.clientID,
+                redirect_uris: [callback.toString()],
+                response_types: ["id_token"],
+            });
+            const nonce = generators.nonce();
+            const state = generators.state();
+            const url = client.authorizationUrl({
+                scope: config.scope,
+                response_mode: "form_post",
+                nonce,
+                state,
+                prompt: config.prompt,
+            });
+            ctx.cookie(c, "auth_nonce", nonce, 60 * 10);
+            ctx.cookie(c, "auth_state", state, 60 * 10);
+            return c.redirect(url);
+        });
+        routes.post("/callback", async (c) => {
+            const callback = c.req.url.replace(/authorize\/.*$/, "callback");
+            const client = new config.issuer.Client({
+                client_id: config.clientID,
+                redirect_uris: [callback],
+                response_types: ["id_token"],
+            });
+            const form = await c.req.formData();
+            const nonce = getCookie(c, "auth_nonce");
+            const state = getCookie(c, "auth_state");
+            const tokenset = await client.callback(callback, Object.fromEntries(form), {
+                nonce,
+                state,
+            });
+            return ctx.success(c, {
+                tokenset,
+                client,
+            });
+        });
+    };
+};

package/dist/auth/adapter/spotify.d.ts

@@ -0,0 +1,12 @@
+import { OauthBasicConfig } from "./oauth.js";
+/**
+ * The Spotify Adapter follows the PKCE flow outlined here:
+ * https://developer.spotify.com/documentation/web-api/tutorials/code-pkce-flow
+ *
+ * List of scopes available:
+ * https://developer.spotify.com/documentation/web-api/concepts/scopes
+ */
+export declare const SpotifyAdapter: (config: OauthBasicConfig) => (routes: import("./adapter.js").AdapterRoute, ctx: import("./adapter.js").AdapterOptions<{
+    tokenset: import("openid-client").TokenSet;
+    client: import("openid-client").BaseClient;
+}>) => Promise<void>;

package/dist/auth/adapter/spotify.js

@@ -0,0 +1,22 @@
+import { Issuer } from "openid-client";
+import { OauthAdapter } from "./oauth.js";
+const issuer = new Issuer({
+    issuer: "https://accounts.spotify.com",
+    authorization_endpoint: "https://accounts.spotify.com/authorize",
+    token_endpoint: "https://accounts.spotify.com/api/token",
+});
+/**
+ * The Spotify Adapter follows the PKCE flow outlined here:
+ * https://developer.spotify.com/documentation/web-api/tutorials/code-pkce-flow
+ *
+ * List of scopes available:
+ * https://developer.spotify.com/documentation/web-api/concepts/scopes
+ */
+export const SpotifyAdapter = 
+/* @__PURE__ */
+(config) => {
+    return OauthAdapter({
+        issuer,
+        ...config,
+    });
+};

package/dist/auth/example/bun.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("hono/hono-base").HonoBase<import("hono").Env, import("hono/types").BlankSchema, string>;
+export default _default;