nextjs-cms 0.5.9 → 0.5.10

package/dist/api/routers/admins.js

@@ -1,219 +1,219 @@
-import { router, privateProcedure } from "../trpc.js";
-import * as z from 'zod';
-import { getAdminsList, getAllPrivileges } from "../lib/serverActions.js";
-import { db } from "../../db/client.js";
-import { AdminPrivilegesTable, AdminsTable } from "../../db/schema.js";
-import { eq } from 'drizzle-orm';
-import { TRPCError } from '@trpc/server';
-import bcrypt from 'bcrypt';
-import { customAlphabet } from 'nanoid';
-import getString from "../../translations.js";
-import path from 'path';
-import fs from 'fs';
-import { getCMSConfig } from "../../core/config.js";
-export const adminsRouter = router({
-    list: privateProcedure.query(async () => {
-        const data = await Promise.all([getAdminsList(), getAllPrivileges()]);
-        const adminList = data[0];
-        const privileges = data[1];
-        return {
-            admins: adminList,
-            privileges: privileges,
-        };
-    }),
-    get: privateProcedure.input(z.string()).query(async (opts) => {
-        const data = await Promise.all([
-            db
-                .select({
-                id: AdminsTable.id,
-                user: AdminsTable.user,
-            })
-                .from(AdminsTable)
-                .where(eq(AdminsTable.id, opts.input)),
-            db
-                .select({
-                sectionName: AdminPrivilegesTable.sectionName,
-                operations: AdminPrivilegesTable.operations,
-                publisher: AdminPrivilegesTable.publisher,
-            })
-                .from(AdminPrivilegesTable)
-                .where(eq(AdminPrivilegesTable.adminId, opts.input)),
-            getAllPrivileges(),
-        ]);
-        const adminRows = data[0];
-        const adminRoles = data[1];
-        const allRoles = data[2];
-        const adminData = adminRows[0];
-        if (!adminData) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: 'Admin not found',
-            });
-        }
-        return {
-            admin: adminData,
-            adminRoles: adminRoles,
-            allRoles: allRoles,
-        };
-    }),
-    create: privateProcedure
-        .input(z.object({
-        username: z.string(),
-        password: z.string(),
-        privileges: z.array(z.object({
-            sectionName: z.string(),
-            publisher: z.boolean().nullable(),
-            operations: z.string(),
-        })),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        /**
-         * First, let's check if the username already exists
-         */
-        const usernameExists = await db.select().from(AdminsTable).where(eq(AdminsTable.user, input.username));
-        /**
-         * If the username already exists, throw an error
-         */
-        if (usernameExists.length > 0) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: getString('adminAlreadyExists'),
-            });
-        }
-        /**
-         * Let's filter the privileges to remove the ones that has operations set to 'none'
-         */
-        const filteredPrivileges = input.privileges.filter((privilege) => privilege.operations !== 'none');
-        /**
-         * If the filtered privileges are empty, throw an error
-         */
-        if (filteredPrivileges.length === 0) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: getString('selectAtLeastOnePrivilege'),
-            });
-        }
-        /**
-         * Hash password with bcrypt
-         */
-        const hashedPassword = await bcrypt.hash(input.password, 10);
-        const id = customAlphabet('1234567890', 25)();
-        const adminCreation = await db.insert(AdminsTable).values({
-            id: id,
-            pass: hashedPassword,
-            user: input.username,
-        });
-        /**
-         * Now, let's prepare the rows to be inserted into the admin_privileges table
-         */
-        const rows = filteredPrivileges.map((privilege) => ({
-            adminId: id,
-            sectionName: privilege.sectionName,
-            operations: privilege.operations,
-            publisher: privilege.publisher,
-        }));
-        /**
-         * Insert the privileges into the admin_privileges table
-         */
-        await db.insert(AdminPrivilegesTable).values(rows);
-        return {
-            status: 'success',
-        };
-    }),
-    update: privateProcedure
-        .input(z.object({
-        id: z.string(),
-        privileges: z.array(z.object({
-            sectionName: z.string(),
-            publisher: z.boolean().nullable(),
-            operations: z.string(),
-        })),
-    }))
-        .mutation(async ({ ctx, input }) => {
-        /**
-         * First, let's check if the admin exists
-         */
-        const usernameExists = await db.select().from(AdminsTable).where(eq(AdminsTable.id, input.id));
-        /**
-         * If the admin doens't exist, throw an error
-         */
-        if (usernameExists.length === 0) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: getString('adminDoesNotExist'),
-            });
-        }
-        /**
-         * Let's filter the privileges to remove the ones that has operations set to 'none'
-         */
-        const filteredPrivileges = input.privileges.filter((privilege) => privilege.operations !== 'none');
-        /**
-         * If the filtered privileges are empty, throw an error
-         */
-        if (filteredPrivileges.length === 0) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: getString('selectAtLeastOnePrivilege'),
-            });
-        }
-        /**
-         * Now, let's prepare the rows to be inserted into the admin_privileges table
-         */
-        const rows = filteredPrivileges.map((privilege) => ({
-            adminId: input.id,
-            sectionName: privilege.sectionName,
-            operations: privilege.operations,
-            publisher: privilege.publisher,
-        }));
-        /**
-         * Delete and then insert the privileges into the admin_privileges table
-         */
-        await db.delete(AdminPrivilegesTable).where(eq(AdminPrivilegesTable.adminId, input.id));
-        await db.insert(AdminPrivilegesTable).values(rows);
-        return {
-            status: 'success',
-        };
-    }),
-    remove: privateProcedure
-        .input(z.object({
-        id: z.string(),
-    }))
-        .mutation(async ({ input }) => {
-        const uploadsFolder = getCMSConfig().files.upload.uploadPath;
-        /**
-         * Check if the admin is not the master admin
-         */
-        if (input.id === '1') {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: getString('masterAdminCannotBeDeleted'),
-            });
-        }
-        /**
-         * Check if the admin exists
-         */
-        const adminResult = await db.select().from(AdminsTable).where(eq(AdminsTable.id, input.id));
-        const admin = adminResult[0];
-        if (!admin) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: getString('adminNotFound'),
-            });
-        }
-        /**
-         * Delete the admin roles from the admin_privileges table
-         */
-        await db.delete(AdminPrivilegesTable).where(eq(AdminPrivilegesTable.adminId, input.id));
-        /**
-         * Delete the admin from the admins table
-         */
-        await db.delete(AdminsTable).where(eq(AdminsTable.id, input.id));
-        /**
-         * Remove the admin avatar as well
-         */
-        if (admin.coverphoto) {
-            await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', 'admins', admin.coverphoto));
-        }
-        return true;
-    }),
-});
+import { router, privateProcedure } from '../trpc.js';
+import * as z from 'zod';
+import { getAdminsList, getAllPrivileges } from '../lib/serverActions.js';
+import { db } from '../../db/client.js';
+import { AdminPrivilegesTable, AdminsTable } from '../../db/schema.js';
+import { eq } from 'drizzle-orm';
+import { TRPCError } from '@trpc/server';
+import bcrypt from 'bcrypt';
+import { customAlphabet } from 'nanoid';
+import getString from '../../translations/index.js';
+import path from 'path';
+import fs from 'fs';
+import { getCMSConfig } from '../../core/config/index.js';
+export const adminsRouter = router({
+    list: privateProcedure.query(async () => {
+        const data = await Promise.all([getAdminsList(), getAllPrivileges()]);
+        const adminList = data[0];
+        const privileges = data[1];
+        return {
+            admins: adminList,
+            privileges: privileges,
+        };
+    }),
+    get: privateProcedure.input(z.string()).query(async (opts) => {
+        const data = await Promise.all([
+            db
+                .select({
+                id: AdminsTable.id,
+                user: AdminsTable.user,
+            })
+                .from(AdminsTable)
+                .where(eq(AdminsTable.id, opts.input)),
+            db
+                .select({
+                sectionName: AdminPrivilegesTable.sectionName,
+                operations: AdminPrivilegesTable.operations,
+                publisher: AdminPrivilegesTable.publisher,
+            })
+                .from(AdminPrivilegesTable)
+                .where(eq(AdminPrivilegesTable.adminId, opts.input)),
+            getAllPrivileges(),
+        ]);
+        const adminRows = data[0];
+        const adminRoles = data[1];
+        const allRoles = data[2];
+        const adminData = adminRows[0];
+        if (!adminData) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'Admin not found',
+            });
+        }
+        return {
+            admin: adminData,
+            adminRoles: adminRoles,
+            allRoles: allRoles,
+        };
+    }),
+    create: privateProcedure
+        .input(z.object({
+        username: z.string(),
+        password: z.string(),
+        privileges: z.array(z.object({
+            sectionName: z.string(),
+            publisher: z.boolean().nullable(),
+            operations: z.string(),
+        })),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        /**
+         * First, let's check if the username already exists
+         */
+        const usernameExists = await db.select().from(AdminsTable).where(eq(AdminsTable.user, input.username));
+        /**
+         * If the username already exists, throw an error
+         */
+        if (usernameExists.length > 0) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('adminAlreadyExists'),
+            });
+        }
+        /**
+         * Let's filter the privileges to remove the ones that has operations set to 'none'
+         */
+        const filteredPrivileges = input.privileges.filter((privilege) => privilege.operations !== 'none');
+        /**
+         * If the filtered privileges are empty, throw an error
+         */
+        if (filteredPrivileges.length === 0) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('selectAtLeastOnePrivilege'),
+            });
+        }
+        /**
+         * Hash password with bcrypt
+         */
+        const hashedPassword = await bcrypt.hash(input.password, 10);
+        const id = customAlphabet('1234567890', 25)();
+        const adminCreation = await db.insert(AdminsTable).values({
+            id: id,
+            pass: hashedPassword,
+            user: input.username,
+        });
+        /**
+         * Now, let's prepare the rows to be inserted into the admin_privileges table
+         */
+        const rows = filteredPrivileges.map((privilege) => ({
+            adminId: id,
+            sectionName: privilege.sectionName,
+            operations: privilege.operations,
+            publisher: privilege.publisher,
+        }));
+        /**
+         * Insert the privileges into the admin_privileges table
+         */
+        await db.insert(AdminPrivilegesTable).values(rows);
+        return {
+            status: 'success',
+        };
+    }),
+    update: privateProcedure
+        .input(z.object({
+        id: z.string(),
+        privileges: z.array(z.object({
+            sectionName: z.string(),
+            publisher: z.boolean().nullable(),
+            operations: z.string(),
+        })),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        /**
+         * First, let's check if the admin exists
+         */
+        const usernameExists = await db.select().from(AdminsTable).where(eq(AdminsTable.id, input.id));
+        /**
+         * If the admin doens't exist, throw an error
+         */
+        if (usernameExists.length === 0) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('adminDoesNotExist'),
+            });
+        }
+        /**
+         * Let's filter the privileges to remove the ones that has operations set to 'none'
+         */
+        const filteredPrivileges = input.privileges.filter((privilege) => privilege.operations !== 'none');
+        /**
+         * If the filtered privileges are empty, throw an error
+         */
+        if (filteredPrivileges.length === 0) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('selectAtLeastOnePrivilege'),
+            });
+        }
+        /**
+         * Now, let's prepare the rows to be inserted into the admin_privileges table
+         */
+        const rows = filteredPrivileges.map((privilege) => ({
+            adminId: input.id,
+            sectionName: privilege.sectionName,
+            operations: privilege.operations,
+            publisher: privilege.publisher,
+        }));
+        /**
+         * Delete and then insert the privileges into the admin_privileges table
+         */
+        await db.delete(AdminPrivilegesTable).where(eq(AdminPrivilegesTable.adminId, input.id));
+        await db.insert(AdminPrivilegesTable).values(rows);
+        return {
+            status: 'success',
+        };
+    }),
+    remove: privateProcedure
+        .input(z.object({
+        id: z.string(),
+    }))
+        .mutation(async ({ input }) => {
+        const uploadsFolder = getCMSConfig().files.upload.uploadPath;
+        /**
+         * Check if the admin is not the master admin
+         */
+        if (input.id === '1') {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('masterAdminCannotBeDeleted'),
+            });
+        }
+        /**
+         * Check if the admin exists
+         */
+        const adminResult = await db.select().from(AdminsTable).where(eq(AdminsTable.id, input.id));
+        const admin = adminResult[0];
+        if (!admin) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('adminNotFound'),
+            });
+        }
+        /**
+         * Delete the admin roles from the admin_privileges table
+         */
+        await db.delete(AdminPrivilegesTable).where(eq(AdminPrivilegesTable.adminId, input.id));
+        /**
+         * Delete the admin from the admins table
+         */
+        await db.delete(AdminsTable).where(eq(AdminsTable.id, input.id));
+        /**
+         * Remove the admin avatar as well
+         */
+        if (admin.coverphoto) {
+            await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', 'admins', admin.coverphoto));
+        }
+        return true;
+    }),
+});

package/dist/api/routers/auth.d.ts

@@ -1,48 +1,48 @@
-import * as z from 'zod';
-export declare const authRouter: import("@trpc/server").TRPCBuiltRouter<{
-    ctx: {
-        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema.js")> & {
-            $client: import("mysql2/promise").Pool;
-        };
-        session: import("../...js").Session | null;
-        opts: {
-            headers: Headers;
-        };
-    };
-    meta: object;
-    errorShape: {
-        data: {
-            zodError: z.core.$ZodFlattenedError<unknown, string> | null;
-            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
-            httpStatus: number;
-            path?: string;
-            stack?: string;
-        };
-        message: string;
-        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
-    };
-    transformer: true;
-}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
-    login: import("@trpc/server").TRPCMutationProcedure<{
-        input: {
-            username: string;
-            password: string;
-        };
-        output: {
-            user: {
-                id: string;
-                username: string;
-                lang: string | null;
-                avatar: string | null;
-            };
-            accessToken: string;
-        };
-        meta: object;
-    }>;
-    logout: import("@trpc/server").TRPCMutationProcedure<{
-        input: void;
-        output: boolean;
-        meta: object;
-    }>;
-}>>;
+import * as z from 'zod';
+export declare const authRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema.js")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../../index.js").Session | null;
+        opts: {
+            headers: Headers;
+        };
+    };
+    meta: object;
+    errorShape: {
+        data: {
+            zodError: z.core.$ZodFlattenedError<unknown, string> | null;
+            code: import("@trpc/server").TRPC_ERROR_CODE_KEY;
+            httpStatus: number;
+            path?: string;
+            stack?: string;
+        };
+        message: string;
+        code: import("@trpc/server").TRPC_ERROR_CODE_NUMBER;
+    };
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    login: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            username: string;
+            password: string;
+        };
+        output: {
+            user: {
+                id: string;
+                username: string;
+                lang: string | null;
+                avatar: string | null;
+            };
+            accessToken: string;
+        };
+        meta: object;
+    }>;
+    logout: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: boolean;
+        meta: object;
+    }>;
+}>>;
 //# sourceMappingURL=auth.d.ts.map

package/dist/api/routers/auth.js

@@ -1,25 +1,25 @@
-import { privateProcedure, publicProcedure, router } from "../trpc.js";
-import * as z from 'zod';
-import { TRPCError } from '@trpc/server';
-import { deleteSession, login } from "../../auth/lib.js";
-export const authRouter = router({
-    login: publicProcedure
-        .input(z.object({
-        username: z.string(),
-        password: z.string(),
-    }))
-        .mutation(async (opts) => {
-        try {
-            return await login(opts.input);
-        }
-        catch (error) {
-            throw new TRPCError({
-                code: 'BAD_REQUEST',
-                message: error.message,
-            });
-        }
-    }),
-    logout: privateProcedure.mutation(async (opts) => {
-        return await deleteSession(opts.ctx.session);
-    }),
-});
+import { privateProcedure, publicProcedure, router } from '../trpc.js';
+import * as z from 'zod';
+import { TRPCError } from '@trpc/server';
+import { deleteSession, login } from '../../auth/lib/index.js';
+export const authRouter = router({
+    login: publicProcedure
+        .input(z.object({
+        username: z.string(),
+        password: z.string(),
+    }))
+        .mutation(async (opts) => {
+        try {
+            return await login(opts.input);
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: error.message,
+            });
+        }
+    }),
+    logout: privateProcedure.mutation(async (opts) => {
+        return await deleteSession(opts.ctx.session);
+    }),
+});