@auditauth/next 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { AuditAuthNext } from './sdk';
 export { AuditAuthGuard, useAuditAuth } from './guard';
 export { login, logout, goToPortal } from './helpers';
+export { auditauthFetch } from './request';
 export type * from './types';

package/dist/index.js

@@ -1,3 +1,4 @@
 export { AuditAuthNext } from './sdk';
 export { AuditAuthGuard, useAuditAuth } from './guard';
 export { login, logout, goToPortal } from './helpers';
+export { auditauthFetch } from './request';

package/dist/request.d.ts

@@ -0,0 +1,2 @@
+declare const auditauthFetch: (url: string, init?: RequestInit) => Promise<Response>;
+export { auditauthFetch };

package/dist/request.js

@@ -0,0 +1,53 @@
+'use server';
+import { cookies } from "next/headers";
+import { SETTINGS } from "./settings";
+const auditauthFetch = async (url, init = {}) => {
+    const cookieManager = await cookies();
+    const access_token = cookieManager.get(SETTINGS.cookies.access.name);
+    const refresh_token = cookieManager.get(SETTINGS.cookies.refresh.name);
+    const doFetch = (token) => fetch(url, {
+        ...init,
+        headers: {
+            ...init.headers,
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+        },
+    });
+    const start = performance.now();
+    let response = await doFetch(access_token?.value);
+    if (response.status === 401 && refresh_token) {
+        const refreshResponse = await fetch(`${SETTINGS.domains.api}/auth/refresh`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                refresh_token,
+                client_type: 'server',
+            }),
+        });
+        if (!refreshResponse.ok)
+            return response;
+        const data = await refreshResponse.json();
+        if (data?.access_token && data?.refresh_token) {
+            response = await doFetch(data.access_token);
+        }
+    }
+    queueMicrotask(() => {
+        const payload = {
+            event_type: 'request',
+            runtime: 'server',
+            target: {
+                type: 'api',
+                method: init.method || 'GET',
+                path: url,
+                status: response.status,
+                duration_ms: Math.round(performance.now() - start),
+            },
+        };
+        fetch(`${SETTINGS.bff.paths.metrics}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ ...payload }),
+        }).catch(() => { });
+    });
+    return response;
+};
+export { auditauthFetch };

package/dist/sdk.d.ts

@@ -4,7 +4,7 @@ declare class AuditAuthNext {
     private config;
     private cookies;
     constructor(config: AuditAuthConfig, cookies: CookieAdapter);
-    private verifyAccessToken;
+    verifyAccessToken(token: string): Promise<boolean>;
     private getCookieTokens;
     private setCookieTokens;
     getSession(): SessionUser | null;
@@ -24,10 +24,14 @@ declare class AuditAuthNext {
         url: string;
         reason: null;
     }>;
-    private refresh;
-    request(path: string, init?: RequestInit): Promise<Response>;
+    private refreshRequest;
+    request(url: string, init?: RequestInit): Promise<Response>;
+    metrics(payload: Metric): Promise<Response>;
     private pushMetric;
-    middleware(_request: NextRequest): Promise<NextResponse<unknown>>;
+    refresh(): Promise<{
+        ok: boolean;
+    }>;
+    middleware(request: NextRequest): Promise<NextResponse<unknown>>;
     getHandlers(): {
         GET: (req: NextRequest, ctx: {
             params: Promise<{
@@ -40,6 +44,5 @@ declare class AuditAuthNext {
             }>;
         }) => Promise<Response>;
     };
-    metrics(payload: Metric): Promise<Response>;
 }
 export { AuditAuthNext };

package/dist/sdk.js

@@ -11,14 +11,22 @@ let cachedKey = null;
 /* -------------------------------------------------------------------------- */
 class AuditAuthNext {
     constructor(config, cookies) {
-        if (!cookies.get || !cookies.set) {
-            throw new Error('Missing cookie adapter');
+        if (!config.appId)
+            throw new Error('Missing appId');
+        if (!config.apiKey)
+            throw new Error('Missing apiKey');
+        if (!config.baseUrl)
+            throw new Error('Missing baseUrl');
+        if (!config.redirectUrl)
+            throw new Error('Missing redirectUrl');
+        if (!cookies?.get || !cookies?.set || !cookies?.remove) {
+            throw new Error('Invalid cookie adapter');
         }
         this.config = config;
         this.cookies = cookies;
     }
     /* ------------------------------------------------------------------------ */
-    /*                             AUTH PRIMITIVES                               */
+    /*                             AUTH PRIMITIVES                              */
     /* ------------------------------------------------------------------------ */
     async verifyAccessToken(token) {
         try {
@@ -41,12 +49,25 @@ class AuditAuthNext {
             refresh: this.cookies.get(SETTINGS.cookies.refresh.name),
         };
     }
-    setCookieTokens(tokens) {
-        this.cookies.set(SETTINGS.cookies.access.name, tokens.at, SETTINGS.cookies.access.config);
-        this.cookies.set(SETTINGS.cookies.refresh.name, tokens.rt, SETTINGS.cookies.refresh.config);
+    setCookieTokens(params) {
+        const isSecure = this.config.redirectUrl.includes('https');
+        this.cookies.set(SETTINGS.cookies.access.name, params.access_token, {
+            httpOnly: true,
+            sameSite: 'lax',
+            secure: isSecure,
+            path: '/',
+            maxAge: params.access_expires_seconds - 60,
+        });
+        this.cookies.set(SETTINGS.cookies.refresh.name, params.refresh_token, {
+            httpOnly: true,
+            sameSite: 'lax',
+            secure: isSecure,
+            path: '/',
+            maxAge: params.refresh_expires_seconds - 60,
+        });
     }
     /* ------------------------------------------------------------------------ */
-    /*                              SESSION HELPERS                              */
+    /*                              SESSION HELPERS                             */
     /* ------------------------------------------------------------------------ */
     getSession() {
         return JSON.parse(this.cookies.get(SETTINGS.cookies.session.name) || '{}')?.user || null;
@@ -55,7 +76,7 @@ class AuditAuthNext {
         return !!this.cookies.get(SETTINGS.cookies.session.name);
     }
     /* ------------------------------------------------------------------------ */
-    /*                              AUTH FLOWS                                   */
+    /*                              AUTH FLOWS                                  */
     /* ------------------------------------------------------------------------ */
     async buildAuthUrl() {
         const response = await fetch(`${SETTINGS.domains.api}/apps/login`, {
@@ -98,10 +119,19 @@ class AuditAuthNext {
                 name: result.user.name,
             },
         };
-        this.cookies.set(SETTINGS.cookies.session.name, JSON.stringify(session), SETTINGS.cookies.session.config);
+        const isSecure = this.config.redirectUrl.includes('http');
+        this.cookies.set(SETTINGS.cookies.session.name, JSON.stringify(session), {
+            httpOnly: true,
+            sameSite: 'lax',
+            secure: isSecure,
+            path: '/',
+            maxAge: result.refresh_expires_seconds - 60,
+        });
         this.setCookieTokens({
-            at: result.access_token,
-            rt: result.refresh_token,
+            access_token: result.access_token,
+            access_expires_seconds: result.access_expires_seconds,
+            refresh_token: result.refresh_token,
+            refresh_expires_seconds: result.refresh_expires_seconds,
         });
         return { ok: true, url: this.config.redirectUrl };
     }
@@ -109,7 +139,7 @@ class AuditAuthNext {
         const { access } = this.getCookieTokens();
         if (access) {
             await fetch(`${SETTINGS.domains.api}/auth/revoke`, {
-                method: 'GET',
+                method: 'PATCH',
                 headers: { Authorization: `Bearer ${access}` },
             }).catch(() => { });
         }
@@ -132,12 +162,16 @@ class AuditAuthNext {
             return { ok: false, url: null, reason: 'fail' };
         }
         const body = await res.json();
-        return { ok: true, url: `${body.redirectUrl}?code=${body.code}&redirectUrl=${this.config.redirectUrl}`, reason: null };
+        return {
+            ok: true,
+            url: `${body.redirectUrl}?code=${body.code}&redirectUrl=${this.config.redirectUrl}`,
+            reason: null,
+        };
     }
     /* ------------------------------------------------------------------------ */
     /*                              REFRESH FLOW                                 */
     /* ------------------------------------------------------------------------ */
-    async refresh(refreshToken) {
+    async refreshRequest(refreshToken) {
         try {
             const response = await fetch(`${SETTINGS.domains.api}/auth/refresh`, {
                 method: 'POST',
@@ -158,9 +192,9 @@ class AuditAuthNext {
     /* ------------------------------------------------------------------------ */
     /*                         REQUEST WITH AUTO-REFRESH                         */
     /* ------------------------------------------------------------------------ */
-    async request(path, init = {}) {
+    async request(url, init = {}) {
         const { access, refresh } = this.getCookieTokens();
-        const doFetch = (token) => fetch(`${this.config.requestUrl}${path}`, {
+        const doFetch = (token) => fetch(url, {
             ...init,
             headers: {
                 ...init.headers,
@@ -169,9 +203,8 @@ class AuditAuthNext {
         });
         const start = performance.now();
         let res = await doFetch(access);
-        // Attempt refresh once on 401
         if (res.status === 401 && refresh) {
-            const data = await this.refresh(refresh);
+            const data = await this.refreshRequest(refresh);
             if (data?.access_token && data?.refresh_token) {
                 res = await doFetch(data.access_token);
             }
@@ -182,7 +215,7 @@ class AuditAuthNext {
             target: {
                 type: 'api',
                 method: init.method || 'GET',
-                path,
+                path: url,
                 status: res.status,
                 duration_ms: Math.round(performance.now() - start),
             },
@@ -192,66 +225,131 @@ class AuditAuthNext {
     /* ------------------------------------------------------------------------ */
     /*                                METRICS                                    */
     /* ------------------------------------------------------------------------ */
+    async metrics(payload) {
+        await fetch(`${SETTINGS.domains.api}/metrics`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-auditauth-app': this.config.appId,
+                'x-auditauth-key': this.config.apiKey,
+            },
+            body: JSON.stringify({ ...payload }),
+        });
+        return new Response(null, { status: 204 });
+    }
     pushMetric(payload) {
-        let sid = this.cookies.get(SETTINGS.cookies.session_id.name);
+        const session_id = this.cookies.get(SETTINGS.cookies.session_id.name);
         queueMicrotask(() => {
             fetch(`${this.config.baseUrl}${SETTINGS.bff.paths.metrics}`, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ ...payload, session_id: sid ?? crypto.randomUUID() }),
+                body: JSON.stringify({ ...payload, session_id }),
             }).catch(() => { });
         });
     }
     /* ------------------------------------------------------------------------ */
+    /*                                METRICS                                    */
+    /* ------------------------------------------------------------------------ */
+    async refresh() {
+        const { refresh } = this.getCookieTokens();
+        if (!refresh)
+            return { ok: false };
+        const result = await this.refreshRequest(refresh);
+        if (!result)
+            return { ok: false };
+        this.setCookieTokens(result);
+        return { ok: true };
+    }
+    /* ------------------------------------------------------------------------ */
     /*                               MIDDLEWARE                                  */
     /* ------------------------------------------------------------------------ */
-    async middleware(_request) {
+    async middleware(request) {
         const { access, refresh } = this.getCookieTokens();
-        if (access && await this.verifyAccessToken(access)) {
-            return NextResponse.next();
-        }
-        if (refresh) {
-            const data = await this.refresh(refresh);
-            if (data?.access_token && data?.refresh_token) {
-                this.setCookieTokens({
-                    at: data.access_token,
-                    rt: data.refresh_token,
+        const url = request.nextUrl;
+        if (access && refresh) {
+            const sid = this.cookies.get(SETTINGS.cookies.session_id.name);
+            if (!sid) {
+                this.cookies.set(SETTINGS.cookies.session_id.name, crypto.randomUUID(), {
+                    httpOnly: true,
+                    sameSite: 'lax',
+                    secure: this.config.baseUrl.startsWith('https'),
+                    path: '/',
+                    maxAge: 60 * 30,
                 });
             }
+            this.pushMetric({
+                event_type: 'navigation',
+                runtime: 'browser',
+                target: {
+                    type: 'page',
+                    path: url.pathname,
+                },
+            });
+            return NextResponse.next();
         }
+        if (!refresh)
+            return NextResponse.redirect(new URL(SETTINGS.bff.paths.login, request.url));
+        if (refresh && !access)
+            return NextResponse.redirect(new URL(`${SETTINGS.bff.paths.refresh}?redirectUrl=${url}`, request.url));
         return NextResponse.next();
     }
     /* ------------------------------------------------------------------------ */
-    /*                               BFF HANDLERS                                */
+    /*                               BFF HANDLERS                               */
     /* ------------------------------------------------------------------------ */
     getHandlers() {
         return {
             GET: async (req, ctx) => {
                 const action = (await ctx.params).auditauth[0];
+                const redirectUrl = req.nextUrl.searchParams.get('redirectUrl');
                 switch (action) {
                     case 'login':
-                        return NextResponse.redirect(await this.buildAuthUrl());
-                    case 'callback': {
-                        const result = await this.callback(req);
-                        return NextResponse.redirect(result.url);
-                    }
+                        {
+                            const url = await this.buildAuthUrl();
+                            return NextResponse.redirect(url);
+                        }
+                        ;
+                    case 'refresh':
+                        {
+                            const { ok } = await this.refresh();
+                            if (ok)
+                                return NextResponse.redirect(redirectUrl || this.config.redirectUrl);
+                            const url = await this.buildAuthUrl();
+                            return NextResponse.redirect(url);
+                        }
+                        ;
+                    case 'callback':
+                        {
+                            const { url } = await this.callback(req);
+                            return NextResponse.redirect(url);
+                        }
+                        ;
                     case 'logout':
-                        await this.logout();
-                        return NextResponse.redirect(this.config.redirectUrl);
-                    case 'portal': {
-                        const result = await this.getPortalUrl();
-                        return result.ok && result.url
-                            ? NextResponse.redirect(result.url)
-                            : NextResponse.redirect(`${SETTINGS.domains.client}/auth/invalid`);
-                    }
-                    case 'session': {
-                        const user = this.getSession();
-                        if (!user)
-                            return new NextResponse(null, { status: 401 });
-                        return NextResponse.json({ user });
-                    }
+                        {
+                            await this.logout();
+                            return NextResponse.redirect(this.config.redirectUrl);
+                        }
+                        ;
+                    case 'portal':
+                        {
+                            const { ok, url } = await this.getPortalUrl();
+                            return ok && url
+                                ? NextResponse.redirect(url)
+                                : NextResponse.redirect(`${SETTINGS.domains.client}/auth/invalid`);
+                        }
+                        ;
+                    case 'session':
+                        {
+                            const user = this.getSession();
+                            if (!user)
+                                return new NextResponse(null, { status: 401 });
+                            return NextResponse.json({ user });
+                        }
+                        ;
                     default:
-                        return new Response('not found', { status: 404 });
+                        {
+                            return new Response('not found', { status: 404 });
+                        }
+                        ;
                 }
             },
             POST: async (req, ctx) => {
@@ -263,17 +361,5 @@ class AuditAuthNext {
             },
         };
     }
-    async metrics(payload) {
-        await fetch(`${SETTINGS.domains.api}/metrics`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'x-auditauth-app': this.config.appId,
-                'x-auditauth-key': this.config.apiKey,
-            },
-            body: JSON.stringify(payload),
-        });
-        return new Response(null, { status: 204 });
-    }
 }
 export { AuditAuthNext };

package/dist/settings.d.ts

@@ -2,8 +2,8 @@ declare const SETTINGS: {
     readonly jwt_public_key: "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs2EYs4Q9OyjNuAEPqb4j\nIzc52JdfVcNvEbG43Xp8B2kI9QxwRyX7rtFSwKowj3W1BlCLaTIMK3TafWOf9QwH\nfemuL9Ni37PFcGptzpyuoCYYA650EuD82PENcO49lsObvty2cuXxQszbPPvAecm4\nJ/XG70td/W1UwbjAJcdmp8ktZGYR0JXM37hYA9Xq/aKwu7d0FTL6WdKTvt3L5VxL\nF6WNyLs65ZSbu+j8UEkwmoJ9h9Y0mLQmFtmkoh/HWOFyFDnBNiJX0vRb++RhJw6w\ncrSbqpbTu7z4vIep5lgSOut39P273SVTQZ3cGQIS+605Ur5wjkkSzzaJV1QLBBR9\nAQIDAQAB\n-----END PUBLIC KEY-----\n";
     readonly jwt_issuer: "https://api.auditauth.com";
     readonly domains: {
-        readonly api: "http://localhost:4000/v1";
-        readonly client: "http://localhost:3000";
+        readonly api: "https://api.auditauth.com/v1";
+        readonly client: "https://auditauth.com";
     };
     readonly bff: {
         readonly paths: {
@@ -13,48 +13,21 @@ declare const SETTINGS: {
             readonly logout: "/api/auditauth/logout";
             readonly portal: "/api/auditauth/portal";
             readonly session: "/api/auditauth/session";
+            readonly refresh: "/api/auditauth/refresh";
         };
     };
     readonly cookies: {
         readonly access: {
             readonly name: "auditauth_access";
-            readonly config: {
-                readonly httpOnly: true;
-                readonly sameSite: "lax";
-                readonly secure: false;
-                readonly path: "/";
-                readonly maxAge: number;
-            };
         };
         readonly session: {
             readonly name: "auditauth_session";
-            readonly config: {
-                readonly maxAge: number;
-                readonly httpOnly: true;
-                readonly secure: false;
-                readonly path: "/";
-                readonly sameSite: "lax";
-            };
         };
         readonly refresh: {
             readonly name: "auditauth_refresh";
-            readonly config: {
-                readonly httpOnly: true;
-                readonly sameSite: "lax";
-                readonly secure: false;
-                readonly path: "/";
-                readonly maxAge: number;
-            };
         };
         readonly session_id: {
             readonly name: "auditauth_sid";
-            readonly config: {
-                readonly httpOnly: false;
-                readonly sameSite: "lax";
-                readonly secure: false;
-                readonly path: "/";
-                readonly maxAge: number;
-            };
         };
     };
 };

package/dist/settings.js

@@ -2,8 +2,10 @@ const SETTINGS = {
     jwt_public_key: "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAs2EYs4Q9OyjNuAEPqb4j\nIzc52JdfVcNvEbG43Xp8B2kI9QxwRyX7rtFSwKowj3W1BlCLaTIMK3TafWOf9QwH\nfemuL9Ni37PFcGptzpyuoCYYA650EuD82PENcO49lsObvty2cuXxQszbPPvAecm4\nJ/XG70td/W1UwbjAJcdmp8ktZGYR0JXM37hYA9Xq/aKwu7d0FTL6WdKTvt3L5VxL\nF6WNyLs65ZSbu+j8UEkwmoJ9h9Y0mLQmFtmkoh/HWOFyFDnBNiJX0vRb++RhJw6w\ncrSbqpbTu7z4vIep5lgSOut39P273SVTQZ3cGQIS+605Ur5wjkkSzzaJV1QLBBR9\nAQIDAQAB\n-----END PUBLIC KEY-----\n",
     jwt_issuer: "https://api.auditauth.com",
     domains: {
-        api: 'http://localhost:4000/v1',
-        client: 'http://localhost:3000',
+        api: 'https://api.auditauth.com/v1',
+        client: 'https://auditauth.com',
+        // api: 'http://localhost:4000/v1',
+        // client: 'http://localhost:3000',
     },
     bff: {
         paths: {
@@ -13,48 +15,21 @@ const SETTINGS = {
             logout: '/api/auditauth/logout',
             portal: '/api/auditauth/portal',
             session: '/api/auditauth/session',
+            refresh: '/api/auditauth/refresh',
         }
     },
     cookies: {
         access: {
             name: 'auditauth_access',
-            config: {
-                httpOnly: true,
-                sameSite: 'lax',
-                secure: false,
-                path: '/',
-                maxAge: 60 * 15,
-            }
         },
         session: {
             name: 'auditauth_session',
-            config: {
-                maxAge: 60 * 60 * 24,
-                httpOnly: true,
-                secure: false,
-                path: "/",
-                sameSite: "lax",
-            },
         },
         refresh: {
             name: 'auditauth_refresh',
-            config: {
-                httpOnly: true,
-                sameSite: 'lax',
-                secure: false,
-                path: '/',
-                maxAge: 60 * 60 * 24,
-            }
         },
         session_id: {
             name: 'auditauth_sid',
-            config: {
-                httpOnly: false,
-                sameSite: 'lax',
-                secure: false,
-                path: '/',
-                maxAge: 60 * 60,
-            }
         }
     }
 };

package/dist/types.d.ts

@@ -1,10 +1,15 @@
 type AuditAuthConfig = {
-    requestUrl: string;
     apiKey: string;
     redirectUrl: string;
     baseUrl: string;
     appId: string;
 };
+type CredentialResponse = {
+    access_token: string;
+    access_expires_seconds: number;
+    refresh_token: string;
+    refresh_expires_seconds: number;
+};
 type SessionUser = {
     _id: string;
     name: string;
@@ -47,4 +52,4 @@ type CookieAdapter = {
     set: (name: string, value: string, options?: CookieOptions) => void;
     remove: (name: string) => void;
 };
-export type { AuditAuthConfig, SessionUser, Session, RequestMethod, Metric, CookieOptions, CookieAdapter, };
+export type { AuditAuthConfig, CredentialResponse, SessionUser, Session, RequestMethod, Metric, CookieOptions, CookieAdapter, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auditauth/next",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Official AuditAuth SDK for Next.js",
   "license": "MIT",
   "author": "Nimibyte",
@@ -18,7 +18,8 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "dev": "tsc -p tsconfig.build.json --watch"
   },
   "peerDependencies": {
     "next": ">=13",
@@ -26,7 +27,6 @@
     "react-dom": ">=18"
   },
   "dependencies": {
-    "crypto": "^1.0.1",
     "jose": "^5.2.0"
   },
   "devDependencies": {