@absolutejs/auth 0.0.1

package/dist/logout.d.ts

@@ -0,0 +1,43 @@
+import Elysia from 'elysia';
+import type { OAuthEventHandler } from './types';
+type LogoutProps = {
+    logoutRoute?: string;
+    onLogout?: OAuthEventHandler;
+};
+export declare const logout: ({ logoutRoute, onLogout }: LogoutProps) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: import("@sinclair/typebox").TModule<{}>;
+    error: {};
+}, {
+    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";
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export {};

package/dist/protectRoute.d.ts

@@ -0,0 +1,27 @@
+import Elysia from 'elysia';
+export declare const protectRoute: <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: {};
+}, {}, {
+    derive: {
+        readonly protectRoute: (onAuth: () => Promise<Response>, onAuthFail?: () => Promise<Response>) => 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<{}, {}, "">;
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/providers.d.ts

@@ -0,0 +1,56 @@
+import { AmazonCognito, AniList, Apple, Atlassian, Auth0, Authentik, Bitbucket, Box, Coinbase, Discord, Dribbble, Dropbox, Facebook, Figma, Intuit, GitHub, GitLab, Google, Kakao, KeyCloak, Lichess, Line, Linear, LinkedIn, MicrosoftEntraId, MyAnimeList, Notion, Okta, Osu, Patreon, Reddit, Roblox, Salesforce, Shikimori, Slack, Spotify, Strava, Tiltify, Tumblr, Twitch, Twitter, VK, WorkOS, Yahoo, Yandex, Zoom, FortyTwo } from 'arctic';
+export type ProvidersMap = {
+    AmazonCognito: typeof AmazonCognito;
+    AniList: typeof AniList;
+    Apple: typeof Apple;
+    Atlassian: typeof Atlassian;
+    Auth0: typeof Auth0;
+    Authentik: typeof Authentik;
+    Bitbucket: typeof Bitbucket;
+    Box: typeof Box;
+    Coinbase: typeof Coinbase;
+    Discord: typeof Discord;
+    Dribbble: typeof Dribbble;
+    Dropbox: typeof Dropbox;
+    Facebook: typeof Facebook;
+    Figma: typeof Figma;
+    FortyTwo: typeof FortyTwo;
+    GitHub: typeof GitHub;
+    GitLab: typeof GitLab;
+    Google: typeof Google;
+    Intuit: typeof Intuit;
+    Kakao: typeof Kakao;
+    KeyCloak: typeof KeyCloak;
+    Lichess: typeof Lichess;
+    Line: typeof Line;
+    Linear: typeof Linear;
+    LinkedIn: typeof LinkedIn;
+    MicrosoftEntraId: typeof MicrosoftEntraId;
+    MyAnimeList: typeof MyAnimeList;
+    Notion: typeof Notion;
+    Okta: typeof Okta;
+    Osu: typeof Osu;
+    Patreon: typeof Patreon;
+    Reddit: typeof Reddit;
+    Roblox: typeof Roblox;
+    Salesforce: typeof Salesforce;
+    Shikimori: typeof Shikimori;
+    Slack: typeof Slack;
+    Spotify: typeof Spotify;
+    Strava: typeof Strava;
+    Tiltify: typeof Tiltify;
+    Tumblr: typeof Tumblr;
+    Twitch: typeof Twitch;
+    Twitter: typeof Twitter;
+    VK: typeof VK;
+    WorkOS: typeof WorkOS;
+    Yahoo: typeof Yahoo;
+    Yandex: typeof Yandex;
+    Zoom: typeof Zoom;
+};
+export declare const providers: ProvidersMap;
+export declare const normalizedProviderKeys: Record<string, string>;
+export declare const userInfoURLs: Record<string, string>;
+export declare const issuerURLs: Record<string, string>;
+export declare const normalizedUserInfoURLKeys: Record<string, string>;
+export declare const normalizedIssuerURLKeys: Record<string, string>;

package/dist/refresh.d.ts

@@ -0,0 +1,44 @@
+import Elysia from 'elysia';
+import type { ClientProviders, OAuthEventHandler } from './types';
+type RefreshProps = {
+    clientProviders: ClientProviders;
+    refreshRoute?: string;
+    onRefresh?: OAuthEventHandler;
+};
+export declare const refresh: ({ clientProviders, refreshRoute, onRefresh }: RefreshProps) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: import("@sinclair/typebox").TModule<{}>;
+    error: {};
+}, {
+    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" | "No refresh token found" | "Provider is not refreshable";
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export {};

package/dist/revoke.d.ts

@@ -0,0 +1,46 @@
+import Elysia from 'elysia';
+import type { ClientProviders, OAuthEventHandler } from './types';
+type RevokeProps = {
+    clientProviders: ClientProviders;
+    revokeRoute?: string;
+    onRevoke?: OAuthEventHandler;
+};
+export declare const revoke: ({ clientProviders, revokeRoute, onRevoke }: RevokeProps) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: import("@sinclair/typebox").TModule<{}>;
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    [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";
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export {};

package/dist/sessionStore.d.ts

@@ -0,0 +1,26 @@
+import Elysia from 'elysia';
+import type { SessionRecord } from './types';
+export declare const sessionStore: <UserType>() => Elysia<"", {
+    decorator: {};
+    store: {
+        session: SessionRecord<UserType>;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    typebox: import("@sinclair/typebox").TModule<{}>;
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;

package/dist/status.d.ts

@@ -0,0 +1,44 @@
+import Elysia from 'elysia';
+import type { OAuthEventHandler } from './types';
+type StatusProps = {
+    statusRoute?: string;
+    onStatus?: OAuthEventHandler;
+};
+export declare const status: <UserType>({ statusRoute, onStatus }: StatusProps) => 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;
+                500: "Internal Server Error";
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export {};

package/dist/typeGuards.d.ts

@@ -0,0 +1,13 @@
+import { OAuth2Tokens } from 'arctic';
+import { providers, userInfoURLs, issuerURLs } from './providers';
+import type { Providers } from './types';
+export declare const isRefreshableProvider: (provider: InstanceType<(typeof providers)[Providers]>) => provider is InstanceType<(typeof providers)[Providers]> & {
+    refreshAccessToken: () => Promise<OAuth2Tokens>;
+};
+export declare const isRevocableProvider: (provider: InstanceType<(typeof providers)[Providers]>) => provider is InstanceType<(typeof providers)[Providers]> & {
+    revokeAccessToken: (token: string) => Promise<void>;
+};
+export declare const isValidProviderKey: (provider: string) => provider is keyof typeof providers;
+export declare const isValidUserInfoURLKey: (userInfoURLKey: string) => userInfoURLKey is keyof typeof userInfoURLs;
+export declare const isValidIssuerURLKey: (issuerURLKey: string) => issuerURLKey is keyof typeof issuerURLs;
+export declare const isValidUser: <UserType>(user: any) => user is UserType;

package/dist/types.d.ts

@@ -0,0 +1,50 @@
+import { providers } from './providers';
+export type Providers = keyof typeof providers;
+export type SessionData<UserType> = {
+    user: UserType;
+    expiresAt: number;
+};
+export type SessionRecord<UserType> = Record<string, SessionData<UserType> | undefined>;
+export type Oauth2ConfigOptions = {
+    [K in Providers]?: {
+        credentials: ConstructorParameters<(typeof providers)[K]>;
+        scopes?: string[];
+        searchParams?: [string, string][];
+    };
+};
+export type OAuthEventHandler = () => void;
+export type CreateUser<UserType> = ({ decodedIdToken, authProvider }: {
+    decodedIdToken: {
+        [key: string]: string | undefined;
+    };
+    authProvider: string;
+}) => Promise<UserType>;
+export type GetUser<UserType> = ({ decodedIdToken, authProvider }: {
+    decodedIdToken: {
+        [key: string]: string | undefined;
+    };
+    authProvider: string;
+}) => Promise<UserType | null>;
+export type AbsoluteAuthProps = {
+    config: Oauth2ConfigOptions;
+    authorizeRoute?: string;
+    callbackRoute?: string;
+    refreshRoute?: string;
+    revokeRoute?: string;
+    logoutRoute?: string;
+    statusRoute?: string;
+    onAuthorize?: OAuthEventHandler;
+    onCallback?: OAuthEventHandler;
+    onStatus?: OAuthEventHandler;
+    onRefresh?: OAuthEventHandler;
+    onLogout?: OAuthEventHandler;
+    onRevoke?: OAuthEventHandler;
+    createUser?: CreateUser<any>;
+    getUser?: GetUser<any>;
+};
+export type ClientProviders = Record<string, {
+    providerInstance: InstanceType<(typeof providers)[Providers]>;
+    scopes: string[];
+    searchParams: [string, string][];
+    userInfoURL?: string;
+}>;

package/package.json

@@ -0,0 +1,53 @@
+{
+	"version": "0.0.1",
+	"name": "@absolutejs/auth",
+	"description": "An authorization library for absolutejs",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/alexkahndev/absolute-auth.git"
+	},
+	"main": "dist/index.js",
+	"license": "CC BY-NC 4.0",
+	"author": "Alex Kahn",
+	"scripts": {
+		"build": "bun build src/index.ts --outdir dist --minify --splitting && tsc --emitDeclarationOnly --project tsconfig.dts.json",
+		"test": "echo \"Error: no test specified\" && exit 1",
+		"format": "prettier --write \"./**/*.{js,jsx,ts,tsx,css,json}\"",
+		"dev": "bun run --watch example/server.ts",
+		"db:generate": "drizzle-kit generate --schema ./example/db/schema.ts --dialect postgresql",
+		"db:migrate": "bun run ./example/db/migrate.ts",
+		"db:studio": "drizzle-kit studio"
+	},
+	"keywords": [
+		"authorization",
+		"authentication",
+		"absolutejs",
+		"elysia",
+		"oauth"
+	],
+	"types": "dist/index.d.ts",
+	"dependencies": {
+		"arctic": "3.0.0",
+		"elysia": "1.2.9"
+	},
+	"devDependencies": {
+		"@elysiajs/static": "1.2.0",
+		"@neondatabase/serverless": "0.10.4",
+		"@types/bun": "1.1.14",
+		"@types/react": "19.0.2",
+		"@types/react-dom": "19.0.2",
+		"drizzle-kit": "0.28.0",
+		"drizzle-orm": "0.36.1",
+		"prettier": "3.4.2",
+		"react": "19.0.0",
+		"react-dom": "19.0.0",
+		"tsup": "8.3.5",
+		"typescript": "^5.7.2"
+	},
+	"module": "dist/index.js",
+	"files": [
+		"dist/",
+		"README.md",
+		"LICENSE"
+	]
+}