@absolutejs/auth 0.4.0 → 0.5.0

package/dist/src/authorize.d.ts

@@ -1,8 +1,8 @@
 import { Elysia } from 'elysia';
-import { ClientProviders } from './types';
+import { AuthorizeRoute, ClientProviders } from './types';
 type AuthorizeProps = {
     clientProviders: ClientProviders;
-    authorizeRoute?: string;
+    authorizeRoute?: AuthorizeRoute;
     onAuthorize?: () => void;
 };
 export declare const authorize: ({ clientProviders, authorizeRoute, onAuthorize }: AuthorizeProps) => Elysia<"", {
@@ -30,7 +30,8 @@ export declare const authorize: ({ clientProviders, authorizeRoute, onAuthorize
                 headers: unknown;
                 response: {
                     200: import("undici-types").Response;
-                    400: "Provider is required" | "Invalid provider";
+                    400: "Cookies are missing" | "Provider is required" | "Invalid provider";
+                    401: "Invalid provider";
                     500: `${string} - ${string}` | `Unknown error: ${string}`;
                     422: {
                         type: "validation";
@@ -45,6 +46,36 @@ export declare const authorize: ({ clientProviders, authorizeRoute, onAuthorize
             };
         };
     };
+} | {
+    [x: string]: {
+        ":provider": {
+            [x: string]: {
+                get: {
+                    body: unknown;
+                    params: {
+                        provider: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("undici-types").Response;
+                        400: "Cookies are missing" | "Provider is required" | "Invalid provider";
+                        401: "Invalid provider";
+                        500: `${string} - ${string}` | `Unknown error: ${string}`;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
 }, {
     derive: {};
     resolve: {};

package/dist/src/callback.d.ts

@@ -1,8 +1,8 @@
 import { Elysia } from 'elysia';
-import { ClientProviders, OnCallback } from './types';
+import { ClientProviders, OnCallback, RouteString } from './types';
 type CallbackProps<UserType> = {
     clientProviders: ClientProviders;
-    callbackRoute?: string;
+    callbackRoute?: RouteString;
     onCallback?: OnCallback<UserType>;
 };
 export declare const callback: <UserType>({ clientProviders, callbackRoute, onCallback }: CallbackProps<UserType>) => Elysia<"", {
@@ -29,9 +29,9 @@ export declare const callback: <UserType>({ clientProviders, callbackRoute, onCa
             headers: unknown;
             response: {
                 200: import("undici-types").Response;
-                500: `${string} - ${string}` | `Failed to validate authorization code: Unknown error: ${string}`;
-                400: "Invalid callback request" | "Invalid state mismatch" | "Code verifier not found and is required";
+                400: "Cookies are missing" | "Invalid callback request" | "Invalid state mismatch" | "Code verifier not found and is required";
                 401: "Invalid provider" | "No auth provider found";
+                500: `${string} - ${string}` | `Failed to validate authorization code: Unknown error: ${string}`;
             };
         };
     };

package/dist/src/index.d.ts

@@ -1,25 +1,21 @@
-import { OAuth2RequestError, ArcticFetchError } from 'arctic';
 import { Elysia } from 'elysia';
 import { AbsoluteAuthProps } from './types';
-export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callbackRoute, logoutRoute, statusRoute, refreshRoute, revokeRoute, onAuthorize, onCallback, onStatus, onRefresh, onLogout, onRevoke }: AbsoluteAuthProps<UserType>) => Elysia<"", {
+export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callbackRoute, profileRoute, signoutRoute, statusRoute, refreshRoute, revokeRoute, onAuthorize, onProfile, onCallback, onStatus, onRefresh, onSignOut, onRevocation }: AbsoluteAuthProps<UserType>) => Elysia<"", {
     decorator: {};
     store: {
-        session: import("./types").SessionRecord<UserType> & import("./types").SessionRecord<unknown>;
+        session: import("./types").SessionRecord<unknown> & import("./types").SessionRecord<UserType>;
     };
     derive: {};
     resolve: {};
 }, {
-    error: {
-        OAUTH2_REQUEST_ERROR: OAuth2RequestError;
-        ARCTIC_FETCH_ERROR: ArcticFetchError;
-    };
+    error: {};
     typebox: import("@sinclair/typebox").TModule<{}, {}>;
 }, {
     schema: {};
     macro: {};
     macroFn: {};
     parser: {};
-}, {
+}, ((({
     [x: string]: {
         post: {
             body: unknown;
@@ -28,29 +24,29 @@ export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callback
             headers: unknown;
             response: {
                 200: Response;
+                400: "Cookies are missing";
                 401: "No auth provider found";
-                500: `Failed to logout: ${string}`;
+                500: `Failed to signout: ${string}`;
             };
         };
     };
 } & {
     [x: string]: {
-        "access-token": {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    401: "No auth provider found" | "No refresh token found";
-                    501: "Provider does not support revocation";
-                    500: `Failed to revoke token: ${string}`;
-                };
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+                400: "Cookies are missing" | "Invalid provider";
+                401: "Invalid provider" | "No auth provider found" | "No user session found";
+                501: "Provider does not support revocation";
+                500: `Failed to revoke token: ${string}`;
             };
         };
     };
-} & {
+} & ({
     [x: string]: {
         get: {
             body: unknown;
@@ -59,12 +55,14 @@ export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callback
             headers: unknown;
             response: {
                 200: Response;
+                400: "Cookies are missing";
+                401: "Invalid provider";
                 501: "Provider is not refreshable";
                 500: `Error: ${string} - ${string}` | `Unknown Error: ${string}`;
             };
         };
     };
-} & {
+} & ({
     [x: string]: {
         post: {
             body: unknown;
@@ -73,13 +71,14 @@ export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callback
             headers: unknown;
             response: {
                 200: Response;
-                401: "No auth provider found" | "No refresh token found";
+                400: "Cookies are missing" | "Invalid provider" | "No refresh token found";
+                401: "Invalid provider" | "No auth provider found" | "No user session found";
                 501: "Provider is not refreshable";
-                500: `Failed to refresh token: ${string}` | `Faile to refresh token: Unknown error: ${string}`;
+                500: `Failed to refresh token: ${string}`;
             };
         };
     };
-} & {
+} & ({
     [x: string]: {
         ":provider": {
             get: {
@@ -91,7 +90,8 @@ export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callback
                 headers: unknown;
                 response: {
                     200: import("undici-types").Response;
-                    400: "Provider is required" | "Invalid provider";
+                    400: "Cookies are missing" | "Provider is required" | "Invalid provider";
+                    401: "Invalid provider";
                     500: `${string} - ${string}` | `Unknown error: ${string}`;
                     422: {
                         type: "validation";
@@ -106,7 +106,37 @@ export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callback
             };
         };
     };
-} & {
+} | {
+    [x: string]: {
+        ":provider": {
+            [x: string]: {
+                get: {
+                    body: unknown;
+                    params: {
+                        provider: string;
+                    };
+                    query: unknown;
+                    headers: unknown;
+                    response: {
+                        200: import("undici-types").Response;
+                        400: "Cookies are missing" | "Provider is required" | "Invalid provider";
+                        401: "Invalid provider";
+                        500: `${string} - ${string}` | `Unknown error: ${string}`;
+                        422: {
+                            type: "validation";
+                            on: string;
+                            summary?: string;
+                            message?: string;
+                            found?: unknown;
+                            property?: string;
+                            expected?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
+})))) & {
     [x: string]: {
         get: {
             body: unknown;
@@ -115,15 +145,30 @@ export declare const absoluteAuth: <UserType>({ config, authorizeRoute, callback
             headers: unknown;
             response: {
                 200: import("undici-types").Response;
-                500: `${string} - ${string}` | `Failed to validate authorization code: Unknown error: ${string}`;
-                400: "Invalid callback request" | "Invalid state mismatch" | "Code verifier not found and is required";
+                400: "Cookies are missing" | "Invalid callback request" | "Invalid state mismatch" | "Code verifier not found and is required";
                 401: "Invalid provider" | "No auth provider found";
+                500: `${string} - ${string}` | `Failed to validate authorization code: Unknown error: ${string}`;
             };
         };
     };
-}, {
+}) & {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+                400: "Cookies are missing";
+                401: "Invalid provider" | "No auth provider found" | "No user session found";
+                500: `${string} - ${string}` | `Failed to validate authorization code: Unknown error: ${string}`;
+            };
+        };
+    };
+}) & {}, {
     derive: {
-        readonly protectRoute: (handleAuth: () => Promise<Response>, handleAuthFail?: () => Promise<Response>) => Promise<Response | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session ID found", 401> | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session found", 401>>;
+        readonly protectRoute: (handleAuth: () => Promise<Response>, handleAuthFail?: () => Promise<Response>) => Promise<Response | import("elysia/error").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session ID found", 401> | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session found", 401>>;
     };
     resolve: {};
     schema: import("elysia").MergeSchema<{

package/dist/src/profile.d.ts

@@ -0,0 +1,47 @@
+import { Elysia } from 'elysia';
+import { ClientProviders, OnProfile, RouteString } from './types';
+type ProfileProps = {
+    clientProviders: ClientProviders;
+    profileRoute?: RouteString;
+    onProfile?: OnProfile;
+};
+export declare const profile: <UserType>({ clientProviders, profileRoute, onProfile }: ProfileProps) => Elysia<"", {
+    decorator: {};
+    store: {
+        session: import("./types").SessionRecord<UserType>;
+    };
+    derive: {};
+    resolve: {};
+}, {
+    error: {};
+    typebox: import("@sinclair/typebox").TModule<{}, {}>;
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+                400: "Cookies are missing";
+                401: "Invalid provider" | "No auth provider found" | "No user session found";
+                500: `${string} - ${string}` | `Failed to validate authorization code: Unknown error: ${string}`;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+export {};

package/dist/src/protectRoute.d.ts

@@ -16,7 +16,7 @@ export declare const protectRoute: <UserType>() => Elysia<"", {
     parser: {};
 }, {}, {
     derive: {
-        readonly protectRoute: (handleAuth: () => Promise<Response>, handleAuthFail?: () => Promise<Response>) => Promise<Response | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session ID found", 401> | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session found", 401>>;
+        readonly protectRoute: (handleAuth: () => Promise<Response>, handleAuthFail?: () => Promise<Response>) => Promise<Response | import("elysia/error").ElysiaCustomStatusResponse<"Bad Request", "Cookies are missing", 400> | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session ID found", 401> | import("elysia/error").ElysiaCustomStatusResponse<"Unauthorized", "No session found", 401>>;
     };
     resolve: {};
     schema: import("elysia").MergeSchema<{}, {}, "">;

package/dist/src/refresh.d.ts

@@ -1,18 +1,20 @@
 import { Elysia } from 'elysia';
-import { ClientProviders } from './types';
+import { ClientProviders, OnRefresh, RouteString } from './types';
 type RefreshProps = {
     clientProviders: ClientProviders;
-    refreshRoute?: string;
-    onRefresh?: () => void;
+    refreshRoute?: RouteString;
+    onRefresh?: OnRefresh;
 };
-export declare const refresh: ({ clientProviders, refreshRoute, onRefresh }: RefreshProps) => Elysia<"", {
+export declare const refresh: <UserType>({ clientProviders, refreshRoute, onRefresh }: RefreshProps) => Elysia<"", {
     decorator: {};
-    store: {};
+    store: {
+        session: import("./types").SessionRecord<UserType>;
+    };
     derive: {};
     resolve: {};
 }, {
-    typebox: import("@sinclair/typebox").TModule<{}>;
     error: {};
+    typebox: import("@sinclair/typebox").TModule<{}, {}>;
 }, {
     schema: {};
     macro: {};
@@ -27,9 +29,10 @@ export declare const refresh: ({ clientProviders, refreshRoute, onRefresh }: Ref
             headers: unknown;
             response: {
                 200: Response;
-                401: "No auth provider found" | "No refresh token found";
+                400: "Cookies are missing" | "Invalid provider" | "No refresh token found";
+                401: "Invalid provider" | "No auth provider found" | "No user session found";
                 501: "Provider is not refreshable";
-                500: `Failed to refresh token: ${string}` | `Faile to refresh token: Unknown error: ${string}`;
+                500: `Failed to refresh token: ${string}`;
             };
         };
     };

package/dist/src/revoke.d.ts

@@ -1,18 +1,20 @@
 import { Elysia } from 'elysia';
-import { ClientProviders } from './types';
+import { ClientProviders, OnRevocation, RouteString } from './types';
 type RevokeProps = {
     clientProviders: ClientProviders;
-    revokeRoute?: string;
-    onRevoke?: () => void;
+    revokeRoute?: RouteString;
+    onRevocation?: OnRevocation;
 };
-export declare const revoke: ({ clientProviders, revokeRoute, onRevoke }: RevokeProps) => Elysia<"", {
+export declare const revoke: <UserType>({ clientProviders, revokeRoute, onRevocation }: RevokeProps) => Elysia<"", {
     decorator: {};
-    store: {};
+    store: {
+        session: import("./types").SessionRecord<UserType>;
+    };
     derive: {};
     resolve: {};
 }, {
-    typebox: import("@sinclair/typebox").TModule<{}>;
     error: {};
+    typebox: import("@sinclair/typebox").TModule<{}, {}>;
 }, {
     schema: {};
     macro: {};
@@ -20,18 +22,17 @@ export declare const revoke: ({ clientProviders, revokeRoute, onRevoke }: Revoke
     parser: {};
 }, {
     [x: string]: {
-        "access-token": {
-            post: {
-                body: unknown;
-                params: {};
-                query: unknown;
-                headers: unknown;
-                response: {
-                    200: Response;
-                    401: "No auth provider found" | "No refresh token found";
-                    501: "Provider does not support revocation";
-                    500: `Failed to revoke token: ${string}`;
-                };
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+                400: "Cookies are missing" | "Invalid provider";
+                401: "Invalid provider" | "No auth provider found" | "No user session found";
+                501: "Provider does not support revocation";
+                500: `Failed to revoke token: ${string}`;
             };
         };
     };

package/dist/src/{logout.d.ts → signout.d.ts}

@@ -1,9 +1,10 @@
 import { Elysia } from 'elysia';
-type LogoutProps = {
-    logoutRoute?: string;
-    onLogout?: () => void;
+import { RouteString } from './types';
+type SignOutProps = {
+    signoutRoute?: RouteString;
+    onSignOut?: () => void;
 };
-export declare const logout: ({ logoutRoute, onLogout }: LogoutProps) => Elysia<"", {
+export declare const signout: ({ signoutRoute, onSignOut }: SignOutProps) => Elysia<"", {
     decorator: {};
     store: {};
     derive: {};
@@ -25,8 +26,9 @@ export declare const logout: ({ logoutRoute, onLogout }: LogoutProps) => Elysia<
             headers: unknown;
             response: {
                 200: Response;
+                400: "Cookies are missing";
                 401: "No auth provider found";
-                500: `Failed to logout: ${string}`;
+                500: `Failed to signout: ${string}`;
             };
         };
     };

package/dist/src/status.d.ts

@@ -1,8 +1,8 @@
 import { Elysia } from 'elysia';
-import { ClientProviders } from './types';
+import { ClientProviders, RouteString } from './types';
 type StatusProps = {
     clientProviders: ClientProviders;
-    statusRoute?: string;
+    statusRoute?: RouteString;
     onStatus?: () => void;
 };
 export declare const status: <UserType>({ clientProviders, statusRoute, onStatus }: StatusProps) => Elysia<"", {
@@ -29,6 +29,8 @@ export declare const status: <UserType>({ clientProviders, statusRoute, onStatus
             headers: unknown;
             response: {
                 200: Response;
+                400: "Cookies are missing";
+                401: "Invalid provider";
                 501: "Provider is not refreshable";
                 500: `Error: ${string} - ${string}` | `Unknown Error: ${string}`;
             };

package/dist/src/typeGuards.d.ts

@@ -1,12 +1,2 @@
-import { OAuth2Tokens } from 'arctic';
-import { providers } from './providers';
-import { 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 isValidUser: <UserType>(user: unknown) => user is UserType;
 export declare const isNonEmptyString: (str: string | null | undefined) => str is string;

package/dist/src/types.d.ts

@@ -1,59 +1,69 @@
+import { CredentialsFor, OAuth2Client, OAuth2TokenResponse, ProviderOption } from 'citra';
 import { Cookie } from 'elysia';
-import { providers } from './providers';
 type SessionData<UserType> = {
     user: UserType;
+    accessToken: string;
+    refreshToken?: string;
     expiresAt: number;
 };
 type Oauth2ConfigOptions = {
-    [K in Providers]?: {
-        credentials: ConstructorParameters<(typeof providers)[K]>;
-        scopes?: string[];
+    [Provider in ProviderOption]?: {
+        credentials: CredentialsFor<Provider>;
+        scope?: string[];
         searchParams?: [string, string][];
     };
 };
-export type Providers = keyof typeof providers;
 export type SessionRecord<UserType> = Record<string, SessionData<UserType> | undefined>;
 export type UserFunctionProps = {
     authProvider: string;
-    userProfile: {
-        [key: string]: string | undefined;
-    };
+    userProfile: Record<string, unknown>;
 };
 export type CreateUser<UserType> = ({ userProfile, authProvider }: UserFunctionProps) => Promise<UserType>;
 export type GetUser<UserType> = ({ userProfile, authProvider }: UserFunctionProps) => Promise<UserType | null>;
-export type OnCallback<UserType> = ({ authProvider, userProfile, session, user_session_id }: {
+export type OnCallback<UserType> = ({ authProvider, tokenResponse, userProfile, session, user_session_id }: {
     authProvider: string;
-    userProfile: {
-        [key: string]: string | undefined;
-    };
+    tokenResponse: OAuth2TokenResponse;
+    userProfile: Record<string, unknown>;
     session: SessionRecord<UserType>;
     user_session_id: Cookie<string | undefined>;
 }) => void | Promise<void>;
+export type OnRefresh = ({ tokenResponse }: {
+    tokenResponse: OAuth2TokenResponse;
+}) => void | Promise<void>;
+export type OnProfile = ({ userProfile }: {
+    userProfile: Record<string, unknown>;
+}) => void | Promise<void>;
+export type OnRevocation = ({ tokenToRevoke }: {
+    tokenToRevoke: string;
+}) => void | Promise<void>;
+export type RouteString = `/${string}`;
+export type AuthorizeRoute = `${string}/:provider${'' | `/${string}`}`;
 export type AbsoluteAuthProps<UserType> = {
     config: Oauth2ConfigOptions;
-    authorizeRoute?: string;
-    callbackRoute?: string;
-    refreshRoute?: string;
-    revokeRoute?: string;
-    logoutRoute?: string;
-    statusRoute?: string;
+    authorizeRoute?: AuthorizeRoute;
+    profileRoute?: RouteString;
+    callbackRoute?: RouteString;
+    refreshRoute?: RouteString;
+    revokeRoute?: RouteString;
+    signoutRoute?: RouteString;
+    statusRoute?: RouteString;
     onAuthorize?: () => void;
     onCallback?: OnCallback<UserType>;
     onStatus?: () => void;
-    onRefresh?: () => void;
-    onLogout?: () => void;
-    onRevoke?: () => void;
+    onRefresh?: OnRefresh;
+    onSignOut?: () => void;
+    onRevocation?: OnRevocation;
+    onProfile?: OnProfile;
 };
 export type ClientProviders = Record<string, {
-    providerInstance: InstanceType<(typeof providers)[Providers]>;
-    scopes: string[];
-    searchParams: [string, string][];
+    providerInstance: OAuth2Client<ProviderOption>;
+    scope?: string[];
+    searchParams?: [string, string][];
 }>;
 export type InsantiateUserSessionProps<UserType> = {
     authProvider: string;
-    userProfile: {
-        [key: string]: string | undefined;
-    };
+    userProfile: Record<string, unknown>;
+    tokenResponse: OAuth2TokenResponse;
     session: SessionRecord<UserType>;
     user_session_id: Cookie<string | undefined>;
     createUser: () => UserType | Promise<UserType>;

package/dist/src/utils.d.ts

@@ -1,3 +1,3 @@
 import { AbsoluteAuthProps, InsantiateUserSessionProps } from './types';
-export declare const instantiateUserSession: <UserType>({ user_session_id, session, getUser, createUser }: InsantiateUserSessionProps<UserType>) => Promise<void>;
+export declare const instantiateUserSession: <UserType>({ user_session_id, session, tokenResponse, getUser, createUser }: InsantiateUserSessionProps<UserType>) => Promise<void>;
 export declare const createAuthConfig: <UserType>(props: AbsoluteAuthProps<UserType>) => AbsoluteAuthProps<UserType>;

package/drizzle.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'drizzle-kit';
+
+if (!process.env.DATABASE_URL) {
+	throw new Error('DATABASE_URL must be set in the environment variables');
+}
+
+export default defineConfig({
+	dialect: 'postgresql',
+	dbCredentials: {
+		url: process.env.DATABASE_URL
+	}
+});