effect/github

Classes

GitHubOAuthAPI

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:67^

Provides GitHub OAuth authentication effects for the StudioCMS API.

This service handles the OAuth flow with GitHub, including:

• Initializing the OAuth session and redirecting users to GitHub for authorization.
• Validating the authorization code returned by GitHub and fetching user data.
• Handling the callback from GitHub, including:
  • Linking OAuth accounts to existing users.
  • Creating new users from GitHub profile data.
  • Verifying user email addresses.
  • Creating user sessions and redirecting to appropriate pages.

Remarks

• Depends on session management, user library, email verification, and SDK core services.
• Handles both first-time setup and linking additional OAuth providers to existing accounts.

Example

const githubOAuth = new GitHubOAuthAPI();
yield* githubOAuth.initSession(context);
yield* githubOAuth.initCallback(context);

See

• Session
• SDKCore
• VerifyEmail
• User

Extends

• { initCallback: (context: APIContext) => Effect<Response, Error | SDKCoreError, never>; initSession: (context: APIContext) => Effect<Response, SessionError, never>; } & { _tag: "GitHubOAuthAPI"; }

Constructors

Constructor

new GitHubOAuthAPI(_: {
  initCallback: (context: APIContext) => Effect<Response, Error | SDKCoreError, never>;
  initSession: (context: APIContext) => Effect<Response, SessionError, never>;
}): GitHubOAuthAPI;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:26559

Parameters

_

initCallback

(context: APIContext) => Effect<Response, Error | SDKCoreError, never> = ...

initSession

(context: APIContext) => Effect<Response, SessionError, never> = ...

Returns

GitHubOAuthAPI

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).constructor

Properties

_tag

readonly _tag: "GitHubOAuthAPI";

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:26560

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
})._tag

initCallback()

initCallback: (context: APIContext) => Effect<Response, Error | SDKCoreError, never>;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:117^

Parameters

context

APIContext

Returns

Effect<Response, Error | SDKCoreError, never>

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).initCallback

initSession()

initSession: (context: APIContext) => Effect<Response, SessionError, never>;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:106^

Parameters

context

APIContext

Returns

Effect<Response, SessionError, never>

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).initSession

_op

readonly static _op: "Tag";

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:28

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
})._op

[ChannelTypeId]

readonly static [ChannelTypeId]: VarianceStruct<never, unknown, never, unknown, GitHubOAuthAPI, unknown, GitHubOAuthAPI>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Channel.d.ts:108

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[ChannelTypeId]

[EffectTypeId]

readonly static [EffectTypeId]: VarianceStruct<GitHubOAuthAPI, never, GitHubOAuthAPI>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:195

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[EffectTypeId]

[ignoreSymbol]?

static optional [ignoreSymbol]: TagUnifyIgnore;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:41

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[ignoreSymbol]

[SinkTypeId]

readonly static [SinkTypeId]: VarianceStruct<GitHubOAuthAPI, unknown, never, never, GitHubOAuthAPI>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Sink.d.ts:82

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[SinkTypeId]

[STMTypeId]

readonly static [STMTypeId]: {
  _A: Covariant<GitHubOAuthAPI>;
  _E: Covariant<never>;
  _R: Covariant<GitHubOAuthAPI>;
};

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/STM.d.ts:136

_A

readonly _A: Covariant<GitHubOAuthAPI>;

_E

readonly _E: Covariant<never>;

_R

readonly _R: Covariant<GitHubOAuthAPI>;

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[STMTypeId]

[StreamTypeId]

readonly static [StreamTypeId]: VarianceStruct<GitHubOAuthAPI, never, GitHubOAuthAPI>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Stream.d.ts:111

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[StreamTypeId]

[TagTypeId]

readonly static [TagTypeId]: {
  _Identifier: Invariant<GitHubOAuthAPI>;
  _Service: Invariant<GitHubOAuthAPI>;
};

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:31

_Identifier

readonly _Identifier: Invariant<GitHubOAuthAPI>;

_Service

readonly _Service: Invariant<GitHubOAuthAPI>;

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[TagTypeId]

[typeSymbol]?

static optional [typeSymbol]: unknown;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:39

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[typeSymbol]

[unifySymbol]?

static optional [unifySymbol]: TagUnify<Class<GitHubOAuthAPI, "GitHubOAuthAPI", {
  dependencies: readonly [Layer<VerifyEmail, Error, never>, Layer<HttpClient, never, never>];
  effect: Effect<{
     initCallback: (context: APIContext) => Effect<Response, Error | SDKCoreError, never>;
     initSession: (context: APIContext) => Effect<Response, SessionError, never>;
  }, SessionError | UserError, VerifyEmail | HttpClient>;
}>>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:40

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[unifySymbol]

Default

readonly static Default: Layer<GitHubOAuthAPI, Error | SessionError | UserError, never>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:26570

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).Default

DefaultWithoutDependencies

readonly static DefaultWithoutDependencies: Layer<GitHubOAuthAPI, SessionError | UserError, VerifyEmail | HttpClient>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:26569

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).DefaultWithoutDependencies

Identifier

readonly static Identifier: GitHubOAuthAPI;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:30

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).Identifier

key

readonly static key: "GitHubOAuthAPI";

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:38

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).key

make()

readonly static make: (_: {
  initCallback: (context: APIContext) => Effect<Response, Error | SDKCoreError, never>;
  initSession: (context: APIContext) => Effect<Response, SessionError, never>;
}) => GitHubOAuthAPI;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:26563

Parameters

_

initCallback

(context: APIContext) => Effect<Response, Error | SDKCoreError, never> = ...

initSession

(context: APIContext) => Effect<Response, SessionError, never> = ...

Returns

GitHubOAuthAPI

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).make

ProviderCookieName

static ProviderCookieName: string = 'github_oauth_state';

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:236^

ProviderID

static ProviderID: string = 'github';

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:235^

Service

readonly static Service: GitHubOAuthAPI;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:29

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).Service

stack?

readonly static optional stack: string;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:37

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).stack

use()

readonly static use: <X>(body: (_: GitHubOAuthAPI) => X) => [X] extends [Effect<A, E, R>] ? Effect<A, E,
  | GitHubOAuthAPI
| R> : [X] extends [PromiseLike<A>] ? Effect<A, UnknownException, GitHubOAuthAPI> : Effect<X, never, GitHubOAuthAPI>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:26562

Type Parameters

X

X

Parameters

body

(_: GitHubOAuthAPI) => X

Returns

[X] extends [Effect<A, E, R>] ? Effect<A, E, | GitHubOAuthAPI | R> : [X] extends [PromiseLike<A>] ? Effect<A, UnknownException, GitHubOAuthAPI> : Effect<X, never, GitHubOAuthAPI>

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).use

Methods

[iterator]()

static iterator: EffectGenerator<Tag<GitHubOAuthAPI, GitHubOAuthAPI>>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Effect.d.ts:137

Returns

EffectGenerator<Tag<GitHubOAuthAPI, GitHubOAuthAPI>>

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[iterator]

[NodeInspectSymbol]()

static NodeInspectSymbol: unknown;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Inspectable.d.ts:22

Returns

unknown

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).[NodeInspectSymbol]

context()

static context(self: GitHubOAuthAPI): Context<GitHubOAuthAPI>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:36

Parameters

self

GitHubOAuthAPI

Returns

Context<GitHubOAuthAPI>

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).context

of()

static of(self: GitHubOAuthAPI): GitHubOAuthAPI;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Context.d.ts:35

Parameters

self

GitHubOAuthAPI

Returns

GitHubOAuthAPI

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).of

pipe()

Call Signature

static pipe<A>(this: A): A;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:10

Type Parameters

A

A

Parameters

this

A

Returns

A

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B>(this: A, ab: (_: A) => B): B;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:11

Type Parameters

A

A

B

B = never

Parameters

this

A

ab

(_: A) => B

Returns

B

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C): C;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:12

Type Parameters

A

A

B

B = never

C

C = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

Returns

C

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D): D;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:13

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

Returns

D

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E): E;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:14

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

Returns

E

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F): F;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:15

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

Returns

F

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G): G;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:16

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

Returns

G

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H): H;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:17

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

Returns

H

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I): I;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:18

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

Returns

I

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J): J;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:19

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

Returns

J

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K): K;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:20

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

Returns

K

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L): L;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:21

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

Returns

L

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M): M;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:22

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

Returns

M

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N): N;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:23

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

Returns

N

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O): O;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:24

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

Returns

O

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P): P;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:25

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

Returns

P

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q): Q;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:26

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

Returns

Q

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R): R;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:27

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

Returns

R

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S): S;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:28

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

Returns

S

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S,
   st: (_: S) => T): T;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:29

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

T

T = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

st

(_: S) => T

Returns

T

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S,
   st: (_: S) => T,
   tu: (_: T) => U): U;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:30

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

T

T = never

U

U = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

st

(_: S) => T

tu

(_: T) => U

Returns

U

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S,
   st: (_: S) => T,
   tu: (_: T) => U): U;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:31

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

T

T = never

U

U = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

st

(_: S) => T

tu

(_: T) => U

Returns

U

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).pipe

toJSON()

static toJSON(): unknown;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Inspectable.d.ts:21

Returns

unknown

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).toJSON

toString()

static toString(): string;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Inspectable.d.ts:20

Returns

string

Inherited from

Effect.Service<GitHubOAuthAPI>()('GitHubOAuthAPI', {
  dependencies: [VerifyEmail.Default, Platform.FetchHttpClient.layer],
  effect: genLogger('studiocms/routes/api/auth/github/effect')(function () {
    const [
      sdk,
      fetchClient,
      { setOAuthSessionTokenCookie, createUserSession },
      { isEmailVerified, sendVerificationEmail },
      { getUserData, createOAuthUser },
    ] = yield Effect.all([SDKCore, Platform.HttpClient.HttpClient, Session, VerifyEmail, User]);

    const { CLIENT_ID, CLIENT_SECRET, REDIRECT_URI } = GITHUB;

    const github = new GitHub(CLIENT_ID, CLIENT_SECRET, REDIRECT_URI);

    const validateAuthCode = (code: string) =>
      genLogger('studiocms/routes/api/auth/github/effect.validateAuthCode')(function () {
        const tokens = yield Effect.tryPromise(() => github.validateAuthorizationCode(code));

        return yield fetchClient
          .get('https://api.github.com/user', {
            headers: {
              Authorization: Bearer ${tokens.accessToken},
            },
          })
          .pipe(
            Effect.flatMap(Platform.HttpClientResponse.schemaBodyJson(GitHubUser)),
            Effect.catchAll((error) =>
              Effect.fail(
                new ValidateAuthCodeError({
                  provider: GitHubOAuthAPI.ProviderID,
                  message: Failed to fetch user info: ${error.message},
                })
              )
            )
          );
      });

    return {
      initSession: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initSession')(function () {
          const state = generateState();
          const scopes = ['user:email', 'repo'];

          const url = github.createAuthorizationURL(state, scopes);

          yield setOAuthSessionTokenCookie(context, GitHubOAuthAPI.ProviderCookieName, state);

          return context.redirect(url.toString());
        }),
      initCallback: (context: APIContext) =>
        genLogger('studiocms/routes/api/auth/github/effect.initCallback')(function () {
          const { cookies, redirect } = context;

          const [code, state, storedState] = yield Effect.all([
            getUrlParam(context, 'code'),
            getUrlParam(context, 'state'),
            getCookie(context, GitHubOAuthAPI.ProviderCookieName),
          ]);

          if (!code || !state || !storedState || state !== storedState) {
            return redirect(StudioCMSRoutes.authLinks.loginURL);
          }

          const githubUser = yield validateAuthCode(code);

          const { id: githubUserId, login: githubUsername } = githubUser;

          const existingOAuthAccount = yield sdk.AUTH.oAuth.searchProvidersForId(
            GitHubOAuthAPI.ProviderID,
            ${githubUserId}
          );

          if (existingOAuthAccount) {
            const user = yield sdk.GET.users.byId(existingOAuthAccount.userId);

            if (!user) {
              return new Response('User not found', { status: 404 });
            }

            const isEmailAccountVerified = yield isEmailVerified(user);

            // If Mailer is enabled, is the user verified?
            if (!isEmailAccountVerified) {
              return new Response('Email not verified, please verify your account first.', {
                status: 400,
              });
            }

            yield createUserSession(user.id, context);

            return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
          }

          const loggedInUser = yield getUserData(context);
          const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;

          if (loggedInUser.user && linkNewOAuth) {
            const existingUser = yield sdk.GET.users.byId(loggedInUser.user.id);

            if (existingUser) {
              yield sdk.AUTH.oAuth.create({
                userId: existingUser.id,
                provider: GitHubOAuthAPI.ProviderID,
                providerUserId: ${githubUserId},
              });

              const isEmailAccountVerified = yield isEmailVerified(existingUser);

              // If Mailer is enabled, is the user verified?
              if (!isEmailAccountVerified) {
                return new Response('Email not verified, please verify your account first.', {
                  status: 400,
                });
              }

              yield createUserSession(existingUser.id, context);

              return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
            }
          }

          const newUser = yield createOAuthUser(
            {
              id: crypto.randomUUID(),
              username: githubUsername,
              email: githubUser.email || null,
              name: githubUser.name || githubUsername,
              avatar: githubUser.avatar_url,
              createdAt: new Date(),
              url: githubUser.blog || null,
              emailVerified: false,
              notifications: null,
              password: null,
              updatedAt: new Date(),
            },
            { provider: GitHubOAuthAPI.ProviderID, providerUserId: ${githubUserId} }
          );

          if ('error' in newUser) {
            return new Response('Error creating user', { status: 500 });
          }

          // FIRST-TIME-SETUP
          if (config.dbStartPage) {
            return redirect('/done');
          }

          yield sendVerificationEmail(newUser.id, true);

          const existingUser = yield sdk.GET.users.byId(newUser.id);

          const isEmailAccountVerified = yield isEmailVerified(existingUser);

          // If Mailer is enabled, is the user verified?
          if (!isEmailAccountVerified) {
            return new Response('Email not verified, please verify your account first.', {
              status: 400,
            });
          }

          yield createUserSession(newUser.id, context);

          return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
        }),
    };
  }),
}).toString

---

GitHubUser

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:23^

Represents a GitHub user profile as returned by the GitHub API.

Extends

• { id: number; } & { html_url: string; } & { login: string; } & { avatar_url: string; } & { name?: string; } & { blog?: string; } & { email?: string; }

Constructors

Constructor

new GitHubUser(props: {
  avatar_url: string;
  blog?: string;
  email?: string;
  html_url: string;
  id: number;
  login: string;
  name?: string;
}, options?: MakeOptions): GitHubUser;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4265

Parameters

props

avatar_url

string = Schema.String

blog?

string = ...

email?

string = ...

html_url

string = Schema.String

id

number = Schema.Number

login

string = Schema.String

name?

string = ...

options?

MakeOptions

Returns

GitHubUser

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).constructor

Properties

avatar_url

readonly avatar_url: string = Schema.String;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:27^

The URL to the user’s avatar image.

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).avatar_url

blog?

readonly optional blog: string;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:29^

The user’s blog URL.

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).blog

email?

readonly optional email: string;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:30^

The user’s public email address.

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).email

html_url

readonly html_url: string = Schema.String;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:25^

The URL to the user’s GitHub profile.

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).html_url

id

readonly id: number = Schema.Number;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:24^

The unique identifier for the user.

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).id

login

readonly login: string = Schema.String;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:26^

The user’s GitHub username.

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).login

name?

readonly optional name: string;

Defined in: studiocms/packages/@studiocms/github/src/effect/github.ts:28^

The user’s display name.

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).name

[TypeId]

readonly static [TypeId]: {
  _A: Invariant<GitHubUser>;
  _I: Invariant<{
     avatar_url: string;
     blog?: string;
     email?: string;
     html_url: string;
     id: number;
     login: string;
     name?: string;
  }>;
  _R: Covariant<never>;
};

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:160

_A

readonly _A: Invariant<GitHubUser>;

_I

readonly _I: Invariant<{
  avatar_url: string;
  blog?: string;
  email?: string;
  html_url: string;
  id: number;
  login: string;
  name?: string;
}>;

_R

readonly _R: Covariant<never>;

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).[TypeId]

ast

readonly static ast: Transformation;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4267

Since

3.10.0

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).ast

Context

readonly static Context: never;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:63

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).Context

Encoded

readonly static Encoded: {
  avatar_url: string;
  blog?: string;
  email?: string;
  html_url: string;
  id: number;
  login: string;
  name?: string;
};

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:62

avatar_url

avatar_url: string;

blog?

optional blog: string;

email?

optional email: string;

html_url

html_url: string;

id

id: number;

login

login: string;

name?

optional name: string;

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).Encoded

fields

readonly static fields: {
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
};

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4270

avatar_url

readonly avatar_url: typeof String$ = Schema.String;

blog

readonly blog: optional<typeof String$>;

email

readonly email: optional<typeof String$>;

html_url

readonly html_url: typeof String$ = Schema.String;

id

readonly id: typeof Number$ = Schema.Number;

login

readonly login: typeof String$ = Schema.String;

name

readonly name: optional<typeof String$>;

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).fields

identifier

readonly static identifier: string;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4273

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).identifier

Type

readonly static Type: GitHubUser;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:61

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).Type

Methods

annotations()

static annotations(annotations: Schema<GitHubUser>): SchemaClass<GitHubUser, {
  avatar_url: string;
  blog?: string;
  email?: string;
  html_url: string;
  id: number;
  login: string;
  name?: string;
}, never>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4269

Merges a set of new annotations with existing ones, potentially overwriting any duplicates.

Parameters

annotations

Schema<GitHubUser>

Returns

SchemaClass<GitHubUser, { avatar_url: string; blog?: string; email?: string; html_url: string; id: number; login: string; name?: string; }, never>

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).annotations

extend()

static extend<Extended>(identifier: string): <NewFields>(fields: NewFields | HasFields<NewFields>, annotations?: ClassAnnotations<Extended, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>) => [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`" : Class<Extended, {
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
} & NewFields, {
  avatar_url: string;
  html_url: string;
  id: number;
  login: string;
} & {
  blog?: string;
  email?: string;
  name?: string;
} & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]> }, Context<NewFields[keyof NewFields]>, {
  id: number;
} & {
  html_url: string;
} & {
  login: string;
} & {
  avatar_url: string;
} & {
  name?: string;
} & {
  blog?: string;
} & {
  email?: string;
} & Constructor<NewFields>, GitHubUser, {
}>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4296

Type Parameters

Extended

Extended = never

Parameters

identifier

string

Returns

<NewFields>(fields: NewFields | HasFields<NewFields>, annotations?: ClassAnnotations<Extended, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>): [Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`" : Class<Extended, {
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
} & NewFields, {
  avatar_url: string;
  html_url: string;
  id: number;
  login: string;
} & {
  blog?: string;
  email?: string;
  name?: string;
} & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]> }, Context<NewFields[keyof NewFields]>, {
  id: number;
} & {
  html_url: string;
} & {
  login: string;
} & {
  avatar_url: string;
} & {
  name?: string;
} & {
  blog?: string;
} & {
  email?: string;
} & Constructor<NewFields>, GitHubUser, {
}>;

Type Parameters

NewFields

NewFields extends Fields

Parameters

fields

NewFields | HasFields<NewFields>

annotations?

ClassAnnotations<Extended, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>

Returns

[Extended] extends [never] ? "Missing `Self` generic - use `class Self extends Base.extend<Self>()({ ... })`" : Class<Extended, { avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$>; } & NewFields, { avatar_url: string; html_url: string; id: number; login: string; } & { blog?: string; email?: string; name?: string; } & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]> }, Context<NewFields[keyof NewFields]>, { id: number; } & { html_url: string; } & { login: string; } & { avatar_url: string; } & { name?: string; } & { blog?: string; } & { email?: string; } & Constructor<NewFields>, GitHubUser, { }>

Example

import { Schema } from "effect"

class MyClass extends Schema.Class<MyClass>("MyClass")({
 myField: Schema.String
}) {
 myMethod() {
   return this.myField + "my"
 }
}

class NextClass extends MyClass.extend<NextClass>("NextClass")({
 nextField: Schema.Number
}) {
 nextMethod() {
   return this.myMethod() + this.myField + this.nextField
 }
}

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).extend

make()

static make<C>(this: C, ...args: ConstructorParameters<C>): InstanceType<C>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4268

Type Parameters

C

C extends (…args: any[]) => any

Parameters

this

C

args

…ConstructorParameters<C>

Returns

InstanceType<C>

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).make

pipe()

Call Signature

static pipe<A>(this: A): A;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:10

Type Parameters

A

A

Parameters

this

A

Returns

A

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B>(this: A, ab: (_: A) => B): B;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:11

Type Parameters

A

A

B

B = never

Parameters

this

A

ab

(_: A) => B

Returns

B

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C): C;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:12

Type Parameters

A

A

B

B = never

C

C = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

Returns

C

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D): D;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:13

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

Returns

D

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E): E;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:14

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

Returns

E

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F): F;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:15

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

Returns

F

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G): G;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:16

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

Returns

G

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H): H;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:17

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

Returns

H

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I): I;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:18

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

Returns

I

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J): J;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:19

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

Returns

J

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K): K;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:20

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

Returns

K

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L): L;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:21

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

Returns

L

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M): M;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:22

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

Returns

M

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N): N;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:23

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

Returns

N

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O): O;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:24

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

Returns

O

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P): P;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:25

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

Returns

P

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q): Q;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:26

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

Returns

Q

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R): R;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:27

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

Returns

R

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S): S;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:28

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

Returns

S

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S,
   st: (_: S) => T): T;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:29

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

T

T = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

st

(_: S) => T

Returns

T

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S,
   st: (_: S) => T,
   tu: (_: T) => U): U;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:30

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

T

T = never

U

U = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

st

(_: S) => T

tu

(_: T) => U

Returns

U

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

Call Signature

static pipe<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(
   this: A,
   ab: (_: A) => B,
   bc: (_: B) => C,
   cd: (_: C) => D,
   de: (_: D) => E,
   ef: (_: E) => F,
   fg: (_: F) => G,
   gh: (_: G) => H,
   hi: (_: H) => I,
   ij: (_: I) => J,
   jk: (_: J) => K,
   kl: (_: K) => L,
   lm: (_: L) => M,
   mn: (_: M) => N,
   no: (_: N) => O,
   op: (_: O) => P,
   pq: (_: P) => Q,
   qr: (_: Q) => R,
   rs: (_: R) => S,
   st: (_: S) => T,
   tu: (_: T) => U): U;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Pipeable.d.ts:31

Type Parameters

A

A

B

B = never

C

C = never

D

D = never

E

E = never

F

F = never

G

G = never

H

H = never

I

I = never

J

J = never

K

K = never

L

L = never

M

M = never

N

N = never

O

O = never

P

P = never

Q

Q = never

R

R = never

S

S = never

T

T = never

U

U = never

Parameters

this

A

ab

(_: A) => B

bc

(_: B) => C

cd

(_: C) => D

de

(_: D) => E

ef

(_: E) => F

fg

(_: F) => G

gh

(_: G) => H

hi

(_: H) => I

ij

(_: I) => J

jk

(_: J) => K

kl

(_: K) => L

lm

(_: L) => M

mn

(_: M) => N

no

(_: N) => O

op

(_: O) => P

pq

(_: P) => Q

qr

(_: Q) => R

rs

(_: R) => S

st

(_: S) => T

tu

(_: T) => U

Returns

U

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).pipe

transformOrFail()

static transformOrFail<Transformed>(identifier: string): <NewFields, R2, R3>(fields: NewFields, options: {
  decode: (input: {
     avatar_url: string;
     blog?: string;
     email?: string;
     html_url: string;
     id: number;
     login: string;
     name?: string;
  }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }, ParseIssue, R2>;
  encode: (input: { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }, options: ParseOptions, ast: Transformation) => Effect<{
     id: number;
   } & {
     html_url: string;
   } & {
     login: string;
   } & {
     avatar_url: string;
   } & {
     name?: string;
   } & {
     blog?: string;
   } & {
     email?: string;
  }, ParseIssue, R3>;
}, annotations?: ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>) => [Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`" : Class<Transformed, {
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
} & NewFields, Encoded<{
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
}>, R2 | R3 | Context<NewFields[keyof NewFields]>, {
  id: number;
} & {
  html_url: string;
} & {
  login: string;
} & {
  avatar_url: string;
} & {
  name?: string;
} & {
  blog?: string;
} & {
  email?: string;
} & Constructor<NewFields>, GitHubUser, {
}>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4326

Type Parameters

Transformed

Transformed = never

Parameters

identifier

string

Returns

<NewFields, R2, R3>(
   fields: NewFields,
   options: {
  decode: (input: {
     avatar_url: string;
     blog?: string;
     email?: string;
     html_url: string;
     id: number;
     login: string;
     name?: string;
  }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }, ParseIssue, R2>;
  encode: (input: { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }, options: ParseOptions, ast: Transformation) => Effect<{
     id: number;
   } & {
     html_url: string;
   } & {
     login: string;
   } & {
     avatar_url: string;
   } & {
     name?: string;
   } & {
     blog?: string;
   } & {
     email?: string;
  }, ParseIssue, R3>;
},
   annotations?: ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>): [Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`" : Class<Transformed, {
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
} & NewFields, Encoded<{
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
}>, R2 | R3 | Context<NewFields[keyof NewFields]>, {
  id: number;
} & {
  html_url: string;
} & {
  login: string;
} & {
  avatar_url: string;
} & {
  name?: string;
} & {
  blog?: string;
} & {
  email?: string;
} & Constructor<NewFields>, GitHubUser, {
}>;

Type Parameters

NewFields

NewFields extends Fields

R2

R2

R3

R3

Parameters

fields

NewFields

options

decode

(input: { avatar_url: string; blog?: string; email?: string; html_url: string; id: number; login: string; name?: string; }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }, ParseIssue, R2>

encode

(input: { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }, options: ParseOptions, ast: Transformation) => Effect<{ id: number; } & { html_url: string; } & { login: string; } & { avatar_url: string; } & { name?: string; } & { blog?: string; } & { email?: string; }, ParseIssue, R3>

annotations?

ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>

Returns

[Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFail<Self>()({ ... })`" : Class<Transformed, { avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$>; } & NewFields, Encoded<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$>; }>, R2 | R3 | Context<NewFields[keyof NewFields]>, { id: number; } & { html_url: string; } & { login: string; } & { avatar_url: string; } & { name?: string; } & { blog?: string; } & { email?: string; } & Constructor<NewFields>, GitHubUser, { }>

Example

import { Effect, Schema } from "effect"

class MyClass extends Schema.Class<MyClass>("MyClass")({
  myField: Schema.String
}) {
  myMethod() {
    return this.myField + "my"
  }
}

class NextClass extends MyClass.transformOrFail<NextClass>("NextClass")({
  nextField: Schema.Number
}, {
  decode: (i) =>
    Effect.succeed({
      myField: i.myField,
      nextField: i.myField.length
    }),
  encode: (a) => Effect.succeed({ myField: a.myField })
}) {
  nextMethod() {
    return this.myMethod() + this.myField + this.nextField
  }
}

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).transformOrFail

transformOrFailFrom()

static transformOrFailFrom<Transformed>(identifier: string): <NewFields, R2, R3>(fields: NewFields, options: {
  decode: (input: {
     avatar_url: string;
     blog?: string;
     email?: string;
     html_url: string;
     id: number;
     login: string;
     name?: string;
  }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: ({ avatar_url: string; html_url: string; id: number; login: string } & { blog?: string; email?: string; name?: string } & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<(...)[(...)]> })[K] }, ParseIssue, R2>;
  encode: (input: { [K in string | number | symbol]: ({ avatar_url: string; html_url: string; id: number; login: string } & { blog?: string; email?: string; name?: string } & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]> })[K] }, options: ParseOptions, ast: Transformation) => Effect<Encoded<{
     avatar_url: typeof String$;
     blog: optional<typeof String$>;
     email: optional<typeof String$>;
     html_url: typeof String$;
     id: typeof Number$;
     login: typeof String$;
     name: optional<typeof String$>;
  }>, ParseIssue, R3>;
}, annotations?: ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>) => [Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`" : Class<Transformed, {
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
} & NewFields, Encoded<{
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
}>, R2 | R3 | Context<NewFields[keyof NewFields]>, {
  id: number;
} & {
  html_url: string;
} & {
  login: string;
} & {
  avatar_url: string;
} & {
  name?: string;
} & {
  blog?: string;
} & {
  email?: string;
} & Constructor<NewFields>, GitHubUser, {
}>;

Defined in: node_modules/.pnpm/effect@3.17.14/node_modules/effect/dist/dts/Schema.d.ts:4359

Type Parameters

Transformed

Transformed = never

Parameters

identifier

string

Returns

<NewFields, R2, R3>(
   fields: NewFields,
   options: {
  decode: (input: {
     avatar_url: string;
     blog?: string;
     email?: string;
     html_url: string;
     id: number;
     login: string;
     name?: string;
  }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: ({ avatar_url: string; html_url: string; id: number; login: string } & { blog?: string; email?: string; name?: string } & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<(...)[(...)]> })[K] }, ParseIssue, R2>;
  encode: (input: { [K in string | number | symbol]: ({ avatar_url: string; html_url: string; id: number; login: string } & { blog?: string; email?: string; name?: string } & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]> })[K] }, options: ParseOptions, ast: Transformation) => Effect<Encoded<{
     avatar_url: typeof String$;
     blog: optional<typeof String$>;
     email: optional<typeof String$>;
     html_url: typeof String$;
     id: typeof Number$;
     login: typeof String$;
     name: optional<typeof String$>;
  }>, ParseIssue, R3>;
},
   annotations?: ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>): [Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`" : Class<Transformed, {
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
} & NewFields, Encoded<{
  avatar_url: typeof String$;
  blog: optional<typeof String$>;
  email: optional<typeof String$>;
  html_url: typeof String$;
  id: typeof Number$;
  login: typeof String$;
  name: optional<typeof String$>;
}>, R2 | R3 | Context<NewFields[keyof NewFields]>, {
  id: number;
} & {
  html_url: string;
} & {
  login: string;
} & {
  avatar_url: string;
} & {
  name?: string;
} & {
  blog?: string;
} & {
  email?: string;
} & Constructor<NewFields>, GitHubUser, {
}>;

Type Parameters

NewFields

NewFields extends Fields

R2

R2

R3

R3

Parameters

fields

NewFields

options

decode

(input: { avatar_url: string; blog?: string; email?: string; html_url: string; id: number; login: string; name?: string; }, options: ParseOptions, ast: Transformation) => Effect<{ [K in string | number | symbol]: ({ avatar_url: string; html_url: string; id: number; login: string } & { blog?: string; email?: string; name?: string } & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<(…)[(…)]> })[K] }, ParseIssue, R2>

encode

(input: { [K in string | number | symbol]: ({ avatar_url: string; html_url: string; id: number; login: string } & { blog?: string; email?: string; name?: string } & { readonly [K in string | number | symbol as Key<NewFields, K>]: Encoded<NewFields[K]> } & { readonly [K in string | number | symbol as Key<NewFields, K>]?: Encoded<NewFields[K]> })[K] }, options: ParseOptions, ast: Transformation) => Effect<Encoded<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$>; }>, ParseIssue, R3>

annotations?

ClassAnnotations<Transformed, { [K in string | number | symbol]: Type<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$> } & NewFields>[K] }>

Returns

[Transformed] extends [never] ? "Missing `Self` generic - use `class Self extends Base.transformOrFailFrom<Self>()({ ... })`" : Class<Transformed, { avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$>; } & NewFields, Encoded<{ avatar_url: typeof String$; blog: optional<typeof String$>; email: optional<typeof String$>; html_url: typeof String$; id: typeof Number$; login: typeof String$; name: optional<typeof String$>; }>, R2 | R3 | Context<NewFields[keyof NewFields]>, { id: number; } & { html_url: string; } & { login: string; } & { avatar_url: string; } & { name?: string; } & { blog?: string; } & { email?: string; } & Constructor<NewFields>, GitHubUser, { }>

Example

import { Effect, Schema } from "effect"

class MyClass extends Schema.Class<MyClass>("MyClass")({
  myField: Schema.String
}) {
  myMethod() {
    return this.myField + "my"
  }
}

class NextClass extends MyClass.transformOrFailFrom<NextClass>("NextClass")({
  nextField: Schema.Number
}, {
  decode: (i) =>
    Effect.succeed({
      myField: i.myField,
      nextField: i.myField.length
    }),
  encode: (a) => Effect.succeed({ myField: a.myField })
}) {
  nextMethod() {
    return this.myMethod() + this.myField + this.nextField
  }
}

Inherited from

Schema.Class<GitHubUser>('GitHubUser')({
  id: Schema.Number,
  html_url: Schema.String,
  login: Schema.String,
  avatar_url: Schema.String,
  name: Schema.optional(Schema.String),
  blog: Schema.optional(Schema.String),
  email: Schema.optional(Schema.String),
}).transformOrFailFrom