nextjs-cms 0.5.9 → 0.5.10

package/dist/auth/jwt.d.ts

@@ -1,6 +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;
+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.js

@@ -1,25 +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;
-    }
-};
+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

@@ -1,33 +1,33 @@
-import type { Session } from "../index.js";
-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>;
+import type { Session } from '../index.js';
+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

@@ -1 +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"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/auth/lib/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,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

@@ -1,209 +1,209 @@
-import { db } from "../../db/client.js";
-import { AccessTokensTable, AdminsTable } from "../../db/schema.js";
-import { and, eq } from 'drizzle-orm';
-import bcrypt from 'bcrypt';
-import { decodeRefreshToken, encodeJWT, encodeRefreshToken } from "../jwt.js";
-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;
-};
+import { db } from '../../db/client.js';
+import { AccessTokensTable, AdminsTable } from '../../db/schema.js';
+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

@@ -1,4 +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;
+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.js

@@ -1,46 +1,46 @@
-'use client';
-import React from 'react';
-import { getCsrfToken } from "../react.js";
-export async function fetchData(path, req = {}) {
-    const url = `/api/auth/${path}`;
-    try {
-        const options = {
-            headers: {
-                // If there is a body, add the x-csrf-token header
-                ...(req?.body ? { 'x-csrf-token': await getCsrfToken() } : {}),
-                'Content-Type': 'application/json',
-                ...(req?.headers?.cookie ? { cookie: req.headers.cookie } : {}),
-            },
-        };
-        if (req?.body) {
-            options.body = JSON.stringify(req.body);
-            options.method = 'POST';
-        }
-        const res = await fetch(url, options);
-        const data = await res.json();
-        if (!res.ok)
-            throw data;
-        return data;
-    }
-    catch (error) {
-        console.error(error.message);
-        return null;
-    }
-}
-export function now() {
-    return Math.floor(Date.now() / 1000);
-}
-export function useOnline() {
-    const [isOnline, setIsOnline] = React.useState(typeof navigator !== 'undefined' ? navigator.onLine : false);
-    const setOnline = () => setIsOnline(true);
-    const setOffline = () => setIsOnline(false);
-    React.useEffect(() => {
-        window.addEventListener('online', setOnline);
-        window.addEventListener('offline', setOffline);
-        return () => {
-            window.removeEventListener('online', setOnline);
-            window.removeEventListener('offline', setOffline);
-        };
-    }, []);
-    return isOnline;
-}
+'use client';
+import React from 'react';
+import { getCsrfToken } from '../react.jsx';
+export async function fetchData(path, req = {}) {
+    const url = `/api/auth/${path}`;
+    try {
+        const options = {
+            headers: {
+                // If there is a body, add the x-csrf-token header
+                ...(req?.body ? { 'x-csrf-token': await getCsrfToken() } : {}),
+                'Content-Type': 'application/json',
+                ...(req?.headers?.cookie ? { cookie: req.headers.cookie } : {}),
+            },
+        };
+        if (req?.body) {
+            options.body = JSON.stringify(req.body);
+            options.method = 'POST';
+        }
+        const res = await fetch(url, options);
+        const data = await res.json();
+        if (!res.ok)
+            throw data;
+        return data;
+    }
+    catch (error) {
+        console.error(error.message);
+        return null;
+    }
+}
+export function now() {
+    return Math.floor(Date.now() / 1000);
+}
+export function useOnline() {
+    const [isOnline, setIsOnline] = React.useState(typeof navigator !== 'undefined' ? navigator.onLine : false);
+    const setOnline = () => setIsOnline(true);
+    const setOffline = () => setIsOnline(false);
+    React.useEffect(() => {
+        window.addEventListener('online', setOnline);
+        window.addEventListener('offline', setOffline);
+        return () => {
+            window.removeEventListener('online', setOnline);
+            window.removeEventListener('offline', setOffline);
+        };
+    }, []);
+    return isOnline;
+}

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

@@ -1,3 +1,3 @@
-export { deleteSession, login, authRefresh } from "./actions.js";
-export { createCSRFToken, validateCSRFToken } from "../csrf.js";
+export { deleteSession, login, authRefresh } from './actions.js';
+export { createCSRFToken, validateCSRFToken } from '../csrf.js';
 //# sourceMappingURL=index.d.ts.map