nextjs-cms 0.0.1 → 0.5.1

package/dist/api/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../src/api/root.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgBpB,CAAA;AAIF,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAA"}

package/dist/api/root.js

@@ -0,0 +1,30 @@
+import { privateProcedure, router } from './trpc';
+import { adminsRouter } from './routers/admins';
+import { hasItemsSectionRouter } from './routers/hasItemsSection';
+import { filesRouter } from './routers/files';
+import { authRouter } from './routers/auth';
+import { navRouter } from './routers/navigation';
+import { simpleSectionRouter } from './routers/simpleSection';
+import { categorySectionRouter } from './routers/categorySection';
+import { accountSettings } from './routers/accountSettings';
+import { cmsSettings } from './routers/cmsSettings';
+import { galleryRouter } from './routers/gallery';
+import { cpanelRouter } from './routers/cpanel';
+import { googleAnalyticsRouter } from './routers/googleAnalytics';
+export const appRouter = router({
+    auth: authRouter,
+    admins: adminsRouter,
+    hasItemsSections: hasItemsSectionRouter,
+    simpleSections: simpleSectionRouter,
+    categorySections: categorySectionRouter,
+    files: filesRouter,
+    gallery: galleryRouter,
+    navigation: navRouter,
+    accountSettings: accountSettings,
+    cmsSettings: cmsSettings,
+    cpanel: cpanelRouter,
+    googleAnalytics: googleAnalyticsRouter,
+    getHello1: privateProcedure.query(async ({ ctx }) => {
+        return ctx;
+    }),
+});

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

@@ -0,0 +1,61 @@
+import * as z from 'zod';
+export declare const accountSettings: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../..").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<{
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            id: string;
+            username: string;
+            emailAddress: string | null;
+            fullName: string | null;
+            avatar: string | null;
+            phoneNumber: string | null;
+        } | undefined;
+        meta: object;
+    }>;
+    /**
+     * No avatar for now, if you want to include it, you have to use the api route,
+     *  because trpc doesn't support file uploads.
+     */
+    save: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            emailAddress: string;
+            fullName: string;
+            phoneNumber: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+    changePassword: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            oldPassword: string;
+            newPassword: string;
+            confirmPassword: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=accountSettings.d.ts.map

package/dist/api/routers/accountSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountSettings.d.ts","sourceRoot":"","sources":["../../../src/api/routers/accountSettings.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkBxB;;;OAGG;;;;;;;;;;;;;;;;;;;GA4FL,CAAA"}

package/dist/api/routers/accountSettings.js

@@ -0,0 +1,108 @@
+import { privateProcedure, router } from '../trpc';
+import { db } from '../../db/client';
+import { AdminsTable } from '../../db/schema';
+import { eq } from 'drizzle-orm';
+import * as z from 'zod';
+import bcrypt from 'bcrypt';
+import { TRPCError } from '@trpc/server';
+export const accountSettings = router({
+    get: privateProcedure.query(async ({ ctx }) => {
+        const admin = await db
+            .select({
+            id: AdminsTable.id,
+            username: AdminsTable.user,
+            emailAddress: AdminsTable.emailAddress,
+            fullName: AdminsTable.fullName,
+            avatar: AdminsTable.coverphoto,
+            phoneNumber: AdminsTable.phoneNumber,
+        })
+            .from(AdminsTable)
+            .where(eq(AdminsTable.id, ctx.session.user.id))
+            .limit(1);
+        return admin[0];
+    }),
+    /**
+     * No avatar for now, if you want to include it, you have to use the api route,
+     *  because trpc doesn't support file uploads.
+     */
+    save: privateProcedure
+        .input(z.object({
+        emailAddress: z.string(),
+        fullName: z.string(),
+        phoneNumber: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        await db
+            .update(AdminsTable)
+            .set({
+            emailAddress: input.emailAddress,
+            fullName: input.fullName,
+            phoneNumber: input.phoneNumber,
+        })
+            .where(eq(AdminsTable.id, ctx.session.user.id))
+            .execute();
+        return true;
+    }),
+    changePassword: privateProcedure
+        .input(z.object({
+        oldPassword: z.string(),
+        newPassword: z.string(),
+        confirmPassword: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        /**
+         * Check if old password is correct
+         */
+        const result = await db
+            .select({
+            password: AdminsTable.pass,
+        })
+            .from(AdminsTable)
+            .where(eq(AdminsTable.id, ctx.session.user.id))
+            .limit(1);
+        const admin = result[0];
+        /**
+         * Check if admin exists
+         */
+        if (!admin) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: 'Admin not found',
+            });
+        }
+        /**
+         * Check password with bcrypt
+         */
+        const match = await bcrypt.compare(input.oldPassword, admin.password);
+        if (!match) {
+            throw new TRPCError({
+                code: 'UNAUTHORIZED',
+                message: 'Old password is incorrect',
+            });
+        }
+        /**
+         * Check if new password and confirm password are the same
+         */
+        if (input.newPassword !== input.confirmPassword) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: 'New password and confirm password do not match',
+            });
+        }
+        /**
+         * Hash new password
+         */
+        const hashedPassword = await bcrypt.hash(input.newPassword, 10);
+        /**
+         * Update password
+         */
+        await db
+            .update(AdminsTable)
+            .set({
+            pass: hashedPassword,
+        })
+            .where(eq(AdminsTable.id, ctx.session.user.id))
+            .execute();
+        return true;
+    }),
+});

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

@@ -0,0 +1,106 @@
+import * as z from 'zod';
+export declare const adminsRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../..").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<{
+    list: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            admins: {
+                id: string;
+                username: string;
+                avatar: string | null;
+                roles: {
+                    operations: "C" | "U" | "D" | "CU" | "CD" | "UD" | "CUD";
+                    publisher: boolean | null;
+                    sectionName: string;
+                }[];
+            }[];
+            privileges: {
+                title: string;
+                order: number;
+                sectionType: string;
+                sectionName: string;
+            }[];
+        };
+        meta: object;
+    }>;
+    get: import("@trpc/server").TRPCQueryProcedure<{
+        input: string;
+        output: {
+            admin: {
+                id: string;
+                user: string;
+            };
+            adminRoles: {
+                sectionName: string;
+                operations: "C" | "U" | "D" | "CU" | "CD" | "UD" | "CUD";
+                publisher: boolean | null;
+            }[];
+            allRoles: {
+                title: string;
+                order: number;
+                sectionType: string;
+                sectionName: string;
+            }[];
+        };
+        meta: object;
+    }>;
+    create: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            username: string;
+            password: string;
+            privileges: {
+                sectionName: string;
+                publisher: boolean | null;
+                operations: string;
+            }[];
+        };
+        output: {
+            status: string;
+        };
+        meta: object;
+    }>;
+    update: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            privileges: {
+                sectionName: string;
+                publisher: boolean | null;
+                operations: string;
+            }[];
+        };
+        output: {
+            status: string;
+        };
+        meta: object;
+    }>;
+    remove: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=admins.d.ts.map

package/dist/api/routers/admins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"admins.d.ts","sourceRoot":"","sources":["../../../src/api/routers/admins.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAaxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+OvB,CAAA"}

package/dist/api/routers/admins.js

@@ -0,0 +1,219 @@
+import { router, privateProcedure } from '../trpc';
+import * as z from 'zod';
+import { getAdminsList, getAllPrivileges } from '../lib/serverActions';
+import { db } from '../../db/client';
+import { AdminPrivilegesTable, AdminsTable } from '../../db/schema';
+import { eq } from 'drizzle-orm';
+import { TRPCError } from '@trpc/server';
+import bcrypt from 'bcrypt';
+import { customAlphabet } from 'nanoid';
+import getString from '../../translations';
+import path from 'path';
+import fs from 'fs';
+import { getCMSConfig } from '../../core/config';
+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

@@ -0,0 +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")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../..").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.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/api/routers/auth.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAIxB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsBrB,CAAA"}

package/dist/api/routers/auth.js

@@ -0,0 +1,25 @@
+import { privateProcedure, publicProcedure, router } from '../trpc';
+import * as z from 'zod';
+import { TRPCError } from '@trpc/server';
+import { deleteSession, login } from '../../auth/lib';
+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);
+    }),
+});