@gatwech/core 0.0.11 → 1.0.0-beta.19

package/dist/src/social-providers/github.d.ts

@@ -0,0 +1,89 @@
+import type { ProviderOptions } from "../oauth2";
+export interface GithubProfile {
+    login: string;
+    id: string;
+    node_id: string;
+    avatar_url: string;
+    gravatar_id: string;
+    url: string;
+    html_url: string;
+    followers_url: string;
+    following_url: string;
+    gists_url: string;
+    starred_url: string;
+    subscriptions_url: string;
+    organizations_url: string;
+    repos_url: string;
+    events_url: string;
+    received_events_url: string;
+    type: string;
+    site_admin: boolean;
+    name: string;
+    company: string;
+    blog: string;
+    location: string;
+    email: string;
+    hireable: boolean;
+    bio: string;
+    twitter_username: string;
+    public_repos: string;
+    public_gists: string;
+    followers: string;
+    following: string;
+    created_at: string;
+    updated_at: string;
+    private_gists: string;
+    total_private_repos: string;
+    owned_private_repos: string;
+    disk_usage: string;
+    collaborators: string;
+    two_factor_authentication: boolean;
+    plan: {
+        name: string;
+        space: string;
+        private_repos: string;
+        collaborators: string;
+    };
+}
+export interface GithubOptions extends ProviderOptions<GithubProfile> {
+    clientId: string;
+}
+export declare const github: (options: GithubOptions) => {
+    id: "github";
+    name: string;
+    createAuthorizationURL({ state, scopes, loginHint, redirectURI }: {
+        state: string;
+        codeVerifier: string;
+        scopes?: string[] | undefined;
+        redirectURI: string;
+        display?: string | undefined;
+        loginHint?: string | undefined;
+    }): Promise<URL>;
+    validateAuthorizationCode: ({ code, redirectURI }: {
+        code: string;
+        redirectURI: string;
+        codeVerifier?: string | undefined;
+        deviceId?: string | undefined;
+    }) => Promise<import("../oauth2").OAuth2Tokens>;
+    refreshAccessToken: (refreshToken: string) => Promise<import("../oauth2").OAuth2Tokens>;
+    getUserInfo(token: import("../oauth2").OAuth2Tokens & {
+        user?: {
+            name?: {
+                firstName?: string;
+                lastName?: string;
+            };
+            email?: string;
+        } | undefined;
+    }): Promise<{
+        user: {
+            id: string;
+            name?: string;
+            email?: string | null;
+            image?: string;
+            emailVerified: boolean;
+            [key: string]: any;
+        };
+        data: any;
+    } | null>;
+    options: GithubOptions;
+};

package/dist/src/social-providers/google.d.ts

@@ -0,0 +1,82 @@
+import type { ProviderOptions } from "../oauth2";
+export interface GoogleProfile {
+    aud: string;
+    azp: string;
+    email: string;
+    email_verified: boolean;
+    exp: number;
+    /**
+     * The family name of the user, or last name in most
+     * Western languages.
+     */
+    family_name: string;
+    /**
+     * The given name of the user, or first name in most
+     * Western languages.
+     */
+    given_name: string;
+    hd?: string | undefined;
+    iat: number;
+    iss: string;
+    jti?: string | undefined;
+    locale?: string | undefined;
+    name: string;
+    nbf?: number | undefined;
+    picture: string;
+    sub: string;
+}
+export interface GoogleOptions extends ProviderOptions<GoogleProfile> {
+    clientId: string;
+    /**
+     * The access type to use for the authorization code request
+     */
+    accessType?: ("offline" | "online") | undefined;
+    /**
+     * The display mode to use for the authorization code request
+     */
+    display?: ("page" | "popup" | "touch" | "wap") | undefined;
+    /**
+     * The hosted domain of the user
+     */
+    hd?: string | undefined;
+}
+export declare const google: (options: GoogleOptions) => {
+    id: "google";
+    name: string;
+    createAuthorizationURL({ state, scopes, codeVerifier, redirectURI, loginHint, display, }: {
+        state: string;
+        codeVerifier: string;
+        scopes?: string[] | undefined;
+        redirectURI: string;
+        display?: string | undefined;
+        loginHint?: string | undefined;
+    }): Promise<URL>;
+    validateAuthorizationCode: ({ code, codeVerifier, redirectURI }: {
+        code: string;
+        redirectURI: string;
+        codeVerifier?: string | undefined;
+        deviceId?: string | undefined;
+    }) => Promise<import("../oauth2").OAuth2Tokens>;
+    refreshAccessToken: (refreshToken: string) => Promise<import("../oauth2").OAuth2Tokens>;
+    verifyIdToken(token: string, nonce: string | undefined): Promise<boolean>;
+    getUserInfo(token: import("../oauth2").OAuth2Tokens & {
+        user?: {
+            name?: {
+                firstName?: string;
+                lastName?: string;
+            };
+            email?: string;
+        } | undefined;
+    }): Promise<{
+        user: {
+            id: string;
+            name?: string;
+            email?: string | null;
+            image?: string;
+            emailVerified: boolean;
+            [key: string]: any;
+        };
+        data: any;
+    } | null>;
+    options: GoogleOptions;
+};

package/dist/src/social-providers/index.d.ts

@@ -0,0 +1,93 @@
+import * as z from "zod";
+export declare const socialProviders: {
+    github: (options: import("./github").GithubOptions) => {
+        id: "github";
+        name: string;
+        createAuthorizationURL({ state, scopes, loginHint, redirectURI }: {
+            state: string;
+            codeVerifier: string;
+            scopes?: string[] | undefined;
+            redirectURI: string;
+            display?: string | undefined;
+            loginHint?: string | undefined;
+        }): Promise<URL>;
+        validateAuthorizationCode: ({ code, redirectURI }: {
+            code: string;
+            redirectURI: string;
+            codeVerifier?: string | undefined;
+            deviceId?: string | undefined;
+        }) => Promise<import("../oauth2").OAuth2Tokens>;
+        refreshAccessToken: (refreshToken: string) => Promise<import("../oauth2").OAuth2Tokens>;
+        getUserInfo(token: import("../oauth2").OAuth2Tokens & {
+            user?: {
+                name?: {
+                    firstName?: string;
+                    lastName?: string;
+                };
+                email?: string;
+            } | undefined;
+        }): Promise<{
+            user: {
+                id: string;
+                name?: string;
+                email?: string | null;
+                image?: string;
+                emailVerified: boolean;
+                [key: string]: any;
+            };
+            data: any;
+        } | null>;
+        options: import("./github").GithubOptions;
+    };
+    google: (options: import("./google").GoogleOptions) => {
+        id: "google";
+        name: string;
+        createAuthorizationURL({ state, scopes, codeVerifier, redirectURI, loginHint, display, }: {
+            state: string;
+            codeVerifier: string;
+            scopes?: string[] | undefined;
+            redirectURI: string;
+            display?: string | undefined;
+            loginHint?: string | undefined;
+        }): Promise<URL>;
+        validateAuthorizationCode: ({ code, codeVerifier, redirectURI }: {
+            code: string;
+            redirectURI: string;
+            codeVerifier?: string | undefined;
+            deviceId?: string | undefined;
+        }) => Promise<import("../oauth2").OAuth2Tokens>;
+        refreshAccessToken: (refreshToken: string) => Promise<import("../oauth2").OAuth2Tokens>;
+        verifyIdToken(token: string, nonce: string | undefined): Promise<boolean>;
+        getUserInfo(token: import("../oauth2").OAuth2Tokens & {
+            user?: {
+                name?: {
+                    firstName?: string;
+                    lastName?: string;
+                };
+                email?: string;
+            } | undefined;
+        }): Promise<{
+            user: {
+                id: string;
+                name?: string;
+                email?: string | null;
+                image?: string;
+                emailVerified: boolean;
+                [key: string]: any;
+            };
+            data: any;
+        } | null>;
+        options: import("./google").GoogleOptions;
+    };
+};
+export declare const socialProviderList: ["github", ...(keyof typeof socialProviders)[]];
+export declare const SocialProviderListEnum: z.ZodType<SocialProviderList[number] | (string & {})>;
+export type SocialProvider = z.infer<typeof SocialProviderListEnum>;
+export type SocialProviders = {
+    [K in SocialProviderList[number]]?: Parameters<(typeof socialProviders)[K]>[0] & {
+        enabled?: boolean | undefined;
+    };
+};
+export * from "./github";
+export * from "./google";
+export type SocialProviderList = typeof socialProviderList;

package/dist/src/types/context.d.ts

@@ -0,0 +1,177 @@
+import type { CookieOptions, EndpointContext } from "better-call";
+import type { Account, PayvoAuthDBSchema, DBPreservedModels, SecondaryStorage, Session, User, Verification } from "../db";
+import type { DBAdapter, Where } from "../db/adapter";
+import { createLogger } from "../env";
+import type { OAuthProvider } from "../oauth2";
+import type { PayvoAuthCookies } from "./cookie";
+import type { LiteralUnion } from "./helper";
+import type { PayvoAuthOptions, PayvoAuthRateLimitOptions } from "./init-options";
+export type GenericEndpointContext<Options extends PayvoAuthOptions = PayvoAuthOptions> = EndpointContext<string, any> & {
+    context: AuthContext<Options>;
+};
+export interface InternalAdapter<Options extends PayvoAuthOptions = PayvoAuthOptions> {
+    createOAuthUser(user: Omit<User, "id" | "createdAt" | "updatedAt">, account: Omit<Account, "userId" | "id" | "createdAt" | "updatedAt"> & Partial<Account>): Promise<{
+        user: User;
+        account: Account;
+    }>;
+    createUser<T extends Record<string, any>>(user: Omit<User, "id" | "createdAt" | "updatedAt" | "emailVerified"> & Partial<User> & Record<string, any>): Promise<T & User>;
+    createAccount<T extends Record<string, any>>(account: Omit<Account, "id" | "createdAt" | "updatedAt"> & Partial<Account> & T): Promise<T & Account>;
+    listSessions(userId: string): Promise<Session[]>;
+    listUsers(limit?: number | undefined, offset?: number | undefined, sortBy?: {
+        field: string;
+        direction: "asc" | "desc";
+    } | undefined, where?: Where[] | undefined): Promise<User[]>;
+    countTotalUsers(where?: Where[] | undefined): Promise<number>;
+    deleteUser(userId: string): Promise<void>;
+    createSession(userId: string, dontRememberMe?: boolean | undefined, override?: (Partial<Session> & Record<string, any>) | undefined, overrideAll?: boolean | undefined): Promise<Session>;
+    findSession(token: string): Promise<{
+        session: Session & Record<string, any>;
+        user: User & Record<string, any>;
+    } | null>;
+    findSessions(sessionTokens: string[]): Promise<{
+        session: Session;
+        user: User;
+    }[]>;
+    updateSession(sessionToken: string, session: Partial<Session> & Record<string, any>): Promise<Session | null>;
+    deleteSession(token: string): Promise<void>;
+    deleteAccounts(userId: string): Promise<void>;
+    deleteAccount(accountId: string): Promise<void>;
+    deleteSessions(userIdOrSessionTokens: string | string[]): Promise<void>;
+    findOAuthUser(email: string, accountId: string, providerId: string): Promise<{
+        user: User;
+        accounts: Account[];
+    } | null>;
+    findUserByEmail(email: string, options?: {
+        includeAccounts: boolean;
+    } | undefined): Promise<{
+        user: User;
+        accounts: Account[];
+    } | null>;
+    findUserById(userId: string): Promise<User | null>;
+    linkAccount(account: Omit<Account, "id" | "createdAt" | "updatedAt"> & Partial<Account>): Promise<Account>;
+    updateUser(userId: string, data: Partial<User> & Record<string, any>): Promise<any>;
+    updateUserByEmail(email: string, data: Partial<User & Record<string, any>>): Promise<User>;
+    updatePassword(userId: string, password: string): Promise<void>;
+    findAccounts(userId: string): Promise<Account[]>;
+    findAccount(accountId: string): Promise<Account | null>;
+    findAccountByProviderId(accountId: string, providerId: string): Promise<Account | null>;
+    findAccountByUserId(userId: string): Promise<Account[]>;
+    updateAccount(id: string, data: Partial<Account>): Promise<Account>;
+    createVerificationValue(data: Omit<Verification, "createdAt" | "id" | "updatedAt"> & Partial<Verification>): Promise<Verification>;
+    findVerificationValue(identifier: string): Promise<Verification | null>;
+    deleteVerificationValue(id: string): Promise<void>;
+    deleteVerificationByIdentifier(identifier: string): Promise<void>;
+    updateVerificationValue(id: string, data: Partial<Verification>): Promise<Verification>;
+}
+type CreateCookieGetterFn = (cookieName: string, overrideAttributes?: Partial<CookieOptions> | undefined) => {
+    name: string;
+    attributes: CookieOptions;
+};
+type CheckPasswordFn<Options extends PayvoAuthOptions = PayvoAuthOptions> = (userId: string, ctx: GenericEndpointContext<Options>) => Promise<boolean>;
+export type AuthContext<Options extends PayvoAuthOptions = PayvoAuthOptions> = {
+    options: Options;
+    appName: string;
+    baseURL: string;
+    trustedOrigins: string[];
+    oauthConfig: {
+        /**
+         * This is dangerous and should only be used in dev or staging environments.
+         */
+        skipStateCookieCheck?: boolean | undefined;
+        /**
+         * Strategy for storing OAuth state
+         *
+         * - "cookie": Store state in an encrypted cookie (stateless)
+         * - "database": Store state in the database
+         *
+         * @default "cookie"
+         */
+        storeStateStrategy: "database" | "cookie";
+    };
+    /**
+     * New session that will be set after the request
+     * meaning: there is a `set-cookie` header that will set
+     * the session cookie. This is the fetched session. And it's set
+     * by `setNewSession` method.
+     */
+    newSession: {
+        session: Session & Record<string, any>;
+        user: User & Record<string, any>;
+    } | null;
+    session: {
+        session: Session & Record<string, any>;
+        user: User & Record<string, any>;
+    } | null;
+    setNewSession: (session: {
+        session: Session & Record<string, any>;
+        user: User & Record<string, any>;
+    } | null) => void;
+    socialProviders: OAuthProvider[];
+    authCookies: PayvoAuthCookies;
+    logger: ReturnType<typeof createLogger>;
+    rateLimit: {
+        enabled: boolean;
+        window: number;
+        max: number;
+        storage: "memory" | "database" | "secondary-storage";
+    } & PayvoAuthRateLimitOptions;
+    adapter: DBAdapter<Options>;
+    internalAdapter: InternalAdapter<Options>;
+    createAuthCookie: CreateCookieGetterFn;
+    secret: string;
+    sessionConfig: {
+        updateAge: number;
+        expiresIn: number;
+        freshAge: number;
+        cookieRefreshCache: false | {
+            enabled: true;
+            updateAge: number;
+        };
+    };
+    generateId: (options: {
+        model: LiteralUnion<DBPreservedModels, string>;
+        size?: number | undefined;
+    }) => string | false;
+    secondaryStorage: SecondaryStorage | undefined;
+    password: {
+        hash: (password: string) => Promise<string>;
+        verify: (data: {
+            password: string;
+            hash: string;
+        }) => Promise<boolean>;
+        config: {
+            minPasswordLength: number;
+            maxPasswordLength: number;
+        };
+        checkPassword: CheckPasswordFn<Options>;
+    };
+    tables: PayvoAuthDBSchema;
+    runMigrations: () => Promise<void>;
+    publishTelemetry: (event: {
+        type: string;
+        anonymousId?: string | undefined;
+        payload: Record<string, any>;
+    }) => Promise<void>;
+    /**
+     * This skips the origin check for all requests.
+     *
+     * set to true by default for `test` environments and `false`
+     * for other environments.
+     *
+     * It's inferred from the `options.advanced?.disableCSRFCheck`
+     * option or `options.advanced?.disableOriginCheck` option.
+     *
+     * @default false
+     */
+    skipOriginCheck: boolean;
+    /**
+     * This skips the CSRF check for all requests.
+     *
+     * This is inferred from the `options.advanced?.
+     * disableCSRFCheck` option.
+     *
+     * @default false
+     */
+    skipCSRFCheck: boolean;
+};
+export {};

package/dist/src/types/cookie.d.ts

@@ -0,0 +1,15 @@
+import type { CookieOptions } from "better-call";
+export type PayvoAuthCookies = {
+    sessionToken: {
+        name: string;
+        options: CookieOptions;
+    };
+    sessionData: {
+        name: string;
+        options: CookieOptions;
+    };
+    dontRememberToken: {
+        name: string;
+        options: CookieOptions;
+    };
+};

package/dist/src/types/helper.d.ts

@@ -0,0 +1,9 @@
+export type Primitive = string | number | symbol | bigint | boolean | null | undefined;
+export type Awaitable<T> = T | Promise<T>;
+export type AwaitableFunction<T> = T | (() => Awaitable<T>);
+export type LiteralString = "" | (string & Record<never, never>);
+export type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>);
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/dist/src/types/index.d.ts

@@ -0,0 +1,7 @@
+export type { StandardSchemaV1 } from "@standard-schema/spec";
+export type { AuthContext, GenericEndpointContext, InternalAdapter, } from "./context";
+export type { PayvoAuthCookies } from "./cookie";
+export type * from "./helper";
+export type { PayvoAuthAdvancedOptions, PayvoAuthOptions, PayvoAuthRateLimitOptions, GenerateIdFn, } from "./init-options";
+export type { PayvoAuthPlugin, HookEndpointContext } from "./plugin";
+export type { PayvoAuthClientOptions, PayvoAuthClientPlugin, ClientAtomListener, ClientStore, } from "./plugin-client";