studiocms 0.1.0-beta.10

package/dist/routes/auth/api/auth0/shared.js

@@ -0,0 +1,24 @@
+import { authEnvCheck } from "studiocms:auth/utils/authEnvCheck";
+import { AuthConfig } from "studiocms:config";
+import { Auth0 } from "arctic";
+const {
+  AUTH0: { CLIENT_ID = "", CLIENT_SECRET = "", DOMAIN, REDIRECT_URI = "" }
+} = await authEnvCheck(AuthConfig.providers);
+const getClientDomain = () => {
+  const cleanDomainSlash = DOMAIN ? DOMAIN.replace(/^\//, "") : "";
+  const NoHttpDomain = cleanDomainSlash.replace(/http:\/\//, "").replace(/https:\/\//, "");
+  return `https://${NoHttpDomain}`;
+};
+const ProviderID = "auth0";
+const ProviderCookieName = "auth0_oauth_state";
+const auth0 = new Auth0(getClientDomain(), CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);
+export {
+  CLIENT_ID,
+  CLIENT_SECRET,
+  DOMAIN,
+  ProviderCookieName,
+  ProviderID,
+  REDIRECT_URI,
+  auth0,
+  getClientDomain
+};

package/dist/routes/auth/api/discord/callback.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/discord/callback.js

@@ -0,0 +1,112 @@
+import { createUserSession } from "studiocms:auth/lib/session";
+import { LinkNewOAuthCookieName, createOAuthUser, getUserData } from "studiocms:auth/lib/user";
+import { config } from "studiocms:config";
+import { StudioCMSRoutes } from "studiocms:lib";
+import studioCMS_SDK from "studiocms:sdk";
+import { OAuth2RequestError } from "arctic";
+import { ProviderCookieName, ProviderID, discord } from "./shared.js";
+const GET = async (context) => {
+  const { url, cookies, redirect } = context;
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = cookies.get(ProviderCookieName)?.value ?? null;
+  if (!code || !state || !storedState || state !== storedState) {
+    return redirect(StudioCMSRoutes.authLinks.loginURL);
+  }
+  let tokens;
+  try {
+    tokens = await discord.validateAuthorizationCode(code);
+    const discordResponse = await fetch("https://discord.com/api/users/@me", {
+      headers: {
+        Authorization: `Bearer ${tokens.accessToken}`
+      }
+    });
+    const discordUser = await discordResponse.json();
+    const discordUserId = discordUser.id;
+    const discordUsername = discordUser.username;
+    const existingOAuthAccount = await studioCMS_SDK.AUTH.oAuth.searchProvidersForId(
+      ProviderID,
+      discordUserId
+    );
+    if (existingOAuthAccount) {
+      const user = await studioCMS_SDK.GET.databaseEntry.users.byId(existingOAuthAccount.userId);
+      if (!user) {
+        return new Response("User not found", {
+          status: 404
+        });
+      }
+      await createUserSession(user.id, context);
+      return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+    }
+    const loggedInUser = await getUserData(context);
+    const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;
+    if (loggedInUser.user && linkNewOAuth) {
+      const existingUser = await studioCMS_SDK.GET.databaseEntry.users.byId(loggedInUser.user.id);
+      if (existingUser) {
+        await studioCMS_SDK.AUTH.oAuth.create({
+          userId: existingUser.id,
+          provider: ProviderID,
+          providerUserId: discordUserId
+        });
+        await createUserSession(existingUser.id, context);
+        return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+      }
+    }
+    const avatar_url = `https://cdn.discordapp.com/avatars/${discordUserId}/${discordUser.avatar}.png`;
+    const newUser = await createOAuthUser(
+      {
+        id: crypto.randomUUID(),
+        username: discordUsername,
+        name: discordUser.global_name ?? discordUsername,
+        email: discordUser.email,
+        avatar: avatar_url,
+        createdAt: /* @__PURE__ */ new Date()
+      },
+      { provider: ProviderID, providerUserId: discordUserId }
+    );
+    if ("error" in newUser) {
+      return new Response("Error creating user", { status: 500 });
+    }
+    if (config.dbStartPage) {
+      return redirect("/done");
+    }
+    await createUserSession(newUser.id, context);
+    return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+  } catch (e) {
+    if (e instanceof OAuth2RequestError) {
+      const code2 = e.code;
+      return new Response(code2, {
+        status: 400
+      });
+    }
+    return new Response(null, {
+      status: 500
+    });
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/discord/index.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/discord/index.js

@@ -0,0 +1,36 @@
+import { setOAuthSessionTokenCookie } from "studiocms:auth/lib/session";
+import { generateState } from "arctic";
+import { ProviderCookieName, discord } from "./shared.js";
+const GET = async (context) => {
+  const state = generateState();
+  const scopes = ["identify", "email"];
+  const url = discord.createAuthorizationURL(state, scopes);
+  setOAuthSessionTokenCookie(context, ProviderCookieName, state);
+  return context.redirect(url.toString());
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/discord/shared.d.ts

@@ -0,0 +1,12 @@
+import { Discord } from 'arctic';
+export declare const CLIENT_ID: string, CLIENT_SECRET: string, REDIRECT_URI: string;
+export declare const ProviderID = "discord";
+export declare const ProviderCookieName = "discord_oauth_state";
+export declare const discord: Discord;
+export interface DiscordUser {
+    id: string;
+    avatar: string;
+    username: string;
+    global_name: string;
+    email: string;
+}

package/dist/routes/auth/api/discord/shared.js

@@ -0,0 +1,17 @@
+import { authEnvCheck } from "studiocms:auth/utils/authEnvCheck";
+import { AuthConfig } from "studiocms:config";
+import { Discord } from "arctic";
+const {
+  DISCORD: { CLIENT_ID = "", CLIENT_SECRET = "", REDIRECT_URI = "" }
+} = await authEnvCheck(AuthConfig.providers);
+const ProviderID = "discord";
+const ProviderCookieName = "discord_oauth_state";
+const discord = new Discord(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);
+export {
+  CLIENT_ID,
+  CLIENT_SECRET,
+  ProviderCookieName,
+  ProviderID,
+  REDIRECT_URI,
+  discord
+};

package/dist/routes/auth/api/github/callback.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/github/callback.js

@@ -0,0 +1,112 @@
+import { createUserSession } from "studiocms:auth/lib/session";
+import { LinkNewOAuthCookieName, createOAuthUser, getUserData } from "studiocms:auth/lib/user";
+import { config } from "studiocms:config";
+import { StudioCMSRoutes } from "studiocms:lib";
+import studioCMS_SDK from "studiocms:sdk";
+import { OAuth2RequestError } from "arctic";
+import { ProviderCookieName, ProviderID, github } from "./shared.js";
+const GET = async (context) => {
+  const { url, cookies, redirect } = context;
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = cookies.get(ProviderCookieName)?.value ?? null;
+  if (!code || !state || !storedState || state !== storedState) {
+    return redirect(StudioCMSRoutes.authLinks.loginURL);
+  }
+  let tokens;
+  try {
+    tokens = await github.validateAuthorizationCode(code);
+    const githubUserResponse = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `Bearer ${tokens.accessToken}`
+      }
+    });
+    const githubUser = await githubUserResponse.json();
+    const githubUserId = githubUser.id;
+    const githubUsername = githubUser.login;
+    const existingOAuthAccount = await studioCMS_SDK.AUTH.oAuth.searchProvidersForId(
+      ProviderID,
+      `${githubUserId}`
+    );
+    if (existingOAuthAccount) {
+      const user = await studioCMS_SDK.GET.databaseEntry.users.byId(existingOAuthAccount.userId);
+      if (!user) {
+        return new Response("User not found", {
+          status: 404
+        });
+      }
+      await createUserSession(user.id, context);
+      return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+    }
+    const loggedInUser = await getUserData(context);
+    const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;
+    if (loggedInUser.user && linkNewOAuth) {
+      const existingUser = await studioCMS_SDK.GET.databaseEntry.users.byId(loggedInUser.user.id);
+      if (existingUser) {
+        await studioCMS_SDK.AUTH.oAuth.create({
+          userId: existingUser.id,
+          provider: ProviderID,
+          providerUserId: `${githubUserId}`
+        });
+        await createUserSession(existingUser.id, context);
+        return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+      }
+    }
+    const newUser = await createOAuthUser(
+      {
+        id: crypto.randomUUID(),
+        username: githubUsername,
+        email: githubUser.email,
+        name: githubUser.name,
+        avatar: githubUser.avatar_url,
+        createdAt: /* @__PURE__ */ new Date(),
+        url: githubUser.blog
+      },
+      { provider: ProviderID, providerUserId: `${githubUserId}` }
+    );
+    if ("error" in newUser) {
+      return new Response("Error creating user", { status: 500 });
+    }
+    if (config.dbStartPage) {
+      return redirect("/done");
+    }
+    await createUserSession(newUser.id, context);
+    return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+  } catch (e) {
+    if (e instanceof OAuth2RequestError) {
+      const code2 = e.code;
+      return new Response(code2, {
+        status: 400
+      });
+    }
+    return new Response(null, {
+      status: 400
+    });
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/github/index.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/github/index.js

@@ -0,0 +1,36 @@
+import { setOAuthSessionTokenCookie } from "studiocms:auth/lib/session";
+import { generateState } from "arctic";
+import { ProviderCookieName, github } from "./shared.js";
+const GET = async (context) => {
+  const state = generateState();
+  const scopes = ["user:email", "repo"];
+  const url = github.createAuthorizationURL(state, scopes);
+  setOAuthSessionTokenCookie(context, ProviderCookieName, state);
+  return context.redirect(url.toString());
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/github/shared.d.ts

@@ -0,0 +1,13 @@
+import { GitHub } from 'arctic';
+export declare const ProviderID = "github";
+export declare const ProviderCookieName = "github_oauth_state";
+export declare const github: GitHub;
+export interface GitHubUser {
+    id: number;
+    html_url: string;
+    login: string;
+    avatar_url: string;
+    name: string;
+    blog: string;
+    email: string;
+}

package/dist/routes/auth/api/github/shared.js

@@ -0,0 +1,14 @@
+import { authEnvCheck } from "studiocms:auth/utils/authEnvCheck";
+import { AuthConfig } from "studiocms:config";
+import { GitHub } from "arctic";
+const {
+  GITHUB: { CLIENT_ID = "", CLIENT_SECRET = "", REDIRECT_URI = null }
+} = await authEnvCheck(AuthConfig.providers);
+const ProviderID = "github";
+const ProviderCookieName = "github_oauth_state";
+const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);
+export {
+  ProviderCookieName,
+  ProviderID,
+  github
+};

package/dist/routes/auth/api/google/callback.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/google/callback.js

@@ -0,0 +1,115 @@
+import { createUserSession } from "studiocms:auth/lib/session";
+import { LinkNewOAuthCookieName, createOAuthUser, getUserData } from "studiocms:auth/lib/user";
+import config from "studiocms:config";
+import { StudioCMSRoutes } from "studiocms:lib";
+import studioCMS_SDK from "studiocms:sdk";
+import { OAuth2RequestError } from "arctic";
+import {
+  ProviderCodeVerifier,
+  ProviderCookieName,
+  ProviderID,
+  google
+} from "./shared.js";
+const GET = async (context) => {
+  const { url, cookies, redirect } = context;
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const codeVerifier = cookies.get(ProviderCodeVerifier)?.value ?? null;
+  const storedState = cookies.get(ProviderCookieName)?.value ?? null;
+  if (!code || !storedState || !codeVerifier || state !== storedState) {
+    return redirect(StudioCMSRoutes.authLinks.loginURL);
+  }
+  let tokens;
+  try {
+    tokens = await google.validateAuthorizationCode(code, codeVerifier);
+    const googleUserResponse = await fetch("https://openidconnect.googleapis.com/v1/userinfo", {
+      headers: {
+        Authorization: `Bearer ${tokens.accessToken}`
+      }
+    });
+    const googleUser = await googleUserResponse.json();
+    const googleUserId = googleUser.sub;
+    const googleUsername = googleUser.name;
+    const existingOAuthAccount = await studioCMS_SDK.AUTH.oAuth.searchProvidersForId(
+      ProviderID,
+      googleUserId
+    );
+    if (existingOAuthAccount) {
+      const user = await studioCMS_SDK.GET.databaseEntry.users.byId(existingOAuthAccount.userId);
+      if (!user) {
+        return new Response("User not found", { status: 404 });
+      }
+      await createUserSession(user.id, context);
+      return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+    }
+    const loggedInUser = await getUserData(context);
+    const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;
+    if (loggedInUser.user && linkNewOAuth) {
+      const existingUser = await studioCMS_SDK.GET.databaseEntry.users.byId(loggedInUser.user.id);
+      if (existingUser) {
+        await studioCMS_SDK.AUTH.oAuth.create({
+          userId: existingUser.id,
+          provider: ProviderID,
+          providerUserId: googleUserId
+        });
+        await createUserSession(existingUser.id, context);
+        return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+      }
+    }
+    const newUser = await createOAuthUser(
+      {
+        id: crypto.randomUUID(),
+        username: googleUsername,
+        email: googleUser.email,
+        name: googleUser.name,
+        avatar: googleUser.picture,
+        createdAt: /* @__PURE__ */ new Date()
+      },
+      { provider: ProviderID, providerUserId: googleUserId }
+    );
+    if ("error" in newUser) {
+      return new Response("Error creating user", { status: 500 });
+    }
+    if (config.dbStartPage) {
+      return redirect("/done");
+    }
+    await createUserSession(newUser.id, context);
+    return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+  } catch (e) {
+    if (e instanceof OAuth2RequestError) {
+      const code2 = e.code;
+      return new Response(code2, {
+        status: 400
+      });
+    }
+    return new Response(null, {
+      status: 500
+    });
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/google/index.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/google/index.js

@@ -0,0 +1,38 @@
+import { setOAuthSessionTokenCookie } from "studiocms:auth/lib/session";
+import { generateCodeVerifier, generateState } from "arctic";
+import { ProviderCodeVerifier, ProviderCookieName, google } from "./shared.js";
+const GET = async (context) => {
+  const state = generateState();
+  const codeVerifier = generateCodeVerifier();
+  const scopes = ["profile", "email"];
+  const url = google.createAuthorizationURL(state, codeVerifier, scopes);
+  setOAuthSessionTokenCookie(context, ProviderCookieName, state);
+  setOAuthSessionTokenCookie(context, ProviderCodeVerifier, codeVerifier);
+  return context.redirect(url.toString());
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/google/shared.d.ts

@@ -0,0 +1,12 @@
+import { Google } from 'arctic';
+export declare const CLIENT_ID: string, CLIENT_SECRET: string, REDIRECT_URI: string;
+export declare const ProviderID = "google";
+export declare const ProviderCookieName = "google_oauth_state";
+export declare const ProviderCodeVerifier = "google_oauth_code_verifier";
+export declare const google: Google;
+export interface GoogleUser {
+    sub: string;
+    picture: string;
+    name: string;
+    email: string;
+}

package/dist/routes/auth/api/google/shared.js

@@ -0,0 +1,19 @@
+import { authEnvCheck } from "studiocms:auth/utils/authEnvCheck";
+import { AuthConfig } from "studiocms:config";
+import { Google } from "arctic";
+const {
+  GOOGLE: { CLIENT_ID = "", CLIENT_SECRET = "", REDIRECT_URI = "" }
+} = await authEnvCheck(AuthConfig.providers);
+const ProviderID = "google";
+const ProviderCookieName = "google_oauth_state";
+const ProviderCodeVerifier = "google_oauth_code_verifier";
+const google = new Google(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);
+export {
+  CLIENT_ID,
+  CLIENT_SECRET,
+  ProviderCodeVerifier,
+  ProviderCookieName,
+  ProviderID,
+  REDIRECT_URI,
+  google
+};

package/dist/routes/auth/api/login.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const POST: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/login.js

@@ -0,0 +1,46 @@
+import { verifyPasswordHash } from "studiocms:auth/lib/password";
+import { createUserSession } from "studiocms:auth/lib/session";
+import studioCMS_SDK from "studiocms:sdk";
+import { badFormDataEntry, parseFormDataEntryToString } from "./shared.js";
+const POST = async (context) => {
+  const formData = await context.request.formData();
+  const username = parseFormDataEntryToString(formData, "username");
+  const password = parseFormDataEntryToString(formData, "password");
+  if (!username) return badFormDataEntry("Missing field", "Username is required");
+  if (!password) return badFormDataEntry("Missing field", "Password is required");
+  const existingUser = await studioCMS_SDK.GET.databaseEntry.users.byUsername(username);
+  if (!existingUser) return badFormDataEntry("Invalid credentials", "Invalid username or password");
+  if (!existingUser.password)
+    return badFormDataEntry("Incorrect method", "User is using OAuth login");
+  const validPassword = await verifyPasswordHash(existingUser.password, password);
+  if (!validPassword)
+    return badFormDataEntry("Invalid credentials", "Invalid username or password");
+  await createUserSession(existingUser.id, context);
+  return new Response();
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, POST",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  OPTIONS,
+  POST
+};

package/dist/routes/auth/api/logout.d.ts

@@ -0,0 +1,5 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const POST: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;