@gatwech/auth 1.0.0-beta.18 → 1.0.0-beta.19

package/dist/src/plugins/audit-log/index.d.ts

@@ -0,0 +1,614 @@
+import type { AuthContext } from "@gatwech/core";
+import * as z from "zod";
+import { type AuditEventType } from "./events";
+import { schema } from "./schema";
+import type { AuditEvent, AuditLogOptions } from "./types";
+export * from "./events";
+export type * from "./types";
+export declare const AUDIT_LOG_ERROR_CODES: {
+    readonly AUDIT_LOG_ACCESS_DENIED: "You don't have access to these audit logs";
+    readonly AUDIT_LOG_UNAVAILABLE: "Audit logs are temporarily unavailable";
+};
+export declare const auditLog: (options?: AuditLogOptions | undefined) => {
+    id: "audit-log";
+    init(ctx: AuthContext<import("@gatwech/core").PayvoAuthOptions>): {
+        options: {
+            databaseHooks: {
+                user: {
+                    create: {
+                        after(user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, unknown>, context: import("@gatwech/core").GenericEndpointContext<import("@gatwech/core").PayvoAuthOptions> | undefined): Promise<void>;
+                    };
+                    update: {
+                        before(data: Partial<{
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        }> & Record<string, unknown>, context: import("@gatwech/core").GenericEndpointContext<import("@gatwech/core").PayvoAuthOptions> | undefined): Promise<{
+                            data: Partial<{
+                                id: string;
+                                createdAt: Date;
+                                updatedAt: Date;
+                                email: string;
+                                emailVerified: boolean;
+                                name: string;
+                                image?: string | null | undefined;
+                            }> & Record<string, unknown>;
+                        }>;
+                        after(user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, unknown>, context: import("@gatwech/core").GenericEndpointContext<import("@gatwech/core").PayvoAuthOptions> | undefined): Promise<void>;
+                    };
+                    delete: {
+                        after(user: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            email: string;
+                            emailVerified: boolean;
+                            name: string;
+                            image?: string | null | undefined;
+                        } & Record<string, unknown>, context: import("@gatwech/core").GenericEndpointContext<import("@gatwech/core").PayvoAuthOptions> | undefined): Promise<void>;
+                    };
+                };
+                session: {
+                    create: {
+                        after(session: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            userId: string;
+                            expiresAt: Date;
+                            token: string;
+                            ipAddress?: string | null | undefined;
+                            userAgent?: string | null | undefined;
+                        } & Record<string, unknown>, context: import("@gatwech/core").GenericEndpointContext<import("@gatwech/core").PayvoAuthOptions> | undefined): Promise<void>;
+                    };
+                };
+                account: {
+                    create: {
+                        after(account: {
+                            id: string;
+                            createdAt: Date;
+                            updatedAt: Date;
+                            providerId: string;
+                            accountId: string;
+                            userId: string;
+                            accessToken?: string | null | undefined;
+                            refreshToken?: string | null | undefined;
+                            idToken?: string | null | undefined;
+                            accessTokenExpiresAt?: Date | null | undefined;
+                            refreshTokenExpiresAt?: Date | null | undefined;
+                            scope?: string | null | undefined;
+                            password?: string | null | undefined;
+                        }, context: import("@gatwech/core").GenericEndpointContext<import("@gatwech/core").PayvoAuthOptions> | undefined): Promise<void>;
+                    };
+                };
+            };
+        };
+    };
+    hooks: {
+        before: {
+            matcher(context: import("@gatwech/core").HookEndpointContext): boolean;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+        }[];
+        after: {
+            matcher(context: import("@gatwech/core").HookEndpointContext): boolean;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+        }[];
+    };
+    endpoints: {
+        getAuditLogs: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                body?: undefined;
+            } & {
+                method?: "GET" | undefined;
+            } & {
+                query?: {
+                    limit?: string | number | undefined;
+                    offset?: string | number | undefined;
+                    eventType?: string | undefined;
+                    identifier?: string | undefined;
+                    organizationId?: string | undefined;
+                    userId?: string | undefined;
+                    startDate?: string | undefined;
+                    endDate?: string | undefined;
+                } | 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: {
+                    events: AuditEvent[];
+                    total: number;
+                    limit: number;
+                    offset: number;
+                };
+            } : {
+                events: AuditEvent[];
+                total: number;
+                limit: number;
+                offset: number;
+            }>;
+            options: {
+                method: "GET";
+                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;
+                        };
+                    };
+                }>)[];
+                query: z.ZodOptional<z.ZodObject<{
+                    limit: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+                    offset: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+                    eventType: z.ZodOptional<z.ZodString>;
+                    identifier: z.ZodOptional<z.ZodString>;
+                    organizationId: z.ZodOptional<z.ZodString>;
+                    userId: z.ZodOptional<z.ZodString>;
+                    startDate: z.ZodOptional<z.ZodString>;
+                    endDate: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                events: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                            eventType: {
+                                                                type: string;
+                                                            };
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                            userId: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            identifier: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            organizationId: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            path: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            ipAddress: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            userAgent: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            visitorId: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            eventData: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            createdAt: {
+                                                                type: string;
+                                                                format: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                total: {
+                                                    type: string;
+                                                };
+                                                limit: {
+                                                    type: string;
+                                                };
+                                                offset: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/audit-log/get-audit-logs";
+        };
+        getAllAuditLogs: {
+            <AsResponse extends boolean = false, ReturnHeaders extends boolean = false>(inputCtx_0?: ({
+                body?: undefined;
+            } & {
+                method?: "GET" | undefined;
+            } & {
+                query?: {
+                    limit?: string | number | undefined;
+                    offset?: string | number | undefined;
+                    eventType?: string | undefined;
+                    identifier?: string | undefined;
+                    organizationId?: string | undefined;
+                    userId?: string | undefined;
+                    startDate?: string | undefined;
+                    endDate?: string | undefined;
+                } | 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: {
+                    events: AuditEvent[];
+                    total: number;
+                    limit: number;
+                    offset: number;
+                };
+            } : {
+                events: AuditEvent[];
+                total: number;
+                limit: number;
+                offset: number;
+            }>;
+            options: {
+                method: "GET";
+                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;
+                        };
+                    };
+                }>)[];
+                query: z.ZodOptional<z.ZodObject<{
+                    limit: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+                    offset: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+                    eventType: z.ZodOptional<z.ZodString>;
+                    identifier: z.ZodOptional<z.ZodString>;
+                    organizationId: z.ZodOptional<z.ZodString>;
+                    userId: z.ZodOptional<z.ZodString>;
+                    startDate: z.ZodOptional<z.ZodString>;
+                    endDate: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: {
+                    openapi: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                events: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                        properties: {
+                                                            id: {
+                                                                type: string;
+                                                            };
+                                                            eventType: {
+                                                                type: string;
+                                                            };
+                                                            status: {
+                                                                type: string;
+                                                            };
+                                                            userId: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            identifier: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            organizationId: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            path: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            ipAddress: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            userAgent: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            visitorId: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            eventData: {
+                                                                type: string;
+                                                                nullable: boolean;
+                                                            };
+                                                            createdAt: {
+                                                                type: string;
+                                                                format: string;
+                                                            };
+                                                        };
+                                                    };
+                                                };
+                                                total: {
+                                                    type: string;
+                                                };
+                                                limit: {
+                                                    type: string;
+                                                };
+                                                offset: {
+                                                    type: string;
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/audit-log/get-all-audit-logs";
+        };
+        getEventTypes: {
+            <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;
+            }) | undefined): Promise<[AsResponse] extends [true] ? Response : [ReturnHeaders] extends [true] ? {
+                headers: Headers;
+                response: {
+                    types: AuditEventType[];
+                };
+            } : {
+                types: AuditEventType[];
+            }>;
+            options: {
+                method: "GET";
+                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: {
+                        operationId: string;
+                        summary: string;
+                        description: string;
+                        responses: {
+                            200: {
+                                description: string;
+                                content: {
+                                    "application/json": {
+                                        schema: {
+                                            type: "object";
+                                            properties: {
+                                                types: {
+                                                    type: string;
+                                                    items: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                            required: string[];
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            } & {
+                use: any[];
+            };
+            path: "/audit-log/get-event-types";
+        };
+    };
+    schema: {
+        auditLog: {
+            fields: {
+                eventType: {
+                    type: "string";
+                    required: true;
+                };
+                userId: {
+                    type: "string";
+                    required: false;
+                };
+                identifier: {
+                    type: "string";
+                    required: false;
+                };
+                organizationId: {
+                    type: "string";
+                    required: false;
+                };
+                status: {
+                    type: "string";
+                    required: true;
+                };
+                path: {
+                    type: "string";
+                    required: false;
+                };
+                ipAddress: {
+                    type: "string";
+                    required: false;
+                };
+                userAgent: {
+                    type: "string";
+                    required: false;
+                };
+                visitorId: {
+                    type: "string";
+                    required: false;
+                };
+                eventData: {
+                    type: "json";
+                    required: false;
+                };
+                createdAt: {
+                    type: "date";
+                    required: true;
+                };
+            };
+        };
+    };
+    $ERROR_CODES: {
+        readonly AUDIT_LOG_ACCESS_DENIED: "You don't have access to these audit logs";
+        readonly AUDIT_LOG_UNAVAILABLE: "Audit logs are temporarily unavailable";
+    };
+    options: {
+        database: boolean;
+        trackFailedSignIns: boolean;
+        adminRoles: string[];
+        remote?: {
+            apiUrl?: string | undefined;
+            apiKey?: string | undefined;
+            timeout?: number | undefined;
+            headers?: Record<string, string> | undefined;
+            batch?: {
+                maxSize?: number | undefined;
+                flushIntervalMs?: number | undefined;
+            } | undefined;
+        } | false | undefined;
+        onEvent?: ((event: AuditEvent) => void | Promise<void>) | undefined;
+        exclude?: AuditEventType[] | undefined;
+        schema?: import("..").InferOptionSchema<typeof schema> | undefined;
+    };
+};

package/dist/src/plugins/audit-log/registry.d.ts

@@ -0,0 +1,13 @@
+import type { AuthContext } from "@gatwech/core";
+import type { AuditEvent } from "./types";
+/** Shape shared by hook contexts, database hook contexts and `onRequest` */
+export type EventContext = {
+    path?: string | undefined;
+    headers?: Headers | undefined;
+    request?: Request | undefined;
+    body?: any;
+    context?: Partial<AuthContext> | undefined;
+};
+export type RecordAuditEvent = (ctx: EventContext | undefined, event: Pick<AuditEvent, "eventType"> & Partial<Omit<AuditEvent, "id" | "eventType" | "createdAt">>) => Promise<void>;
+export declare function registerAuditRecorder(context: Pick<AuthContext, "adapter">, record: RecordAuditEvent): void;
+export declare function getAuditRecorder(context: Pick<AuthContext, "adapter">): RecordAuditEvent | undefined;

package/dist/src/plugins/audit-log/remote.d.ts

@@ -0,0 +1,34 @@
+import type { AuthContext } from "@gatwech/core";
+import type { AuditEvent, AuditLogOptions } from "./types";
+export type RemoteQuery = {
+    limit: number;
+    offset: number;
+    eventType?: string | undefined;
+    identifier?: string | undefined;
+    userId?: string | undefined;
+    organizationId?: string | undefined;
+    startDate?: string | undefined;
+    endDate?: string | undefined;
+    userIds?: string[] | undefined;
+    organizationIds?: string[] | undefined;
+};
+interface RemoteSink {
+    push(event: AuditEvent, logger: AuthContext["logger"]): void;
+    flush(logger?: AuthContext["logger"]): Promise<void>;
+    query(query: RemoteQuery): Promise<{
+        events: AuditEvent[];
+        total: number;
+        limit: number;
+        offset: number;
+    }>;
+}
+/**
+ * Batches events and sends them to the hosted backend. Sending is never
+ * awaited by the auth flow, and failures are logged and dropped.
+ */
+export declare function createRemoteSink(options: AuditLogOptions["remote"]): {
+    sink: RemoteSink | null;
+    /** Remote logging was configured but the URL or key is missing */
+    misconfigured: boolean;
+};
+export {};