@gatwech/auth 1.0.0-beta.18

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+export type { StandardSchemaV1 } from "@gatwech/core";
+export * from "@gatwech/core";
+export { getCurrentAdapter } from "@gatwech/core/context";
+export * from "@gatwech/core/env";
+export * from "@gatwech/core/error";
+export * from "@gatwech/core/oauth2";
+export * from "@gatwech/core/utils";
+export type * from "better-call";
+export * from "./auth";
+export * from "./types";
+export type { Prettify, UnionToIntersection } from "./types/helper";
+export * from "./utils";
+export { createTelemetry, getTelemetryAuthConfig, type TelemetryEvent, } from "@gatwech/telemetry";
+export { APIError } from "./api";

package/dist/src/init.d.ts

@@ -0,0 +1,2 @@
+import type { AuthContext, PayvoAuthOptions } from "@gatwech/core";
+export declare const init: (options: PayvoAuthOptions) => Promise<AuthContext>;

package/dist/src/integrations/next-js.d.ts

@@ -0,0 +1,15 @@
+export declare function toNextJsHandler(auth: {
+    handler: (request: Request) => Promise<Response>;
+} | ((request: Request) => Promise<Response>)): {
+    GET: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+};
+export declare const nextCookies: () => {
+    id: "next-cookies";
+    hooks: {
+        after: {
+            matcher(ctx: import("@gatwech/core").HookEndpointContext): true;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+        }[];
+    };
+};

package/dist/src/integrations/node.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingHttpHeaders } from "http";
+import type { Auth } from "../auth";
+export declare const toNodeHandler: (auth: {
+    handler: Auth["handler"];
+} | Auth["handler"]) => (req: import("http").IncomingMessage, res: import("http").ServerResponse) => Promise<void>;
+export declare function fromNodeHeaders(nodeHeaders: IncomingHttpHeaders): Headers;

package/dist/src/integrations/react-start.d.ts

@@ -0,0 +1,9 @@
+export declare const reactStartCookies: () => {
+    id: "react-start-cookies";
+    hooks: {
+        after: {
+            matcher(ctx: import("@gatwech/core").HookEndpointContext): true;
+            handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+        }[];
+    };
+};

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

@@ -0,0 +1,4 @@
+export * from "@gatwech/core/oauth2";
+export * from "./link-account";
+export * from "./state";
+export * from "./utils";

package/dist/src/oauth2/link-account.d.ts

@@ -0,0 +1,41 @@
+import type { GenericEndpointContext } from "@gatwech/core";
+import type { Account, User } from "../types";
+export declare function handleOAuthUserInfo(c: GenericEndpointContext, { userInfo, account, callbackURL, disableSignUp, overrideUserInfo, }: {
+    userInfo: Omit<User, "createdAt" | "updatedAt">;
+    account: Omit<Account, "id" | "userId" | "createdAt" | "updatedAt">;
+    callbackURL?: string | undefined;
+    disableSignUp?: boolean | undefined;
+    overrideUserInfo?: boolean | undefined;
+}): Promise<{
+    error: string;
+    data: null;
+    isRegister?: undefined;
+} | {
+    error: string;
+    data: null;
+    isRegister: boolean;
+} | {
+    data: {
+        session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+        };
+        user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+        };
+    };
+    error: null;
+    isRegister: boolean;
+}>;

package/dist/src/oauth2/state.d.ts

@@ -0,0 +1,21 @@
+import type { GenericEndpointContext } from "@gatwech/core";
+export declare function generateState(c: GenericEndpointContext, link: {
+    email: string;
+    userId: string;
+} | undefined, additionalData: Record<string, any> | false | undefined): Promise<{
+    state: string;
+    codeVerifier: string;
+}>;
+export declare function parseState(c: GenericEndpointContext): Promise<{
+    [x: string]: unknown;
+    callbackURL: string;
+    codeVerifier: string;
+    expiresAt: number;
+    errorURL?: string | undefined;
+    newUserURL?: string | undefined;
+    link?: {
+        email: string;
+        userId: string;
+    } | undefined;
+    requestSignUp?: boolean | undefined;
+}>;

package/dist/src/oauth2/utils.d.ts

@@ -0,0 +1,3 @@
+import type { AuthContext } from "@gatwech/core";
+export declare function decryptOAuthToken(token: string, ctx: AuthContext): string | Promise<string>;
+export declare function setTokenUtil(token: string | null | undefined, ctx: AuthContext): string | Promise<string> | null | undefined;

package/dist/src/plugins/access/access.d.ts

@@ -0,0 +1,25 @@
+import type { Statements, Subset } from "./types";
+export type AuthorizeResponse = {
+    success: false;
+    error: string;
+} | {
+    success: true;
+    error?: never | undefined;
+};
+export declare function role<TStatements extends Statements>(statements: TStatements): {
+    authorize<K extends keyof TStatements>(request: { [key in K]?: TStatements[key] | {
+        actions: TStatements[key];
+        connector: "OR" | "AND";
+    }; }, connector?: "OR" | "AND"): AuthorizeResponse;
+    statements: TStatements;
+};
+export declare function createAccessControl<const TStatements extends Statements>(s: TStatements): {
+    newRole<K extends keyof TStatements>(statements: Subset<K, TStatements>): {
+        authorize<K_1 extends K>(request: K_1 extends infer T extends keyof Subset<K, TStatements> ? { [key in T]?: Subset<K, TStatements>[key] | {
+            actions: Subset<K, TStatements>[key];
+            connector: "OR" | "AND";
+        } | undefined; } : never, connector?: "OR" | "AND"): AuthorizeResponse;
+        statements: Subset<K, TStatements>;
+    };
+    statements: TStatements;
+};

package/dist/src/plugins/access/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./access";
+export * from "./types";

package/dist/src/plugins/access/types.d.ts

@@ -0,0 +1,14 @@
+import type { LiteralString } from "../../types/helper";
+import type { AuthorizeResponse, createAccessControl } from "./access";
+export type SubArray<T extends unknown[] | readonly unknown[] | any[]> = T[number][];
+export type Subset<K extends keyof R, R extends Record<string | LiteralString, readonly string[] | readonly LiteralString[]>> = {
+    [P in K]: SubArray<R[P]>;
+};
+export type Statements = {
+    readonly [resource: string]: readonly LiteralString[];
+};
+export type AccessControl<TStatements extends Statements = Statements> = ReturnType<typeof createAccessControl<TStatements>>;
+export type Role<TStatements extends Statements = Record<string, any>> = {
+    authorize: (request: any, connector?: ("OR" | "AND") | undefined) => AuthorizeResponse;
+    statements: TStatements;
+};

package/dist/src/plugins/additional-fields/client.d.ts

@@ -0,0 +1,91 @@
+import type { DBFieldAttribute } from "@gatwech/core/db";
+import type { PayvoAuthOptions, PayvoAuthPlugin } from "../../types";
+export declare const inferAdditionalFields: <T, S extends {
+    user?: {
+        [key: string]: DBFieldAttribute;
+    } | undefined;
+    session?: {
+        [key: string]: DBFieldAttribute;
+    } | undefined;
+} = {}>(schema?: S | undefined) => {
+    id: "additional-fields-client";
+    $InferServerPlugin: ((T extends PayvoAuthOptions ? T : T extends {
+        options: PayvoAuthOptions;
+    } ? T["options"] : never) extends never ? S extends {
+        user?: {
+            [key: string]: DBFieldAttribute;
+        } | undefined;
+        session?: {
+            [key: string]: DBFieldAttribute;
+        } | undefined;
+    } ? {
+        id: "additional-fields-client";
+        schema: {
+            user: {
+                fields: S["user"] extends object ? S["user"] : {};
+            };
+            session: {
+                fields: S["session"] extends object ? S["session"] : {};
+            };
+        };
+    } : never : (T extends PayvoAuthOptions ? T : T extends {
+        options: PayvoAuthOptions;
+    } ? T["options"] : never) extends PayvoAuthOptions ? {
+        id: "additional-fields";
+        schema: {
+            user: {
+                fields: (T extends PayvoAuthOptions ? T : T extends {
+                    options: PayvoAuthOptions;
+                } ? T["options"] : never)["user"] extends {
+                    additionalFields: infer U;
+                } ? U : {};
+            };
+            session: {
+                fields: (T extends PayvoAuthOptions ? T : T extends {
+                    options: PayvoAuthOptions;
+                } ? T["options"] : never)["session"] extends {
+                    additionalFields: infer U;
+                } ? U : {};
+            };
+        };
+    } : never) extends PayvoAuthPlugin ? (T extends PayvoAuthOptions ? T : T extends {
+        options: PayvoAuthOptions;
+    } ? T["options"] : never) extends never ? S extends {
+        user?: {
+            [key: string]: DBFieldAttribute;
+        } | undefined;
+        session?: {
+            [key: string]: DBFieldAttribute;
+        } | undefined;
+    } ? {
+        id: "additional-fields-client";
+        schema: {
+            user: {
+                fields: S["user"] extends object ? S["user"] : {};
+            };
+            session: {
+                fields: S["session"] extends object ? S["session"] : {};
+            };
+        };
+    } : never : (T extends PayvoAuthOptions ? T : T extends {
+        options: PayvoAuthOptions;
+    } ? T["options"] : never) extends PayvoAuthOptions ? {
+        id: "additional-fields";
+        schema: {
+            user: {
+                fields: (T extends PayvoAuthOptions ? T : T extends {
+                    options: PayvoAuthOptions;
+                } ? T["options"] : never)["user"] extends {
+                    additionalFields: infer U;
+                } ? U : {};
+            };
+            session: {
+                fields: (T extends PayvoAuthOptions ? T : T extends {
+                    options: PayvoAuthOptions;
+                } ? T["options"] : never)["session"] extends {
+                    additionalFields: infer U;
+                } ? U : {};
+            };
+        };
+    } : never : undefined;
+};

package/dist/src/plugins/admin/access/index.d.ts

@@ -0,0 +1 @@
+export * from "./statement";

package/dist/src/plugins/admin/access/statement.d.ts

@@ -0,0 +1,110 @@
+export declare const defaultStatements: {
+    readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+    readonly session: readonly ["list", "revoke", "delete"];
+};
+export declare const defaultAc: {
+    newRole<K extends "session" | "user">(statements: import("../../access").Subset<K, {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    }>): {
+        authorize<K_1 extends K>(request: K_1 extends infer T extends keyof import("../../access").Subset<K, {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }> ? { [key in T]?: import("../../access").Subset<K, {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>[key] | {
+            actions: import("../../access").Subset<K, {
+                readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                readonly session: readonly ["list", "revoke", "delete"];
+            }>[key];
+            connector: "OR" | "AND";
+        } | undefined; } : never, connector?: "OR" | "AND"): import("../../access").AuthorizeResponse;
+        statements: import("../../access").Subset<K, {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>;
+    };
+    statements: {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    };
+};
+export declare const adminAc: {
+    authorize<K extends "session" | "user">(request: K extends infer T extends keyof import("../../access").Subset<"session" | "user", {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    }> ? { [key in T]?: import("../../access").Subset<"session" | "user", {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    }>[key] | {
+        actions: import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>[key];
+        connector: "OR" | "AND";
+    } | undefined; } : never, connector?: "OR" | "AND"): import("../../access").AuthorizeResponse;
+    statements: import("../../access").Subset<"session" | "user", {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    }>;
+};
+export declare const userAc: {
+    authorize<K extends "session" | "user">(request: K extends infer T extends keyof import("../../access").Subset<"session" | "user", {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    }> ? { [key in T]?: import("../../access").Subset<"session" | "user", {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    }>[key] | {
+        actions: import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>[key];
+        connector: "OR" | "AND";
+    } | undefined; } : never, connector?: "OR" | "AND"): import("../../access").AuthorizeResponse;
+    statements: import("../../access").Subset<"session" | "user", {
+        readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+        readonly session: readonly ["list", "revoke", "delete"];
+    }>;
+};
+export declare const defaultRoles: {
+    admin: {
+        authorize<K extends "session" | "user">(request: K extends infer T extends keyof import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }> ? { [key in T]?: import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>[key] | {
+            actions: import("../../access").Subset<"session" | "user", {
+                readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                readonly session: readonly ["list", "revoke", "delete"];
+            }>[key];
+            connector: "OR" | "AND";
+        } | undefined; } : never, connector?: "OR" | "AND"): import("../../access").AuthorizeResponse;
+        statements: import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>;
+    };
+    user: {
+        authorize<K extends "session" | "user">(request: K extends infer T extends keyof import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }> ? { [key in T]?: import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>[key] | {
+            actions: import("../../access").Subset<"session" | "user", {
+                readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+                readonly session: readonly ["list", "revoke", "delete"];
+            }>[key];
+            connector: "OR" | "AND";
+        } | undefined; } : never, connector?: "OR" | "AND"): import("../../access").AuthorizeResponse;
+        statements: import("../../access").Subset<"session" | "user", {
+            readonly user: readonly ["create", "list", "set-role", "ban", "impersonate", "delete", "set-password", "get", "update"];
+            readonly session: readonly ["list", "revoke", "delete"];
+        }>;
+    };
+};