@wasp.sh/wasp-cli-darwin-arm64-unknown 0.20.0

package/data/Generator/templates/sdk/wasp/universal/url.ts

@@ -0,0 +1,9 @@
+export function stripTrailingSlash(url: string): string
+export function stripTrailingSlash(url: undefined): undefined
+export function stripTrailingSlash(url?: string): string | undefined {
+    return url?.replace(/\/$/, "");
+}
+
+export function getOrigin(url: string) {
+    return new URL(url).origin;
+}

package/data/Generator/templates/sdk/wasp/universal/validators.ts

@@ -0,0 +1,21 @@
+export function isValidAbsoluteURL(rawUrl: string): boolean {
+    try {
+        const url = new URL(rawUrl);
+        /*
+            URL constructor will parse some invalid absolute URLs as valid URLs
+            so we need to do some extra checks.
+
+            Example: "localhost:3000" will be parsed as URL with protocol of
+            "localhost:" and host of "3000"
+        */
+        return url.protocol === "http:" || url.protocol === "https:";
+    } catch (e) {
+        return false;
+    }
+}
+
+export function throwIfNotValidAbsoluteURL(value: string | undefined, name: string): void {
+    if (value && !isValidAbsoluteURL(value)) {
+        throw new Error(`${name} must be a valid absolute URL`);
+    }
+}

package/data/Generator/templates/sdk/wasp/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/data/Generator/templates/server/README.md

@@ -0,0 +1 @@
+`npm start` to run server in development mode (it reloads on changes).

package/data/Generator/templates/server/gitignore

@@ -0,0 +1,6 @@
+node_modules
+
+npm-debug.log
+*.log
+
+.env

package/data/Generator/templates/server/nodemon.json

@@ -0,0 +1,13 @@
+{{={= =}=}}
+{
+  "env": {
+    "NODE_ENV": "development"
+  },
+  "watch": [
+    "src/",
+    "{= relativeUserSrcDirPath =}",
+    ".env"
+  ],
+  "comment-filip": "We now have to watch {= relativeUserSrcDirPath =} because we're importing client files directly",
+  "ext": "ts,mts,js,mjs,json"
+}

package/data/Generator/templates/server/npmrc

@@ -0,0 +1 @@
+engine-strict=true

package/data/Generator/templates/server/package.json

@@ -0,0 +1,27 @@
+{{={= =}=}}
+{
+  "name": "{= packageName =}",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "comment-filip": "The server.js location changed because we have now included client source files above .wasp/out/server/src.",
+  "scripts": {
+    "bundle": "tsc --build && rollup --config --silent",
+    "start": "node --enable-source-maps -r dotenv/config bundle/server.js",
+    "bundle-and-start": "npm run bundle && npm run start",
+    "watch": "nodemon --exec 'npm run bundle-and-start || exit 1'",
+    "db-seed": "npm run bundle && node --enable-source-maps -r dotenv/config bundle/dbSeed.js",
+    "db-migrate-prod": "prisma migrate deploy --schema=../db/schema.prisma",
+    "start-production": "{=& startProductionScript =}"
+  },
+  "nodemonConfig": {
+    "delay": "1000"
+  },
+  "engineStrict": true,
+  "engines": {
+    "node": "{=& nodeVersionRange =}"
+  },
+  "prisma": {=& prisma =},
+  {=& depsChunk =},
+  {=& devDepsChunk =}
+}

package/data/Generator/templates/server/rollup.config.js

@@ -0,0 +1,44 @@
+{{={= =}=}}
+import esbuild from 'rollup-plugin-esbuild'
+import resolve from '@rollup/plugin-node-resolve';
+
+export default [
+  createBundle('src/server.ts', 'bundle/server.js'),
+  {=# areDbSeedsDefined =}
+  createBundle('src/dbSeed.ts', 'bundle/dbSeed.js'),
+  {=/ areDbSeedsDefined =}
+]
+
+function createBundle(inputFilePath, outputFilePath) {
+  return {
+    input: inputFilePath,
+    output: {
+      file: outputFilePath,
+      format: 'es',
+      sourcemap: true,
+    },
+    plugins: [
+      resolve(),
+      esbuild({
+        target: 'esnext',
+      }),
+    ],
+    // We don't want to bundle any of the node_module deps because we want to
+    // keep them as external dependencies.
+    external: /node_modules/,
+    // 'preserveSymlinks: false' tells Rollup to fully follow symlinks when
+    // resolving modules. This is the default option, but we're setting it
+    // explicitly because we rely on it.
+    //
+    // With this set to 'false', the 'wasp' package resolves to
+    // '.wasp/out/sdk/wasp' (not 'node_modules/wasp'), preventing Rollup from
+    // viewing it as an external dependency and ensuring it gets bundled.
+    //
+    // We need to bundle 'wasp' to support fully extensionless relative
+    // imports. See https://github.com/wasp-lang/wasp/issues/2492 for more
+    // details.
+    //
+    // Source: https://rollupjs.org/configuration-options/#preservesymlinks
+    preserveSymlinks: false,
+  }
+}

package/data/Generator/templates/server/src/actions/_action.ts

@@ -0,0 +1,18 @@
+{{={= =}=}}
+import { prisma } from 'wasp/server'
+
+{=& jsFn.importStatement =}
+
+{=! TODO: This template is exactly the same at the moment as one for queries,
+          consider in the future if it is worth removing this duplication. =}
+
+export default async function (args, context) {
+  return ({= jsFn.importIdentifier =} as any)(args, {
+    ...context,
+    entities: {
+      {=# entities =}
+      {= name =}: prisma.{= prismaIdentifier =},
+      {=/ entities =}
+    },
+  })
+}

package/data/Generator/templates/server/src/app.js

@@ -0,0 +1,36 @@
+import express from 'express'
+
+import { HttpError } from 'wasp/server'
+import indexRouter from './routes/index.js'
+
+// TODO: Consider extracting most of this logic into createApp(routes, path) function so that
+//   it can be used in unit tests to test each route individually.
+
+const app = express()
+
+// NOTE: Middleware are installed on a per-router or per-route basis.
+
+app.use('/', indexRouter)
+
+// Custom error handler.
+app.use((err, _req, res, next) => {
+  // As by expressjs documentation, when the headers have already
+  // been sent to the client, we must delegate to the default error handler.
+  if (res.headersSent) { return next(err) }
+
+  if (err instanceof HttpError) {
+    return res.status(err.statusCode).json({ message: err.message, data: err.data })
+  }
+
+  // This forwards the error to the default express error handler.
+  // As described by expressjs documentation, the default error handler sets response status
+  // to err.status or err.statusCode if it is 4xx or 5xx, and if not, sets it to 500.
+  // It won't add any more info to it if server is running in production, which is exactly what we want,
+  // we want to share as little info as possible when error happens in production, for security reasons,
+  // so they will get only status code if set, or 500 if not, no extra info.
+  // In development it will also share the error stack though, which is useful.
+  // If the user wants to put more information about the error into the response, they should use HttpError.
+  return next(err)
+})
+
+export default app

package/data/Generator/templates/server/src/auth/hooks.ts

@@ -0,0 +1,135 @@
+{{={= =}=}}
+import { prisma } from 'wasp/server'
+import type {
+  OnAfterSignupHook,
+  OnAfterEmailVerifiedHook,
+  OnBeforeOAuthRedirectHook,
+  OnBeforeSignupHook,
+  OnBeforeLoginHook,
+  OnAfterLoginHook,
+  InternalAuthHookParams,
+} from 'wasp/server/auth'
+{=# onBeforeSignupHook.isDefined =}
+{=& onBeforeSignupHook.importStatement =}
+{=/ onBeforeSignupHook.isDefined =}
+{=# onAfterSignupHook.isDefined =}
+{=& onAfterSignupHook.importStatement =}
+{=/ onAfterSignupHook.isDefined =}
+{=# onAfterEmailVerifiedHook.isDefined =}
+{=& onAfterEmailVerifiedHook.importStatement =}
+{=/ onAfterEmailVerifiedHook.isDefined =}
+{=# onBeforeOAuthRedirectHook.isDefined =}
+{=& onBeforeOAuthRedirectHook.importStatement =}
+{=/ onBeforeOAuthRedirectHook.isDefined =}
+{=# onBeforeLoginHook.isDefined =}
+{=& onBeforeLoginHook.importStatement =}
+{=/ onBeforeLoginHook.isDefined =}
+{=# onAfterLoginHook.isDefined =}
+{=& onAfterLoginHook.importStatement =}
+{=/ onAfterLoginHook.isDefined =}
+
+/*
+  These are "internal hook functions" based on the user defined hook functions.
+
+  In the server code (e.g. email signup) we import these functions and call them.
+
+  We want to pass extra params to the user defined hook functions, but we don't want to
+  pass them when we call them in the server code.
+*/
+
+{=# onBeforeSignupHook.isDefined =}
+export const onBeforeSignupHook: InternalFunctionForHook<OnBeforeSignupHook> = (params) =>
+  {= onBeforeSignupHook.importIdentifier =}({
+    prisma,
+    ...params,
+  })
+{=/ onBeforeSignupHook.isDefined =}
+{=^ onBeforeSignupHook.isDefined =}
+/**
+ * This is a no-op function since the user didn't define the onBeforeSignup hook.
+ */
+export const onBeforeSignupHook: InternalFunctionForHook<OnBeforeSignupHook> = async (_params) => {}
+{=/ onBeforeSignupHook.isDefined =}
+
+{=# onAfterSignupHook.isDefined =}
+export const onAfterSignupHook: InternalFunctionForHook<OnAfterSignupHook> = (params) =>
+  {= onAfterSignupHook.importIdentifier =}({
+    prisma,
+    ...params,
+  })
+{=/ onAfterSignupHook.isDefined =}
+{=^ onAfterSignupHook.isDefined =}
+/**
+ * This is a no-op function since the user didn't define the onAfterSignup hook.
+ */
+export const onAfterSignupHook: InternalFunctionForHook<OnAfterSignupHook> = async (_params) => {}
+{=/ onAfterSignupHook.isDefined =}
+
+{=# onAfterEmailVerifiedHook.isDefined =}
+export const onAfterEmailVerifiedHook: InternalFunctionForHook<OnAfterEmailVerifiedHook> = (params) =>
+  {= onAfterEmailVerifiedHook.importIdentifier =}({
+    prisma,
+    ...params,
+  })
+{=/ onAfterEmailVerifiedHook.isDefined =}
+{=^ onAfterEmailVerifiedHook.isDefined =}
+/**
+ * This is a no-op function since the user didn't define the onAfterSignup hook.
+ */
+export const onAfterEmailVerifiedHook: InternalFunctionForHook<OnAfterEmailVerifiedHook> = async (_params) => {}
+{=/ onAfterEmailVerifiedHook.isDefined =}
+
+{=# onBeforeOAuthRedirectHook.isDefined =}
+export const onBeforeOAuthRedirectHook: InternalFunctionForHook<OnBeforeOAuthRedirectHook> = (params) =>
+  {= onBeforeOAuthRedirectHook.importIdentifier =}({
+    prisma,
+    ...params,
+  })
+{=/ onBeforeOAuthRedirectHook.isDefined =}
+{=^ onBeforeOAuthRedirectHook.isDefined =}
+/**
+ * This is an identity function since the user didn't define the onBeforeOAuthRedirect hook.
+ */
+export const onBeforeOAuthRedirectHook: InternalFunctionForHook<OnBeforeOAuthRedirectHook> = async (params) => params
+{=/ onBeforeOAuthRedirectHook.isDefined =}
+
+
+{=# onBeforeLoginHook.isDefined =}
+export const onBeforeLoginHook: InternalFunctionForHook<OnBeforeLoginHook> = (params) =>
+  {= onBeforeLoginHook.importIdentifier =}({
+    prisma,
+    ...params,
+  })
+{=/ onBeforeLoginHook.isDefined =}
+{=^ onBeforeLoginHook.isDefined =}
+/**
+ * This is a no-op function since the user didn't define the onBeforeLogin hook.
+ */
+export const onBeforeLoginHook: InternalFunctionForHook<OnBeforeLoginHook> = async (_params) => {}
+{=/ onBeforeLoginHook.isDefined =}
+
+{=# onAfterLoginHook.isDefined =}
+export const onAfterLoginHook: InternalFunctionForHook<OnAfterLoginHook> = (params) =>
+  {= onAfterLoginHook.importIdentifier =}({
+    prisma,
+    ...params,
+  })
+{=/ onAfterLoginHook.isDefined =}
+{=^ onAfterLoginHook.isDefined =}
+/**
+ * This is a no-op function since the user didn't define the onAfterLogin hook.
+ */
+export const onAfterLoginHook: InternalFunctionForHook<OnAfterLoginHook> = async (_params) => {}
+{=/ onAfterLoginHook.isDefined =}
+
+/*
+  We pass extra params to the user defined hook functions, but we don't want to
+  pass the extra params (e.g. 'prisma') when we call the hooks in the server code.
+  So, we need to remove the extra params from the params object which is used to define the
+  internal hook functions.
+*/
+type InternalFunctionForHook<Fn extends (args: never) => unknown | Promise<unknown>> = Fn extends (
+  params: infer P,
+) => infer R
+  ? (args: Omit<P, keyof InternalAuthHookParams>) => R
+  : never

package/data/Generator/templates/server/src/auth/providers/config/discord.ts

@@ -0,0 +1,69 @@
+{{={= =}=}}
+
+import type { ProviderConfig } from "wasp/auth/providers/types";
+import { discord } from "wasp/server/auth";
+import { mergeDefaultAndUserConfig } from "../oauth/config.js";
+import { createOAuthProviderRouter } from "../oauth/handler.js";
+
+{=# userSignupFields.isDefined =}
+{=& userSignupFields.importStatement =}
+const _waspUserSignupFields = {= userSignupFields.importIdentifier =}
+{=/ userSignupFields.isDefined =}
+{=^ userSignupFields.isDefined =}
+const _waspUserSignupFields = undefined
+{=/ userSignupFields.isDefined =}
+{=# configFn.isDefined =}
+{=& configFn.importStatement =}
+const _waspUserDefinedConfigFn = {= configFn.importIdentifier =}
+{=/ configFn.isDefined =}
+{=^ configFn.isDefined =}
+const _waspUserDefinedConfigFn = undefined
+{=/ configFn.isDefined =}
+
+const _waspConfig: ProviderConfig = {
+    id: discord.id,
+    displayName: discord.displayName,
+    createRouter(provider) {
+        const config = mergeDefaultAndUserConfig({
+            scopes: {=& requiredScopes =},
+        }, _waspUserDefinedConfigFn);
+
+        async function getDiscordProfile(accessToken: string): Promise<{
+            providerProfile: unknown;
+            providerUserId: string;
+        }> {
+            const response = await fetch("https://discord.com/api/users/@me", {
+              headers: {
+                Authorization: `Bearer ${accessToken}`,
+              },
+            });
+            const providerProfile = (await response.json()) as {
+                id?: string;
+                email?: string;
+                global_name?: string;
+                avatar?: string;
+            };
+            
+            if (!providerProfile.id) {
+               throw new Error("Invalid profile");
+            }
+
+            if (providerProfile.avatar) {
+              providerProfile.avatar = `https://cdn.discordapp.com/avatars/${providerProfile.id}/${providerProfile.avatar}.png`;
+            }
+            
+            return { providerProfile, providerUserId: providerProfile.id };
+        }
+
+        return createOAuthProviderRouter({
+            provider,
+            oAuthType: 'OAuth2',
+            userSignupFields: _waspUserSignupFields,
+            getAuthorizationUrl: ({ state }) => discord.oAuthClient.createAuthorizationURL(state, config),
+            getProviderTokens: ({ code }) => discord.oAuthClient.validateAuthorizationCode(code),
+            getProviderInfo: ({ accessToken }) => getDiscordProfile(accessToken),
+        });
+    },
+}
+
+export default _waspConfig;

package/data/Generator/templates/server/src/auth/providers/config/email.ts

@@ -0,0 +1,96 @@
+{{={= =}=}}
+import { Router } from "express";
+
+import { ProviderConfig } from "wasp/auth/providers/types";
+import type { EmailFromField } from "wasp/server/email/core/types";
+
+import { getLoginRoute } from "../email/login.js";
+import { getSignupRoute } from "../email/signup.js";
+import { getRequestPasswordResetRoute } from "../email/requestPasswordReset.js";
+import { resetPassword } from "../email/resetPassword.js";
+import { verifyEmail } from "../email/verifyEmail.js";
+import { GetVerificationEmailContentFn, GetPasswordResetEmailContentFn } from "wasp/server/auth/email";
+import { defineHandler } from "wasp/server/utils";
+import { env } from "wasp/server";
+
+{=# userSignupFields.isDefined =}
+{=& userSignupFields.importStatement =}
+const _waspUserSignupFields = {= userSignupFields.importIdentifier =}
+{=/ userSignupFields.isDefined =}
+{=^ userSignupFields.isDefined =}
+const _waspUserSignupFields = undefined
+{=/ userSignupFields.isDefined =}
+
+{=# getVerificationEmailContent.isDefined =}
+{=& getVerificationEmailContent.importStatement =}
+const _waspGetVerificationEmailContent: GetVerificationEmailContentFn = {= getVerificationEmailContent.importIdentifier =};
+{=/ getVerificationEmailContent.isDefined =}
+{=# getPasswordResetEmailContent.isDefined =}
+{=& getPasswordResetEmailContent.importStatement =}
+const _waspGetPasswordResetEmailContent: GetPasswordResetEmailContentFn = {= getPasswordResetEmailContent.importIdentifier =};
+{=/ getPasswordResetEmailContent.isDefined =}
+
+{=^ getVerificationEmailContent.isDefined =}
+const _waspGetVerificationEmailContent: GetVerificationEmailContentFn = ({ verificationLink }) => ({
+    subject: 'Verify your email',
+    text: `Click the link below to verify your email: ${verificationLink}`,
+    html: `
+        <p>Click the link below to verify your email</p>
+        <a href="${verificationLink}">Verify email</a>
+    `,
+});
+{=/ getVerificationEmailContent.isDefined =}
+{=^ getPasswordResetEmailContent.isDefined =}
+const _waspGetPasswordResetEmailContent: GetPasswordResetEmailContentFn = ({ passwordResetLink }) => ({
+    subject: 'Reset your password',
+    text: `Click the link below to reset your password: ${passwordResetLink}`,
+    html: `
+        <p>Click the link below to reset your password</p>
+        <a href="${passwordResetLink}">Reset password</a>
+    `,
+});
+{=/ getPasswordResetEmailContent.isDefined =}
+
+const fromField: EmailFromField = {
+    name: '{= fromField.name =}',
+    email: '{= fromField.email =}',
+};
+
+const config: ProviderConfig = {
+    id: "{= providerId =}",
+    displayName: "{= displayName =}",
+    createRouter() {
+        const router = Router();
+
+        const loginRoute = defineHandler(getLoginRoute());
+        router.post('/login', loginRoute);
+
+        const signupRoute = defineHandler(getSignupRoute({
+            userSignupFields: _waspUserSignupFields,
+            fromField,
+            clientRoute: '{= emailVerificationClientRoute =}',
+            getVerificationEmailContent: _waspGetVerificationEmailContent,
+            {=# isDevelopment =}
+            isEmailAutoVerified: env.SKIP_EMAIL_VERIFICATION_IN_DEV,
+            {=/ isDevelopment =}
+            {=^ isDevelopment =}
+            isEmailAutoVerified: false,
+            {=/ isDevelopment =}
+        }));
+        router.post('/signup', signupRoute);
+
+        const requestPasswordResetRoute = defineHandler(getRequestPasswordResetRoute({
+            fromField,
+            clientRoute: '{= passwordResetClientRoute =}',
+            getPasswordResetEmailContent: _waspGetPasswordResetEmailContent,
+        }));
+        router.post('/request-password-reset', requestPasswordResetRoute);
+
+        router.post('/reset-password', defineHandler(resetPassword));
+        router.post('/verify-email', defineHandler(verifyEmail));
+
+        return router;
+    },
+}
+
+export default config;

package/data/Generator/templates/server/src/auth/providers/config/github.ts

@@ -0,0 +1,78 @@
+{{={= =}=}}
+
+import type { ProviderConfig } from "wasp/auth/providers/types";
+import { github } from "wasp/server/auth";
+import { mergeDefaultAndUserConfig } from "../oauth/config.js";
+import { createOAuthProviderRouter } from "../oauth/handler.js";
+
+{=# userSignupFields.isDefined =}
+{=& userSignupFields.importStatement =}
+const _waspUserSignupFields = {= userSignupFields.importIdentifier =}
+{=/ userSignupFields.isDefined =}
+{=^ userSignupFields.isDefined =}
+const _waspUserSignupFields = undefined
+{=/ userSignupFields.isDefined =}
+{=# configFn.isDefined =}
+{=& configFn.importStatement =}
+const _waspUserDefinedConfigFn = {= configFn.importIdentifier =}
+{=/ configFn.isDefined =}
+{=^ configFn.isDefined =}
+const _waspUserDefinedConfigFn = undefined
+{=/ configFn.isDefined =}
+
+const _waspConfig: ProviderConfig = {
+    id: github.id,
+    displayName: github.displayName,
+    createRouter(provider) {
+        const config = mergeDefaultAndUserConfig({
+            scopes: {=& requiredScopes =},
+        }, _waspUserDefinedConfigFn);
+
+        async function getGithubProfile(accessToken: string): Promise<{
+            providerProfile: unknown;
+            providerUserId: string;
+        }> {
+            const response = await fetch("https://api.github.com/user", {
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            const providerProfile = (await response.json()) as {
+                id?: string;
+                emails?: unknown[];
+            };
+            
+            if (!providerProfile.id) {
+               throw new Error("Invalid profile");
+            }
+
+            const scopes = config.scopes as string[];
+            // Using the logic from https://github.com/cfsghost/passport-github/blob/master/lib/strategy.js#L118C24-L120C10
+            const isEmailAccessAllowed = scopes.some((scope) => {
+                return scope === 'user' || scope === 'user:email';
+            });
+            if (isEmailAccessAllowed) {
+                const emailsResponse = await fetch("https://api.github.com/user/emails", {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                });
+                const emails = (await emailsResponse.json()) as unknown[];
+                providerProfile.emails = emails;
+            }
+
+            return { providerProfile, providerUserId: `${providerProfile.id}` };
+        }
+
+        return createOAuthProviderRouter({
+            provider,
+            oAuthType: 'OAuth2',
+            userSignupFields: _waspUserSignupFields,
+            getAuthorizationUrl: ({ state }) => github.oAuthClient.createAuthorizationURL(state, config),
+            getProviderTokens: ({ code }) => github.oAuthClient.validateAuthorizationCode(code),
+            getProviderInfo: ({ accessToken }) => getGithubProfile(accessToken),
+        });
+    },
+}
+
+export default _waspConfig;

package/data/Generator/templates/server/src/auth/providers/config/google.ts

@@ -0,0 +1,65 @@
+{{={= =}=}}
+import type { ProviderConfig } from "wasp/auth/providers/types";
+import { google } from "wasp/server/auth";
+
+import { mergeDefaultAndUserConfig } from "../oauth/config.js";
+import { createOAuthProviderRouter } from "../oauth/handler.js";
+
+{=# userSignupFields.isDefined =}
+{=& userSignupFields.importStatement =}
+const _waspUserSignupFields = {= userSignupFields.importIdentifier =}
+{=/ userSignupFields.isDefined =}
+{=^ userSignupFields.isDefined =}
+const _waspUserSignupFields = undefined
+{=/ userSignupFields.isDefined =}
+{=# configFn.isDefined =}
+{=& configFn.importStatement =}
+const _waspUserDefinedConfigFn = {= configFn.importIdentifier =}
+{=/ configFn.isDefined =}
+{=^ configFn.isDefined =}
+const _waspUserDefinedConfigFn = undefined
+{=/ configFn.isDefined =}
+
+const _waspConfig: ProviderConfig = {
+    id: google.id,
+    displayName: google.displayName,
+    createRouter(provider) {
+        const config = mergeDefaultAndUserConfig({
+            scopes: {=& requiredScopes =},
+        }, _waspUserDefinedConfigFn);
+
+        async function getGoogleProfile(accessToken: string): Promise<{
+            providerProfile: unknown;
+            providerUserId: string;
+        }> {
+            const response = await fetch(
+                "https://openidconnect.googleapis.com/v1/userinfo",
+                {
+                    headers: {
+                        Authorization: `Bearer ${accessToken}`,
+                    },
+                }
+            );
+            const providerProfile = (await response.json()) as {
+                sub?: string;
+            };
+        
+            if (!providerProfile.sub) {
+                throw new Error("Invalid profile");
+            }
+
+            return { providerProfile, providerUserId: providerProfile.sub };
+        }
+
+        return createOAuthProviderRouter({
+            provider,
+            oAuthType: 'OAuth2WithPKCE',
+            userSignupFields: _waspUserSignupFields,
+            getAuthorizationUrl: ({ state, codeVerifier }) => google.oAuthClient.createAuthorizationURL(state, codeVerifier, config),
+            getProviderTokens: ({ code, codeVerifier }) => google.oAuthClient.validateAuthorizationCode(code, codeVerifier),
+            getProviderInfo: ({ accessToken }) => getGoogleProfile(accessToken),
+        });
+    },
+}
+
+export default _waspConfig;