@gatwech/auth 1.0.0-beta.18

package/dist/src/plugins/magic-link/index.d.ts

@@ -0,0 +1,253 @@
+import * as z from "zod";
+interface MagicLinkopts {
+    /**
+     * Time in seconds until the magic link expires.
+     * @default (60 * 5) // 5 minutes
+     */
+    expiresIn?: number | undefined;
+    /**
+     * Send magic link implementation.
+     */
+    sendMagicLink: (data: {
+        email: string;
+        url: string;
+        token: string;
+    }, request?: Request | undefined) => Promise<void> | void;
+    /**
+     * Disable sign up if user is not found.
+     *
+     * @default false
+     */
+    disableSignUp?: boolean | undefined;
+    /**
+     * Rate limit configuration.
+     *
+     * @default {
+     *  window: 60,
+     *  max: 5,
+     * }
+     */
+    rateLimit?: {
+        window: number;
+        max: number;
+    } | undefined;
+    /**
+     * Custom function to generate a token
+     */
+    generateToken?: ((email: string) => Promise<string> | string) | undefined;
+    /**
+     * This option allows you to configure how the token is stored in your database.
+     * Note: This will not affect the token that's sent, it will only affect the token stored in your database.
+     *
+     * @default "plain"
+     */
+    storeToken?: ("plain" | "hashed" | {
+        type: "custom-hasher";
+        hash: (token: string) => Promise<string>;
+    }) | undefined;
+}
+export declare const magicLink: (options: MagicLinkopts) => {
+    id: "magic-link";
+    endpoints: {
+        /**
+         * ### Endpoint
+         *
+         * POST `/sign-in/magic-link`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.signInMagicLink`
+         *
+         * **client:**
+         * `authClient.signIn.magicLink`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/sign-in#api-method-sign-in-magic-link)
+         */
+        signInMagicLink: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    email: string;
+                    name?: string | undefined;
+                    callbackURL?: string | undefined;
+                    newUserCallbackURL?: string | undefined;
+                    errorCallbackURL?: string | 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: {
+                    status: boolean;
+                };
+            } : {
+                status: boolean;
+            }>;
+            options: {
+                method: "POST";
+                requireHeaders: true;
+                body: z.ZodObject<{
+                    email: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                    newUserCallbackURL: z.ZodOptional<z.ZodString>;
+                    errorCallbackURL: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/sign-in/magic-link";
+        };
+        /**
+         * ### Endpoint
+         *
+         * GET `/magic-link/verify`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.magicLinkVerify`
+         *
+         * **client:**
+         * `authClient.magicLink.verify`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/magic-link#api-method-magic-link-verify)
+         */
+        magicLinkVerify: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body?: undefined;
+            } & {
+                method?: "GET" | undefined;
+            } & {
+                query: {
+                    token: string;
+                    callbackURL?: string | undefined;
+                    errorCallbackURL?: string | undefined;
+                    newUserCallbackURL?: string | 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: "GET";
+                query: z.ZodObject<{
+                    token: z.ZodString;
+                    callbackURL: z.ZodOptional<z.ZodString>;
+                    errorCallbackURL: z.ZodOptional<z.ZodString>;
+                    newUserCallbackURL: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>)[];
+                requireHeaders: true;
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                                user: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/magic-link/verify";
+        };
+    };
+    rateLimit: {
+        pathMatcher(path: string): boolean;
+        window: number;
+        max: number;
+    }[];
+};
+export {};

package/dist/src/plugins/magic-link/utils.d.ts

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

package/dist/src/plugins/multi-session/client.d.ts

@@ -0,0 +1,9 @@
+import type { multiSession } from ".";
+export declare const multiSessionClient: () => {
+    id: "multi-session";
+    $InferServerPlugin: ReturnType<typeof multiSession>;
+    atomListeners: {
+        matcher(path: string): path is "/multi-session/set-active";
+        signal: "$sessionSignal";
+    }[];
+};

package/dist/src/plugins/multi-session/index.d.ts

@@ -0,0 +1,284 @@
+import * as z from "zod";
+interface MultiSessionConfig {
+    /**
+     * The maximum number of sessions a user can have
+     * at a time
+     * @default 5
+     */
+    maximumSessions?: number | undefined;
+}
+export declare const multiSession: (options?: MultiSessionConfig | undefined) => {
+    id: "multi-session";
+    endpoints: {
+        /**
+         * ### Endpoint
+         *
+         * GET `/multi-session/list-device-sessions`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.listDeviceSessions`
+         *
+         * **client:**
+         * `authClient.multiSession.listDeviceSessions`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/multi-session#api-method-multi-session-list-device-sessions)
+         */
+        listDeviceSessions: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body?: undefined;
+            } & {
+                method?: "GET" | 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: {
+                    session: import("packages/core/dist/index-65G5U5DB.mjs").bt;
+                    user: import("packages/core/dist/index-65G5U5DB.mjs")._t;
+                }[];
+            } : {
+                session: import("packages/core/dist/index-65G5U5DB.mjs").bt;
+                user: import("packages/core/dist/index-65G5U5DB.mjs")._t;
+            }[]>;
+            options: {
+                method: "GET";
+                requireHeaders: true;
+            } & {
+                use: any[];
+            };
+            path: "/multi-session/list-device-sessions";
+        };
+        /**
+         * ### Endpoint
+         *
+         * POST `/multi-session/set-active`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.setActiveSession`
+         *
+         * **client:**
+         * `authClient.multiSession.setActive`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/multi-session#api-method-multi-session-set-active)
+         */
+        setActiveSession: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    sessionToken: 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: {
+                    session: import("packages/core/dist/index-65G5U5DB.mjs").bt & Record<string, any>;
+                    user: import("packages/core/dist/index-65G5U5DB.mjs")._t & Record<string, any>;
+                };
+            } : {
+                session: import("packages/core/dist/index-65G5U5DB.mjs").bt & Record<string, any>;
+                user: import("packages/core/dist/index-65G5U5DB.mjs")._t & Record<string, any>;
+            }>;
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    sessionToken: z.ZodString;
+                }, z.core.$strip>;
+                requireHeaders: true;
+                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;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                session: {
+                                                    $ref: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/multi-session/set-active";
+        };
+        /**
+         * ### Endpoint
+         *
+         * POST `/multi-session/revoke`
+         *
+         * ### API Methods
+         *
+         * **server:**
+         * `auth.api.revokeDeviceSession`
+         *
+         * **client:**
+         * `authClient.multiSession.revoke`
+         *
+         * @see [Read our docs to learn more.](https://payvopayvo.com/docs/plugins/multi-session#api-method-multi-session-revoke)
+         */
+        revokeDeviceSession: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body: {
+                    sessionToken: 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: {
+                    status: boolean;
+                };
+            } : {
+                status: boolean;
+            }>;
+            options: {
+                method: "POST";
+                body: z.ZodObject<{
+                    sessionToken: z.ZodString;
+                }, z.core.$strip>;
+                requireHeaders: true;
+                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;
+                        };
+                    };
+                }>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                status: {
+                                                    type: string;
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/multi-session/revoke";
+        };
+    };
+    hooks: {
+        after: {
+            matcher: (context: import("@gatwech/core").HookEndpointContext) => boolean;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+        }[];
+    };
+    $ERROR_CODES: {
+        readonly INVALID_SESSION_TOKEN: "Invalid session token";
+    };
+};
+export {};

package/dist/src/plugins/oauth-proxy/index.d.ts

@@ -0,0 +1,119 @@
+import * as z from "zod";
+export interface OAuthProxyOptions {
+    /**
+     * The current URL of the application.
+     * The plugin will attempt to infer the current URL from your environment
+     * by checking the base URL from popular hosting providers,
+     * from the request URL if invoked by a client,
+     * or as a fallback, from the `baseURL` in your auth config.
+     * If the URL is not inferred correctly, you can provide a value here."
+     */
+    currentURL?: string | undefined;
+    /**
+     * If a request in a production url it won't be proxied.
+     *
+     * default to `PAYVO_AUTH_URL`
+     */
+    productionURL?: string | undefined;
+}
+/**
+ * A proxy plugin, that allows you to proxy OAuth requests.
+ * Useful for development and preview deployments where
+ * the redirect URL can't be known in advance to add to the OAuth provider.
+ */
+export declare const oAuthProxy: (opts?: OAuthProxyOptions | undefined) => {
+    id: "oauth-proxy";
+    options: OAuthProxyOptions | undefined;
+    endpoints: {
+        oAuthProxy: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0: {
+                body?: undefined;
+            } & {
+                method?: "GET" | undefined;
+            } & {
+                query: {
+                    callbackURL: string;
+                    cookies: string;
+                };
+            } & {
+                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: never;
+            } : never>;
+            options: {
+                method: "GET";
+                query: z.ZodObject<{
+                    callbackURL: z.ZodString;
+                    cookies: z.ZodString;
+                }, z.core.$strip>;
+                use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>)[];
+                metadata: {
+                    openapi: {
+                        description: string;
+                        parameters: {
+                            in: "query";
+                            name: string;
+                            required: true;
+                            description: string;
+                        }[];
+                        responses: {
+                            302: {
+                                description: string;
+                                headers: {
+                                    Location: {
+                                        description: string;
+                                        schema: {
+                                            type: string;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/oauth-proxy-callback";
+        };
+    };
+    hooks: {
+        after: {
+            matcher(context: import("@gatwech/core").HookEndpointContext): boolean;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+        }[];
+        before: ({
+            matcher(): true;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                context: {
+                    context: {
+                        oauthConfig: {
+                            skipStateCookieCheck: boolean;
+                        };
+                    };
+                };
+            } | undefined>;
+        } | {
+            matcher(context: import("@gatwech/core").HookEndpointContext): boolean;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+                context: import("better-call").MiddlewareContext<import("better-call").MiddlewareOptions, import("@gatwech/core").AuthContext<import("@gatwech/core").PayvoAuthOptions> & {
+                    returned?: unknown | undefined;
+                    responseHeaders?: Headers | undefined;
+                }>;
+            } | undefined>;
+        })[];
+    };
+};