ThirdParty.init({
          signInAndUpFeature: {
            providers: [
              ThirdParty.Google({
                clientId:
                  'SOMECLIENTID',
                clientSecret: 'SOMECLIENTSECRET',
                authorisationRedirect: {
                  params: {
                    redirect_uri:
                      'http://localhost/auth/callback/social/google',
                  },
                },
              }),
            ],
          },
          override: {
            apis: (oI) => {
              return {
                ...oI,
                signInUpPOST: async function (input) {
                  if (oI.signInUpPOST === undefined) {
                    throw Error('Should never come here');
                  }
                  try {
                    await oI.signInUpPOST(input);
                  } catch (err) {
                    console.log(err);
                  }
                  let resp = await oI.signInUpPOST(input);
                  if (resp.status === 'OK') {
                    if (resp.createdNewUser) {
                      let googleAccessToken =
                        resp.authCodeResponse['access_token'];
                      let user = resp.user;
                      let session = resp.session;

                      const hexPerm = pm.createPermissionAttribute(
                        Permissions.CREATE_LINK,
                        Permissions.EDIT_LINK,
                      );

                      const newUser = await this.prisma.user.create({
                        data: {
                          uid: 'TEST',
                          email: user.email.toLowerCase(),
                          username: user.email.toLowerCase(),
                          permissions: hexPerm,
                        },
                      });

                      // TODO: store info about the user in your own db

                      // TODO: You can modify the access token payload like this:
                      await session.updateAccessTokenPayload({
                        perms: newUser.permissions,
                      });
                    }
                  }
                  return resp;
                },
              };
            },
          },
        }),

http://localhost/auth/callback/social/google

await http.post('/auth/signinup', {
            redirectURI: 'http://localhost/auth/callback/social/google',
            thirdPartyId: 'google',
            code: `${code}`
        });

await http.get('/auth/authorisationurl?thirdPartyId=google').then((res) => {
            if(res.data.status === 'OK') {
                goto(res.data.url);
                // console.log(res.data);
        }
        });

redirect_uri=...

oI.signInUpPOST(input)

ThirdParty.Google({
                clientId:
                  'SOMECLIENTID',
                clientSecret: 'SOMECLIENTSECRET',
                authorisationRedirect: {
                  params: {
                    redirect_uri:
                      'http://localhost/auth/callback/social/google',
                  },
                },
              }),

googleUrl

frontend/src/routes/auth/callback/social/google.svelte

code

/auth/signinup

if (typeof window !== "undefined") {
    ...
    // Read code
    // Call sign in up API here
    ...
}

<script lang="ts">
import { goto } from '$app/navigation';

    import { page } from '$app/stores';
    import { http } from '../../../../util/http';

    
    if (typeof window !== "undefined") {

    const code = $page.url.searchParams.get('code');

    console.log("OG CODE", code)
    if (typeof window !== "undefined") {
        console.log("WI CODE", (new URL(window.location)).searchParams.get("code"))
    }

    (async () => {
        await http.post('/auth/signinup', {
            redirectURI: 'http://localhost:8080/auth/callback/social/google',
            thirdPartyId: 'google',
            code: `${code}`
        });
    })().catch((err) => {
        // console.error(err);
    });
    }
</script>

authorisationRedirect: { redirect_uri }

rid

const googleUrl = await http.get('/auth/authorisationurl?thirdPartyId=google');

ts
ThirdParty.Google({
    clientId: 'ID',
    clientSecret: 'SECRET',
    authorisationRedirect: {
        params: {
            redirect_uri: 'http://localhost:8080/auth/callback/social/google'
        }
    }
}),

goto(googleUrl.data.url) // redirect straight to url provided from our API

ts
<script lang="ts">
    import { browser } from '$app/env';
    import { page } from '$app/stores';
    import { http } from '../../../../util/http';

    if (browser) {
        const code = $page.url.searchParams.get('code');
        http.post(`/auth/signinup`, {
            redirectURI: 'http://localhost:8080/auth/callback/social/google',
            thirdPartyId: 'google',
            code
        }, {
            headers: {
                rid: 'thirdparty'
            }
        });
    }
</script>

if (browser)

// __layout.svelte
// The combination of a load function, within a module script, within a layout component, means that this function will be the very first thing to run when the user navigates to any page on the website, and it will be run once only
<script context="module" lang="ts">
    import SuperTokens from 'supertokens-website';
    import { browser } from '$app/env';
    import type { LoadEvent } from '@sveltejs/kit';

  export async function load({}: LoadEvent) {
    if (browser) {
        SuperTokens.init({
            apiDomain: 'http://localhost:3000', 
            apiBasePath: '/auth', 
            enableDebugLogs: true, 
            autoAddCredentials: true
        });
  
        console.log("----------- SUPERTOKENS INITIALISED ---------------")

        if (SuperTokens.doesSessionExist()) {
            // Session cookies exist, try refreshing tokens?
        } else {
          // redirect to login?
        }
    }
    return {};
  }
</script><main><slot /></main>