@absolutejs/auth 0.0.1

package/LICENSE

@@ -0,0 +1,24 @@
+```
+# Creative Commons Attribution-NonCommercial 4.0 International License (CC BY-NC 4.0)
+
+By using this project, you agree to the following terms under the Creative Commons Attribution-NonCommercial 4.0 International License.
+
+## License Summary
+This license allows you to:
+- **Share**: Copy and redistribute the material in any medium or format.
+- **Adapt**: Remix, transform, and build upon the material.
+
+**Under the following conditions**:
+- **Attribution**: You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use.
+- **Non-Commercial**: You may not use the material for commercial purposes.
+
+## Full License Text
+The full license text can be found at: https://creativecommons.org/licenses/by-nc/4.0/legalcode
+
+## Contact Information for Commercial Use
+For commercial use, licensing inquiries, or additional permissions, please contact:
+Alex Kahn
+alexkahndev@gmail.com
+alexkahndev.github.io
+```
+

package/README.md

@@ -0,0 +1,62 @@
+# Absolute Auth
+
+## Overview
+
+Absolute Auth is a TypeScript-based authentication system that provides a comprehensive solution for handling user authentication in web applications. It supports multiple authentication providers and offers features such as authorization, callback handling, token refresh, token revocation, and session management.
+
+## Installation
+
+### Prerequisites
+
+- [Elysia](https://elysiajs.com/) 
+
+### Steps to Install Dependencies
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/alexkahndev/absolute-auth.git
+   cd absolute-auth
+   ```
+
+2. Install the dependencies:
+   ```bash
+   bun install
+   ```
+
+## Usage
+
+### Running the Example Server
+
+Start the example server:
+   ```bash
+   bun dev
+   ```
+
+3. Open your browser and navigate to `http://localhost:3000` to test the authentication flow.
+
+## Authentication System
+
+### Features
+
+- **Authorization**: Handles the authorization process by generating the authorization URL and redirecting the user to the authentication provider.
+- **Callback Handling**: Handles the callback process by validating the authorization code, decoding the ID token, and creating or retrieving the user.
+- **Token Refresh**: Handles the token refresh process by refreshing the access token using the refresh token.
+- **Token Revocation**: Handles the token revocation process by revoking the access token.
+- **Session Management**: Manages user sessions, including creating, retrieving, and removing sessions.
+
+### Configuration Options
+
+- **Providers**: Configure multiple authentication providers such as Google, GitHub, and more.
+- **Routes**: Customize the routes for authorization, callback, logout, status, refresh, and revoke.
+- **Event Handlers**: Define custom event handlers for authorization, callback, status, refresh, logout, and revoke events.
+- **User Management**: Implement custom functions for creating and retrieving users.
+
+### Example Components and Utilities in the `example` Directory
+
+- `components/Example.tsx`: A React component that demonstrates the usage of the authentication system, including login, logout, and protected routes.
+- `components/Navbar.tsx`: A React component that provides a navigation bar with authentication-related links and actions.
+- `server.ts`: The main server file that sets up the example server, handles routes, and integrates the authentication system.
+
+## Note
+
+This project uses Bun and is built for Elysia.

package/dist/authorize.d.ts

@@ -0,0 +1,57 @@
+import Elysia from 'elysia';
+import type { ClientProviders, OAuthEventHandler } from './types';
+type AuthorizeProps = {
+    clientProviders: ClientProviders;
+    authorizeRoute?: string;
+    onAuthorize?: OAuthEventHandler;
+};
+export declare const authorize: ({ clientProviders, authorizeRoute, onAuthorize }: AuthorizeProps) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: import("@sinclair/typebox").TModule<{}>;
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    [x: string]: {
+        ":provider": {
+            get: {
+                body: unknown;
+                params: {
+                    provider: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: import("undici-types").Response;
+                    400: "Provider is required" | "Invalid provider";
+                    500: "Internal Server Error";
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export {};

package/dist/callback.d.ts

@@ -0,0 +1,49 @@
+import Elysia from 'elysia';
+import type { ClientProviders, CreateUser, GetUser, OAuthEventHandler } from './types';
+type CallbackProps<UserType> = {
+    clientProviders: ClientProviders;
+    callbackRoute?: string;
+    onCallback?: OAuthEventHandler;
+    getUser?: GetUser<UserType>;
+    createUser?: CreateUser<UserType>;
+};
+export declare const callback: <UserType>({ clientProviders, callbackRoute, onCallback, getUser, createUser }: CallbackProps<UserType>) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("./types").SessionRecord<UserType_1>;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    error: {};
+    typebox: import("elysia/dist/types").MergeTypeModule<import("@sinclair/typebox").TModule<{}, {}>, import("@sinclair/typebox").TModule<{}, {}>>;
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: import("undici-types").Response;
+                400: "Invalid provider" | "Invalid callback request" | "Invalid state mismatch" | "Code verifier not found and is required";
+                500: "Internal Server Error" | "Invalid user schema";
+                401: "No auth provider found";
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,138 @@
+import Elysia from 'elysia';
+import { OAuth2RequestError, ArcticFetchError } from 'arctic';
+import type { AbsoluteAuthProps } from './types';
+export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callbackRoute, logoutRoute, statusRoute, refreshRoute, revokeRoute, onAuthorize, onCallback, onStatus, onRefresh, onLogout, onRevoke, createUser, getUser }: AbsoluteAuthProps) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("./types").SessionRecord<UserType_1>;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    error: {
+        OAUTH2_REQUEST_ERROR: OAuth2RequestError;
+        ARCTIC_FETCH_ERROR: ArcticFetchError;
+    };
+    typebox: import("elysia/dist/types").MergeTypeModule<import("elysia/dist/types").MergeTypeModule<import("elysia/dist/types").MergeTypeModule<import("elysia/dist/types").MergeTypeModule<import("elysia/dist/types").MergeTypeModule<import("elysia/dist/types").MergeTypeModule<import("elysia/dist/types").MergeTypeModule<import("@sinclair/typebox").TModule<{}, {}>, import("@sinclair/typebox").TModule<{}, {}>>, import("@sinclair/typebox").TModule<{}, {}>>, import("elysia/dist/types").MergeTypeModule<import("@sinclair/typebox").TModule<{}, {}>, import("@sinclair/typebox").TModule<{}, {}>>>, import("@sinclair/typebox").TModule<{}, {}>>, import("@sinclair/typebox").TModule<{}, {}>>, import("elysia/dist/types").MergeTypeModule<import("@sinclair/typebox").TModule<{}, {}>, import("@sinclair/typebox").TModule<{}, {}>>>, import("elysia/dist/types").MergeTypeModule<import("@sinclair/typebox").TModule<{}, {}>, import("@sinclair/typebox").TModule<{}, {}>>>;
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: import("undici-types").Response;
+                500: "Internal Server Error";
+                401: "No auth provider found";
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        "access-token": {
+            post: {
+                body: unknown;
+                params: {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: undefined;
+                    400: "Invalid provider";
+                    401: "No auth provider found" | "No refresh token found";
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: import("undici-types").Response;
+                500: "Internal Server Error";
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: import("undici-types").Response;
+                500: "Internal Server Error";
+                401: "No auth provider found" | "No refresh token found" | "Provider is not refreshable";
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        ":provider": {
+            get: {
+                body: unknown;
+                params: {
+                    provider: string;
+                };
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: import("undici-types").Response;
+                    400: "Provider is required" | "Invalid provider";
+                    500: "Internal Server Error";
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: import("undici-types").Response;
+                400: "Invalid provider" | "Invalid callback request" | "Invalid state mismatch" | "Code verifier not found and is required";
+                500: "Internal Server Error" | "Invalid user schema";
+                401: "No auth provider found";
+            };
+        };
+    };
+}, {
+    derive: {
+        readonly protectRoute: (onAuth: () => Promise<Response>, onAuthFail?: (() => Promise<Response>) | undefined) => Promise<Response | import("elysia/dist/error").ElysiaCustomStatusResponse<401, "No session ID found", 401> | import("elysia/dist/error").ElysiaCustomStatusResponse<401, "No session found", 401>>;
+    };
+    resolve: {};
+    schema: import("elysia").MergeSchema<{
+        body: unknown;
+        headers: unknown;
+        query: unknown;
+        params: {};
+        cookie: unknown;
+        response: {};
+    }, {}, "">;
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;