nextjs-cms 0.0.1 → 0.5.1

package/dist/auth/csrf.js

@@ -0,0 +1,76 @@
+/**
+ * Creates a cookie with the value 'token|hash',
+ * where 'token' is the CSRF token and 'hash' is a hash made of the token and
+ * the secret, and the two values are joined by a pipe '|'. By storing the
+ * value and the hash of the value (with the secret used as a salt) we can
+ * verify the cookie was set by the server and not by a malicious attacker.
+ *
+ * For more details, see the following OWASP links:
+ * https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html#double-submit-cookie
+ * https://owasp.org/www-chapter-london/assets/slides/David_Johansson-Double_Defeat_of_Double-Submit_Cookie.pdf
+ */
+export async function createCSRFToken(cookieValue) {
+    /**
+     * If there is a CSRF token cookie, we verify it
+     */
+    if (cookieValue) {
+        /**
+         * Split the cookie value into the token and the hash
+         */
+        const [csrfToken, csrfTokenHash] = cookieValue.split('|');
+        if (csrfToken && csrfTokenHash) {
+            /**
+             * Create a hash of the CSRF token and the secret
+             */
+            const expectedCsrfTokenHash = await createHash(`${csrfToken}${process.env.CSRF_TOKEN_SECRET}`);
+            /**
+             * If hash matches then we trust the CSRF token value
+             */
+            if (csrfTokenHash === expectedCsrfTokenHash) {
+                return { csrfToken };
+            }
+        }
+    }
+    /**
+     * If this line is reached, then the CSRF token is not verified and we need to create a new one
+     */
+    const csrfToken = randomString(32);
+    const csrfTokenHash = await createHash(`${csrfToken}${process.env.CSRF_TOKEN_SECRET}`);
+    const cookie = `${csrfToken}|${csrfTokenHash}`;
+    /**
+     * Return the cookie and the CSRF token value
+     */
+    return { cookie, csrfToken };
+}
+/**
+ * This function is used to validate the CSRF token in POST, PUT, DELETE requests (or any request that changes data)
+ * @param cookieValue
+ * @param bodyValue
+ */
+export async function validateCSRFToken({ cookieValue, bodyValue }) {
+    if (cookieValue) {
+        const [csrfToken, csrfTokenHash] = cookieValue.split('|');
+        const expectedCsrfTokenHash = await createHash(`${csrfToken}${process.env.CSRF_TOKEN_SECRET}`);
+        if (csrfTokenHash === expectedCsrfTokenHash) {
+            // If hash matches then we trust the CSRF token value
+            // If this is a POST request and the CSRF Token in the POST request matches
+            // the cookie we have already verified is the one we have set, then the token is verified!
+            return csrfToken === bodyValue;
+        }
+    }
+    return false;
+}
+export function randomString(size) {
+    const i2hex = (i) => ('0' + i.toString(16)).slice(-2);
+    const r = (a, i) => a + i2hex(i);
+    const bytes = crypto.getRandomValues(new Uint8Array(size));
+    return Array.from(bytes).reduce(r, '');
+}
+export async function createHash(message) {
+    const data = new TextEncoder().encode(message);
+    const hash = await crypto.subtle.digest('SHA-256', data);
+    return Array.from(new Uint8Array(hash))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('')
+        .toString();
+}

package/dist/auth/hooks/index.d.ts

@@ -0,0 +1,4 @@
+import useAxiosPrivate from "./useAxiosPrivate";
+import useRefreshToken from "./useRefreshToken";
+export { useAxiosPrivate, useRefreshToken };
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/auth/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,eAAe,MAAM,mBAAmB,CAAA;AAC/C,OAAO,eAAe,MAAM,mBAAmB,CAAA;AAE/C,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,CAAA"}

package/dist/auth/hooks/index.js

@@ -0,0 +1,3 @@
+import useAxiosPrivate from "./useAxiosPrivate";
+import useRefreshToken from "./useRefreshToken";
+export { useAxiosPrivate, useRefreshToken };

package/dist/auth/hooks/useAxiosPrivate.d.ts

@@ -0,0 +1,5 @@
+declare const useAxiosPrivate: (options?: {
+    refreshTokenOn?: 401 | 404;
+}) => import("axios").AxiosInstance;
+export default useAxiosPrivate;
+//# sourceMappingURL=useAxiosPrivate.d.ts.map

package/dist/auth/hooks/useAxiosPrivate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAxiosPrivate.d.ts","sourceRoot":"","sources":["../../../src/auth/hooks/useAxiosPrivate.tsx"],"names":[],"mappings":"AAMA,QAAA,MAAM,eAAe,GAAI,UAAU;IAAE,cAAc,CAAC,EAAE,GAAG,GAAG,GAAG,CAAA;CAAE,kCAgFhE,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/auth/hooks/useAxiosPrivate.js

@@ -0,0 +1,74 @@
+import { axiosPrivate } from '../axios/axiosInstance';
+import { useEffect } from 'react';
+import useRefreshToken from './useRefreshToken';
+import axios from 'axios';
+import { getCsrfToken } from '../react';
+const useAxiosPrivate = (options) => {
+    const refresh = useRefreshToken();
+    const { refreshTokenOn = 401 } = options || {};
+    useEffect(() => {
+        /**
+         * Add a request interceptor
+         */
+        const requestIntercept = axiosPrivate.interceptors.request.use(
+        /**
+         * Do something before request is sent
+         * @param config The request config object
+         */
+        async (config) => {
+            if (config.method && ['post', 'put', 'delete'].includes(config.method.toLowerCase())) {
+                /**
+                 * If the request is a POST, PUT, or DELETE request, the XSRF-TOKEN header is added to the request.
+                 */
+                config.headers['x-csrf-token'] = await getCsrfToken();
+            }
+            /**
+             * Return the config object
+             */
+            return config;
+        }, (error) => Promise.reject(error));
+        /**
+         * This is the response interceptor
+         */
+        const responseIntercept = axiosPrivate.interceptors.response.use((response) => response, // Do nothing if the request is successful,
+        async (error) => {
+            // If the access token has expired, refresh it and retry the request
+            const prevRequest = error?.config; // The request that caused the error (the one that returned 401) is saved in the error object
+            if (error?.response?.status === refreshTokenOn && !prevRequest?.sent) {
+                // If the error is 401 and the request hasn't been sent before
+                prevRequest.sent = true; // Prevent infinite loops
+                const refreshStatus = await refresh(); // Refresh the access token cookie
+                if (refreshStatus === false)
+                    return Promise.reject(error); // If the refresh failed, reject the promise
+                // NOTICE: This is needed to send the request as multipart form data,
+                //  because resending the request with axios resets the Content-Type to application/json for some reason
+                // Use transformRequest to set Content-Type and include boundary for multipart form data
+                prevRequest.headers['Content-Type'] = 'multipart/form-data';
+                prevRequest.transformRequest = [
+                    (data, headers) => {
+                        // If the request data is FormData, set the boundary
+                        if (data instanceof FormData) {
+                            // @ts-ignore
+                            headers['Content-Type'] += `; boundary=${data._boundary}`;
+                        }
+                        return data;
+                    },
+                    ...axios.defaults.transformRequest, // Keep the default transformRequest functions
+                ];
+                return axiosPrivate(prevRequest); // The request that returned 401 is retried with the new access token
+            }
+            return Promise.reject(error);
+        });
+        // Remove the interceptors when the component unmounts
+        // This is needed to prevent memory leaks
+        return () => {
+            // Eject the interceptors
+            axiosPrivate.interceptors.request.eject(requestIntercept);
+            axiosPrivate.interceptors.response.eject(responseIntercept);
+        };
+    }, [
+    /*auth, refresh*/
+    ]);
+    return axiosPrivate;
+};
+export default useAxiosPrivate;

package/dist/auth/hooks/useRefreshToken.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This hook is used to refresh the access token when it expires.
+ * It is used in the useAxiosPrivate hook to refresh the access token when a request returns a 401 error.
+ */
+declare const useRefreshToken: () => () => Promise<unknown>;
+export default useRefreshToken;
+//# sourceMappingURL=useRefreshToken.d.ts.map

package/dist/auth/hooks/useRefreshToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRefreshToken.d.ts","sourceRoot":"","sources":["../../../src/auth/hooks/useRefreshToken.tsx"],"names":[],"mappings":"AAEA;;;GAGG;AACH,QAAA,MAAM,eAAe,8BA6EpB,CAAA;AAED,eAAe,eAAe,CAAA"}

package/dist/auth/hooks/useRefreshToken.js

@@ -0,0 +1,79 @@
+import { logout, refreshSession } from '../react';
+/**
+ * This hook is used to refresh the access token when it expires.
+ * It is used in the useAxiosPrivate hook to refresh the access token when a request returns a 401 error.
+ */
+const useRefreshToken = () => {
+    let isRefreshing = false; // Is a refresh request being sent?
+    let failedQueue = []; // An array of requests that failed because of 401
+    const processQueue = (error, token = null) => {
+        failedQueue.forEach((prom) => {
+            if (error) {
+                prom.reject(error);
+            }
+            else {
+                prom.resolve(token);
+            }
+        });
+        failedQueue = [];
+    };
+    const refresh = async () => {
+        try {
+            const response = await fetch('/api/auth/refresh');
+            const data = await response.json();
+            /**
+             * The refresh request is done
+             */
+            isRefreshing = false;
+            if (response.status !== 200) {
+                /**
+                 * If the refresh token is invalid, we log out the user
+                 */
+                await logout({
+                    /**
+                     * No need to delete the cookies, because they are both invalid.
+                     */
+                    deleteCookies: false,
+                });
+                return false;
+            }
+            else {
+                /**
+                 * update the session
+                 */
+                await refreshSession();
+            }
+            /**
+             * Process the failed requests
+             */
+            processQueue(null, data?.accessToken);
+            return true;
+        }
+        catch (error) {
+            /**
+             * If the refresh token is invalid, we log out the user
+             */
+            await logout({
+                /**
+                 * No need to delete the cookies, because they are both invalid.
+                 */
+                deleteCookies: false,
+            });
+            return false;
+        }
+    };
+    // TODO: Apply this inside useAxiosPrivate.tsx to prevent even the 401 errors from happening
+    // Let's use semaphores to prevent multiple refreshes at the same time
+    return async () => {
+        if (isRefreshing) {
+            // If a refresh request is being sent, we return a promise
+            // that will be resolved when the refresh request is done
+            return new Promise((resolve, reject) => {
+                failedQueue.push({ resolve, reject });
+            });
+        }
+        isRefreshing = true; // A refresh request is being sent
+        return await refresh(); // Send the refresh request and return the new access token
+    };
+};
+export default useRefreshToken;

package/dist/auth/index.d.ts

@@ -0,0 +1,23 @@
+export interface Session {
+    user: User;
+}
+export interface User {
+    id: string;
+    name: string;
+    locale?: string | null;
+    email?: string | null;
+    image?: string | null;
+}
+/**
+ * Internal function to get the auth session
+ */
+declare function __auth__internal(): Promise<Session | null>;
+/**
+ * Cache the auth session to avoid unnecessary requests per a single server request.
+ */
+declare const auth: typeof __auth__internal;
+/**
+ * Export the auth function
+ */
+export default auth;
+//# sourceMappingURL=index.d.ts.map

package/dist/auth/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/auth/index.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,OAAO;IACpB,IAAI,EAAE,IAAI,CAAA;CACb;AAED,MAAM,WAAW,IAAI;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB;AAeD;;GAEG;AACH,iBAAe,gBAAgB,IAAI,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAczD;AAED;;GAEG;AACH,QAAA,MAAM,IAAI,yBAA0B,CAAA;AAEpC;;GAEG;AACH,eAAe,IAAI,CAAA"}

package/dist/auth/index.js

@@ -0,0 +1,44 @@
+import { decodeJWT } from './jwt';
+import { cookies } from 'next/headers';
+import { cache } from 'react';
+/**
+ * Get the authenticated user from the access token
+ * @param accessToken
+ */
+const getAuthedUser = (accessToken) => {
+    if (!accessToken)
+        return null;
+    try {
+        return decodeJWT(accessToken);
+    }
+    catch (err) {
+        return null;
+    }
+};
+/**
+ * Internal function to get the auth session
+ */
+async function __auth__internal() {
+    const cookieJar = await cookies();
+    const jwt = getAuthedUser(cookieJar.get('access_token')?.value);
+    if (jwt) {
+        return {
+            user: {
+                id: jwt.id,
+                name: jwt.sub,
+                locale: jwt.locale,
+            },
+        };
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * Cache the auth session to avoid unnecessary requests per a single server request.
+ */
+const auth = cache(__auth__internal);
+/**
+ * Export the auth function
+ */
+export default auth;

package/dist/auth/jwt.d.ts

@@ -0,0 +1,6 @@
+import type { AccessTokenPayload, RefreshTokenPayload } from 'jsonwebtoken';
+export declare const encodeJWT: (payload: AccessTokenPayload) => string;
+export declare const encodeRefreshToken: (payload: RefreshTokenPayload) => string;
+export declare const decodeJWT: (token: string) => AccessTokenPayload;
+export declare const decodeRefreshToken: (token: string) => RefreshTokenPayload;
+//# sourceMappingURL=jwt.d.ts.map

package/dist/auth/jwt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../src/auth/jwt.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAG3E,eAAO,MAAM,SAAS,GAAI,SAAS,kBAAkB,KAAG,MAKvD,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,SAAS,mBAAmB,KAAG,MAKjE,CAAA;AAED,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,KAAG,kBAEzC,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,OAAO,MAAM,KAAG,mBAMlD,CAAA"}

package/dist/auth/jwt.js

@@ -0,0 +1,25 @@
+import { randomUUID } from 'node:crypto';
+import jwt from 'jsonwebtoken';
+export const encodeJWT = (payload) => {
+    return jwt.sign(payload, process.env.ACCESS_TOKEN_SECRET, {
+        expiresIn: process.env.ACCESS_TOKEN_EXPIRATION,
+        jwtid: randomUUID(),
+    });
+};
+export const encodeRefreshToken = (payload) => {
+    return jwt.sign(payload, process.env.REFRESH_TOKEN_SECRET, {
+        expiresIn: process.env.REFRESH_TOKEN_EXPIRATION,
+        jwtid: randomUUID(),
+    });
+};
+export const decodeJWT = (token) => {
+    return jwt.verify(token, process.env.ACCESS_TOKEN_SECRET || '');
+};
+export const decodeRefreshToken = (token) => {
+    try {
+        return jwt.verify(token, process.env.REFRESH_TOKEN_SECRET || '');
+    }
+    catch (err) {
+        throw err;
+    }
+};

package/dist/auth/lib/actions.d.ts

@@ -0,0 +1,33 @@
+import type { Session } from '../index';
+export declare const authRefresh: (refreshToken?: {
+    value: string;
+}) => Promise<{
+    status: number;
+    code: string;
+    state: string;
+    user?: undefined;
+} | {
+    status: number;
+    state: string;
+    user: {
+        id: string;
+        username: string;
+        lang: string | null;
+        avatar: string | null;
+    };
+    code?: undefined;
+}>;
+export declare const login: ({ username, password }: {
+    username: string;
+    password: string;
+}) => Promise<{
+    user: {
+        id: string;
+        username: string;
+        lang: string | null;
+        avatar: string | null;
+    };
+    accessToken: string;
+}>;
+export declare const deleteSession: (session?: Session | null) => Promise<boolean>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/auth/lib/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/auth/lib/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAEvC,eAAO,MAAM,WAAW,GAAU,eAAe;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;EA4GjE,CAAA;AAED,eAAO,MAAM,KAAK,GAAU,wBAAwB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE;;;;;;;;EA+FzF,CAAA;AAED,eAAO,MAAM,aAAa,GAAU,UAAU,OAAO,GAAG,IAAI,qBA0B3D,CAAA"}

package/dist/auth/lib/actions.js

@@ -0,0 +1,209 @@
+import { db } from '../../db/client';
+import { AccessTokensTable, AdminsTable } from '../../db/schema';
+import { and, eq } from 'drizzle-orm';
+import bcrypt from 'bcrypt';
+import { decodeRefreshToken, encodeJWT, encodeRefreshToken } from '../jwt';
+import { cookies } from 'next/headers';
+export const authRefresh = async (refreshToken) => {
+    if (!refreshToken) {
+        return {
+            status: 401,
+            code: 'no_refresh_token',
+            state: 'logged_out',
+        };
+    }
+    try {
+        const decoded = decodeRefreshToken(refreshToken.value);
+        const result = await db
+            .select({
+            adminId: AccessTokensTable.adminId,
+            accessToken: AccessTokensTable.accessToken,
+            refreshToken: AccessTokensTable.refreshToken,
+            expiration: AccessTokensTable.expiration,
+            username: AdminsTable.user,
+            locale: AdminsTable.language,
+            coverphoto: AdminsTable.coverphoto,
+        })
+            .from(AccessTokensTable)
+            .innerJoin(AdminsTable, eq(AccessTokensTable.adminId, AdminsTable.id))
+            .where(and(eq(AccessTokensTable.adminId, decoded.id), eq(AccessTokensTable.refreshToken, refreshToken.value)))
+            .limit(1);
+        const adminTokenResult = result[0];
+        if (!adminTokenResult) {
+            return {
+                status: 401,
+                code: 'invalid_refresh_token',
+                state: 'logged_out',
+            };
+        }
+        // Let's create a JWT access token and refresh token
+        const accessToken = encodeJWT({
+            id: decoded.id,
+            iss: 'Lazemni CMS',
+            aud: 'admin',
+            sub: adminTokenResult.username,
+            locale: adminTokenResult.locale || 'en',
+        });
+        const newRefreshToken = encodeRefreshToken({
+            id: adminTokenResult.adminId,
+            iss: 'Lazemni CMS',
+            aud: 'admin',
+            sub: adminTokenResult.username,
+        });
+        // Let's update the refresh token in the database
+        await db
+            .update(AccessTokensTable)
+            .set({
+            accessToken,
+            refreshToken: newRefreshToken,
+            expiration: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+        })
+            .where(and(eq(AccessTokensTable.adminId, adminTokenResult.adminId), eq(AccessTokensTable.refreshToken, refreshToken.value)));
+        // Let's send the refresh token as a cookie
+        const cookieStore = await cookies();
+        cookieStore.set({
+            name: 'refresh_token',
+            value: newRefreshToken,
+            httpOnly: true,
+            path: '/api/auth/refresh',
+            secure: true,
+            sameSite: true,
+            maxAge: 60 * 60 * 24 * 365,
+        });
+        cookieStore.set({
+            name: 'access_token',
+            value: accessToken,
+            httpOnly: true,
+            secure: true,
+            sameSite: true,
+            maxAge: 60 * 60 * 2, // 2 hours
+        });
+        return {
+            status: 200,
+            // accessToken: accessToken,
+            state: 'logged_in',
+            user: {
+                id: adminTokenResult.adminId,
+                username: adminTokenResult.username,
+                lang: adminTokenResult.locale,
+                avatar: adminTokenResult.coverphoto,
+            },
+        };
+    }
+    catch (err) {
+        return {
+            status: 401,
+            code: 'invalid_refresh_token',
+            state: 'logged_out',
+        };
+    }
+};
+export const login = async ({ username, password }) => {
+    if (!username || !password) {
+        throw new Error('Please provide username and password');
+    }
+    const result = await db
+        .select({
+        password: AdminsTable.pass,
+        id: AdminsTable.id,
+        username: AdminsTable.user,
+        locale: AdminsTable.language,
+        coverphoto: AdminsTable.coverphoto,
+    })
+        .from(AdminsTable)
+        .where(eq(AdminsTable.user, username))
+        .limit(1);
+    const admin = result[0];
+    if (!admin) {
+        throw new Error('Invalid credentials');
+    }
+    // Verify password with bcrypt
+    const valid = await bcrypt.compare(password, admin.password);
+    if (!valid) {
+        throw new Error('Invalid credentials');
+    }
+    // Let's create a JWT access token and refresh token
+    const accessToken = encodeJWT({
+        id: admin.id,
+        iss: 'Lazemni CMS',
+        aud: 'admin',
+        sub: admin.username,
+        locale: admin.locale || 'en',
+    });
+    const refreshToken = encodeRefreshToken({
+        id: admin.id,
+        iss: 'Lazemni CMS',
+        aud: 'admin',
+        sub: admin.username,
+    });
+    // Let's save the refresh token in the database
+    await db
+        .insert(AccessTokensTable)
+        .values({
+        accessToken,
+        refreshToken,
+        adminId: admin.id,
+        expiration: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+    })
+        .onDuplicateKeyUpdate({
+        set: {
+            accessToken,
+            refreshToken,
+            expiration: new Date(Date.now() + 1000 * 60 * 60 * 24 * 365),
+        },
+    });
+    const cookieStore = await cookies();
+    // Let's send the refresh token as a cookie
+    cookieStore.set({
+        name: 'refresh_token',
+        value: refreshToken,
+        httpOnly: true,
+        path: '/api/auth/refresh',
+        secure: true,
+        sameSite: true,
+        maxAge: 60 * 60 * 24 * 365,
+    });
+    cookieStore.set({
+        name: 'access_token',
+        value: accessToken,
+        httpOnly: true,
+        secure: true,
+        sameSite: true,
+        maxAge: 60 * 60 * 2, // 2 hours
+    });
+    // Now, return the access token in body
+    return {
+        user: {
+            id: admin.id,
+            username: admin.username,
+            lang: admin.locale,
+            avatar: admin.coverphoto,
+        },
+        accessToken: accessToken,
+    };
+};
+export const deleteSession = async (session) => {
+    // Let's delete csrf, access and refresh token cookies
+    const cookieStore = await cookies();
+    cookieStore.set({
+        name: 'csrf_token',
+        value: '',
+        maxAge: -1,
+    });
+    cookieStore.set({
+        name: 'access_token',
+        value: '',
+        maxAge: -1,
+    });
+    cookieStore.set({
+        name: 'refresh_token',
+        value: '',
+        path: '/api/auth/refresh',
+        maxAge: -1,
+    });
+    if (session?.user.id) {
+        // Let's delete the refresh token from the database
+        await db.delete(AccessTokensTable).where(eq(AccessTokensTable.adminId, session.user.id));
+    }
+    return true;
+};

package/dist/auth/lib/client.d.ts

@@ -0,0 +1,4 @@
+export declare function fetchData<T = any>(path: string, req?: any): Promise<T | null>;
+export declare function now(): number;
+export declare function useOnline(): boolean;
+//# sourceMappingURL=client.d.ts.map

package/dist/auth/lib/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/auth/lib/client.ts"],"names":[],"mappings":"AAKA,wBAAsB,SAAS,CAAC,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,GAAQ,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAyBvF;AAED,wBAAgB,GAAG,WAElB;AAED,wBAAgB,SAAS,YAiBxB"}