@gatwech/auth 1.0.0-beta.18

package/dist/src/plugins/two-factor/otp/index.d.ts

@@ -0,0 +1,282 @@
+import * as z from "zod";
+import type { UserWithTwoFactor } from "../types";
+export interface OTPOptions {
+    /**
+     * How long the opt will be valid for in
+     * minutes
+     *
+     * @default "3 mins"
+     */
+    period?: number | undefined;
+    /**
+     * Number of digits for the OTP code
+     *
+     * @default 6
+     */
+    digits?: number | undefined;
+    /**
+     * Send the otp to the user
+     *
+     * @param user - The user to send the otp to
+     * @param otp - The otp to send
+     * @param request - The request object
+     * @returns void | Promise<void>
+     */
+    sendOTP?: ((
+    /**
+     * The user to send the otp to
+     * @type UserWithTwoFactor
+     * @default UserWithTwoFactors
+     */
+    data: {
+        user: UserWithTwoFactor;
+        otp: string;
+    }, 
+    /**
+     * The request object
+     */
+    request?: Request) => Promise<void> | void) | undefined;
+    /**
+     * The number of allowed attempts for the OTP
+     *
+     * @default 5
+     */
+    allowedAttempts?: number | undefined;
+    storeOTP?: ("plain" | "encrypted" | "hashed" | {
+        hash: (token: string) => Promise<string>;
+    } | {
+        encrypt: (token: string) => Promise<string>;
+        decrypt: (token: string) => Promise<string>;
+    }) | undefined;
+}
+/**
+ * The otp adapter is created from the totp adapter.
+ */
+export declare const otp2fa: (options?: OTPOptions | undefined) => {
+    id: "otp";
+    endpoints: {
+        /**
+         * ### Endpoint
+         *
+         * POST `/two-factor/send-otp`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.send2FaOTP`
+         *
+         * **client:**
+         * `authClient.twoFactor.sendOtp`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/2fa#api-method-two-factor-send-otp)
+         */
+        sendTwoFactorOTP: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                body?: {
+                    trustDevice?: boolean | undefined;
+                } | undefined;
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: import("better-call").Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    status: boolean;
+                };
+            } : {
+                status: boolean;
+            }>;
+            options: {
+                method: "POST";
+                body: z.ZodOptional<z.ZodObject<{
+                    trustDevice: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/two-factor/send-otp";
+        };
+        /**
+         * ### Endpoint
+         *
+         * POST `/two-factor/verify-otp`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.verifyOTP`
+         *
+         * **client:**
+         * `authClient.twoFactor.verifyOtp`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/2fa#api-method-two-factor-verify-otp)
+         */
+        verifyTwoFactorOTP: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    code: string;
+                    trustDevice?: boolean | undefined;
+                };
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: import("better-call").Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    token: string;
+                    user: {
+                        id: any;
+                        email: any;
+                        emailVerified: any;
+                        name: any;
+                        image: any;
+                        createdAt: any;
+                        updatedAt: any;
+                    };
+                };
+            } : {
+                token: string;
+                user: {
+                    id: any;
+                    email: any;
+                    emailVerified: any;
+                    name: any;
+                    image: any;
+                    createdAt: any;
+                    updatedAt: any;
+                };
+            }>;
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                    trustDevice: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            "200": {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                token: {
+                                                    type: string;
+                                                    description: string;
+                                                };
+                                                user: {
+                                                    type: string;
+                                                    properties: {
+                                                        id: {
+                                                            type: string;
+                                                            description: string;
+                                                        };
+                                                        email: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        emailVerified: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        name: {
+                                                            type: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        image: {
+                                                            type: string;
+                                                            format: string;
+                                                            nullable: boolean;
+                                                            description: string;
+                                                        };
+                                                        createdAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                        updatedAt: {
+                                                            type: string;
+                                                            format: string;
+                                                            description: string;
+                                                        };
+                                                    };
+                                                    required: string[];
+                                                    description: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/two-factor/verify-otp";
+        };
+    };
+};

package/dist/src/plugins/two-factor/schema.d.ts

@@ -0,0 +1,35 @@
+export declare const schema: {
+    user: {
+        fields: {
+            twoFactorEnabled: {
+                type: "boolean";
+                required: false;
+                defaultValue: false;
+                input: false;
+            };
+        };
+    };
+    twoFactor: {
+        fields: {
+            secret: {
+                type: "string";
+                required: true;
+                returned: false;
+            };
+            backupCodes: {
+                type: "string";
+                required: true;
+                returned: false;
+            };
+            userId: {
+                type: "string";
+                required: true;
+                returned: false;
+                references: {
+                    model: string;
+                    field: string;
+                };
+            };
+        };
+    };
+};

package/dist/src/plugins/two-factor/totp/index.d.ts

@@ -0,0 +1,298 @@
+import * as z from "zod";
+import type { BackupCodeOptions } from "../backup-codes";
+export type TOTPOptions = {
+    /**
+     * Issuer
+     */
+    issuer?: string | undefined;
+    /**
+     * How many digits the otp to be
+     *
+     * @default 6
+     */
+    digits?: (6 | 8) | undefined;
+    /**
+     * Period for otp in seconds.
+     * @default 30
+     */
+    period?: number | undefined;
+    /**
+     * Backup codes configuration
+     */
+    backupCodes?: BackupCodeOptions | undefined;
+    /**
+     * Disable totp
+     */
+    disable?: boolean | undefined;
+};
+export declare const totp2fa: (options?: TOTPOptions | undefined) => {
+    id: "totp";
+    endpoints: {
+        /**
+         * ### Endpoint
+         *
+         * POST `/totp/generate`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.generateTOTP`
+         *
+         * **client:**
+         * `authClient.totp.generate`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/totp#api-method-totp-generate)
+         */
+        generateTOTP: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    secret: string;
+                };
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: import("better-call").Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    code: string;
+                };
+            } : {
+                code: string;
+            }>;
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    secret: z.ZodString;
+                }, z.core.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                code: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    SERVER_ONLY: true;
+                };
+            } & {
+                use: any[];
+            };
+            path: "/totp/generate";
+        };
+        /**
+         * ### Endpoint
+         *
+         * POST `/two-factor/get-totp-uri`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.getTOTPURI`
+         *
+         * **client:**
+         * `authClient.twoFactor.getTotpUri`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/two-factor#api-method-two-factor-get-totp-uri)
+         */
+        getTOTPURI: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    password: string;
+                };
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: import("better-call").Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    totpURI: string;
+                };
+            } : {
+                totpURI: string;
+            }>;
+            options: {
+                method: "POST";
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                    session: {
+                        session: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        };
+                        user: Record<string, any> & {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        };
+                    };
+                }>)[];
+                body: z.ZodObject<{
+                    password: z.ZodString;
+                }, z.core.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                totpURI: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/two-factor/get-totp-uri";
+        };
+        verifyTOTP: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    code: string;
+                    trustDevice?: boolean | undefined;
+                };
+            } & {
+                method?: "POST" | undefined;
+            } & {
+                query?: Record<string, any> | undefined;
+            } & {
+                params?: Record<string, any>;
+            } & {
+                request?: Request;
+            } & {
+                headers?: HeadersInit;
+            } & {
+                asResponse?: boolean;
+                returnHeaders?: boolean;
+                use?: import("better-call").Middleware[];
+                path?: string;
+            } & {
+                asResponse?: AsResponse | undefined;
+                returnHeaders?: ReturnHeaders | undefined;
+            }): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    token: string;
+                    user: {
+                        id: string;
+                        email: string;
+                        emailVerified: boolean;
+                        name: string;
+                        image: string | null | undefined;
+                        createdAt: Date;
+                        updatedAt: Date;
+                    };
+                };
+            } : {
+                token: string;
+                user: {
+                    id: string;
+                    email: string;
+                    emailVerified: boolean;
+                    name: string;
+                    image: string | null | undefined;
+                    createdAt: Date;
+                    updatedAt: Date;
+                };
+            }>;
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    code: z.ZodString;
+                    trustDevice: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>;
+                metadata: {
+                    openapi: {
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/two-factor/verify-totp";
+        };
+    };
+};

package/dist/src/plugins/two-factor/types.d.ts

@@ -0,0 +1,50 @@
+import type { PayvoAuthPlugin } from "@gatwech/core";
+import type { InferOptionSchema, User } from "../../types";
+import type { LiteralString } from "../../types/helper";
+import type { BackupCodeOptions } from "./backup-codes";
+import type { OTPOptions } from "./otp";
+import type { schema } from "./schema";
+import type { TOTPOptions } from "./totp";
+export interface TwoFactorOptions {
+    /**
+     * Application Name
+     */
+    issuer?: string | undefined;
+    /**
+     * TOTP OPtions
+     */
+    totpOptions?: Omit<TOTPOptions, "issuer"> | undefined;
+    /**
+     * OTP Options
+     */
+    otpOptions?: OTPOptions | undefined;
+    /**
+     * Backup code options
+     */
+    backupCodeOptions?: BackupCodeOptions | undefined;
+    /**
+     * Skip verification on enabling two factor authentication.
+     * @default false
+     */
+    skipVerificationOnEnable?: boolean | undefined;
+    /**
+     * Custom schema for the two factor plugin
+     */
+    schema?: InferOptionSchema<typeof schema> | undefined;
+}
+export interface UserWithTwoFactor extends User {
+    /**
+     * If the user has enabled two factor authentication.
+     */
+    twoFactorEnabled: boolean;
+}
+export interface TwoFactorProvider {
+    id: LiteralString;
+    endpoints?: PayvoAuthPlugin["endpoints"] | undefined;
+}
+export interface TwoFactorTable {
+    userId: string;
+    secret: string;
+    backupCodes: string;
+    enabled: boolean;
+}

package/dist/src/plugins/two-factor/utils.d.ts

@@ -0,0 +1 @@
+export declare const defaultKeyHasher: (token: string) => Promise<string>;