nextjs-cms 0.9.37 → 0.9.38

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

@@ -0,0 +1,82 @@
+import * as z from 'zod';
+export declare const cpanelRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        headers: Headers;
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema.js")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../../index.js").Session | null;
+    };
+    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<{
+    getData: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            dbsLimit: number;
+            dbsCount: number;
+            bandwidthUsage: number;
+            bandwidthLimit: number;
+            diskSpaceUsage: number;
+            diskSpaceLimit: number;
+            emailsUsage: number;
+            emailsLimit: number;
+            dbInfo: any;
+            dbsList: any;
+            phpVersion: any;
+            passengerAppList: never[];
+            documentRoot: any;
+        };
+        meta: object;
+    }>;
+    getEmails: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            emails: any;
+        };
+        meta: object;
+    }>;
+    createEmail: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+            password: string;
+            quota: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    quotaChange: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+            quota: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    passwordChange: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            email: string;
+            password: string;
+            passwordConfirm: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    deleteEmail: import("@trpc/server").TRPCMutationProcedure<{
+        input: string;
+        output: any;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=cpanel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpanel.d.ts","sourceRoot":"","sources":["../../../src/api/routers/cpanel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAKxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0QvB,CAAA"}

package/dist/api/routers/cpanel.js

@@ -0,0 +1,216 @@
+import { privateProcedure, router } from '../trpc.js';
+import { CpanelAPI } from '../../utils/index.js';
+import * as z from 'zod';
+import { TRPCError } from '@trpc/server';
+import getString from '../../translations/index.js';
+// import '@/envConfig'
+export const cpanelRouter = router({
+    getData: privateProcedure.query(async ({ ctx, input }) => {
+        if (!process.env.CPANEL_USER || !process.env.CPANEL_PASSWORD || !process.env.CPANEL_DOMAIN) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('cpanelCredentialsNotSet', ctx.session.user.language),
+            });
+        }
+        const cPanel = new CpanelAPI(process.env.CPANEL_USER, process.env.CPANEL_PASSWORD, `cpanel.${process.env.CPANEL_DOMAIN}`);
+        const data = await Promise.all([
+            cPanel.callApi('DomainInfo', 'single_domain_data', {
+                domain: process.env.CPANEL_DOMAIN,
+            }),
+            cPanel.callApi('ResourceUsage', 'get_usages'),
+            cPanel.callApi('Mysql', 'get_server_information'),
+            cPanel.callApi('Mysql', 'list_databases'),
+            // cPanel.callApi('PassengerApps', 'list_applications'),
+        ]);
+        // console.log(data)
+        if (cPanel.isError) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: cPanel.getError(),
+            });
+        }
+        const dbInfo = data[2];
+        const dbsList = data[3];
+        // const passengerAppList = data[4]
+        let bandwidthLimit = 0, bandwidthUsage = 0;
+        let diskSpaceLimit = 0, usedDiskSpace = 0;
+        let emailsLimit = 0, emailsCount = 0;
+        let dbsLimit = 0, dbsCount = 0;
+        const domainInfoData = data[0].data;
+        const cpanelUsagesArray = data[1].data;
+        cpanelUsagesArray.forEach((singleItemUsage) => {
+            switch (singleItemUsage.id) {
+                case 'bandwidth':
+                    bandwidthLimit = singleItemUsage.maximum || 1000000000000;
+                    bandwidthUsage = singleItemUsage.usage;
+                    break;
+                case 'disk_usage':
+                    diskSpaceLimit = singleItemUsage.maximum || 1000000000000;
+                    usedDiskSpace = singleItemUsage.usage;
+                    break;
+                case 'email_accounts':
+                    emailsLimit = singleItemUsage.maximum || 1000000000000;
+                    emailsCount = singleItemUsage.usage;
+                    break;
+                case 'mysql_databases':
+                    dbsLimit = singleItemUsage.maximum || 1000000000000;
+                    dbsCount = singleItemUsage.usage;
+                    break;
+            }
+        });
+        /*data[4].data = Object.keys(data[4].data).map((key) => {
+            const app = data[4].data[key]
+            return {
+                name: app.name,
+                path: app.path,
+                domain: app.domain,
+                enabled: app.enabled,
+                url: app.base_uri,
+                nodejs: app.nodejs,
+                deploymentMode: app.deployment_mode,
+            }
+        })*/
+        return {
+            dbsLimit,
+            dbsCount,
+            bandwidthUsage,
+            bandwidthLimit,
+            diskSpaceUsage: usedDiskSpace,
+            diskSpaceLimit,
+            emailsUsage: emailsCount,
+            emailsLimit,
+            dbInfo: dbInfo.data,
+            dbsList: dbsList.data,
+            phpVersion: domainInfoData?.phpversion,
+            passengerAppList: [],
+            documentRoot: domainInfoData?.documentroot,
+        };
+    }),
+    getEmails: privateProcedure.query(async ({ ctx, input }) => {
+        if (!process.env.CPANEL_USER || !process.env.CPANEL_PASSWORD || !process.env.CPANEL_DOMAIN) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('cpanelCredentialsNotSet', ctx.session.user.language),
+            });
+        }
+        const cPanel = new CpanelAPI(process.env.CPANEL_USER, process.env.CPANEL_PASSWORD, `cpanel.${process.env.CPANEL_DOMAIN}`);
+        const data = await cPanel.callApi('Email', 'list_pops_with_disk', {
+            domain: process.env.CPANEL_DOMAIN,
+            maxaccounts: 100,
+            no_validate: 1,
+            infinitylang: 1,
+            'api.sort': '1',
+            'api.sort_column': 'mtime',
+        });
+        return {
+            emails: data.data,
+        };
+    }),
+    createEmail: privateProcedure
+        .input(z.object({
+        email: z.string(),
+        password: z.string(),
+        quota: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!process.env.CPANEL_USER || !process.env.CPANEL_PASSWORD || !process.env.CPANEL_DOMAIN) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('cpanelCredentialsNotSet', ctx.session.user.language),
+            });
+        }
+        const cPanel = new CpanelAPI(process.env.CPANEL_USER, process.env.CPANEL_PASSWORD, `cpanel.${process.env.CPANEL_DOMAIN}`);
+        const data = await cPanel.callApi('Email', 'add_pop', {
+            domain: process.env.CPANEL_DOMAIN,
+            email: input.email,
+            password: input.password,
+            quota: input.quota,
+        });
+        if (cPanel.isError) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: cPanel.getError(),
+            });
+        }
+        return data;
+    }),
+    quotaChange: privateProcedure
+        .input(z.object({
+        email: z.string(),
+        quota: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!process.env.CPANEL_USER || !process.env.CPANEL_PASSWORD || !process.env.CPANEL_DOMAIN) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('cpanelCredentialsNotSet', ctx.session.user.language),
+            });
+        }
+        const cPanel = new CpanelAPI(process.env.CPANEL_USER, process.env.CPANEL_PASSWORD, `cpanel.${process.env.CPANEL_DOMAIN}`);
+        const data = await cPanel.callApi('Email', 'edit_pop_quota', {
+            domain: process.env.CPANEL_DOMAIN,
+            email: input.email,
+            quota: input.quota,
+        });
+        if (cPanel.isError) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: cPanel.getError(),
+            });
+        }
+        return data;
+    }),
+    passwordChange: privateProcedure
+        .input(z.object({
+        email: z.string(),
+        password: z.string(),
+        passwordConfirm: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        if (!process.env.CPANEL_USER || !process.env.CPANEL_PASSWORD || !process.env.CPANEL_DOMAIN) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('cpanelCredentialsNotSet', ctx.session.user.language),
+            });
+        }
+        if (input.password !== input.passwordConfirm) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('passwordsDoNotMatch', ctx.session.user.language),
+            });
+        }
+        const cPanel = new CpanelAPI(process.env.CPANEL_USER, process.env.CPANEL_PASSWORD, `cpanel.${process.env.CPANEL_DOMAIN}`);
+        const data = await cPanel.callApi('Email', 'passwd_pop', {
+            domain: process.env.CPANEL_DOMAIN,
+            email: input.email,
+            password: input.password,
+        });
+        if (cPanel.isError) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: cPanel.getError(),
+            });
+        }
+        return data;
+    }),
+    deleteEmail: privateProcedure.input(z.string()).mutation(async ({ ctx, input }) => {
+        if (!process.env.CPANEL_USER || !process.env.CPANEL_PASSWORD || !process.env.CPANEL_DOMAIN) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('cpanelCredentialsNotSet', ctx.session.user.language),
+            });
+        }
+        const cPanel = new CpanelAPI(process.env.CPANEL_USER, process.env.CPANEL_PASSWORD, `cpanel.${process.env.CPANEL_DOMAIN}`);
+        const data = await cPanel.callApi('Email', 'delete_pop', {
+            domain: process.env.CPANEL_DOMAIN,
+            email: input,
+        });
+        if (cPanel.isError) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: cPanel.getError(),
+            });
+        }
+        return data;
+    }),
+});

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

@@ -0,0 +1,35 @@
+import * as z from 'zod';
+export declare const fieldsRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        headers: Headers;
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema.js")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../../index.js").Session | null;
+    };
+    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<{
+    tagsAutoComplete: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            sectionName: string;
+            fieldName: string;
+            query: string;
+            locale?: string | undefined;
+        };
+        output: string[];
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=fields.d.ts.map

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

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

package/dist/api/routers/fields.js

@@ -0,0 +1,81 @@
+import { privateProcedure, router } from '../trpc.js';
+import * as z from 'zod';
+import { SectionFactory } from '../../core/factories/index.js';
+import { TRPCError } from '@trpc/server';
+import getString from '../../translations/index.js';
+import { db } from '../../db/client.js';
+import { sql } from 'drizzle-orm';
+import { is } from '../../core/helpers/index.js';
+import { TagsField } from '../../core/fields/index.js';
+import { getCMSConfig } from '../../core/config/index.js';
+import { resolveLocale } from '../../core/localization/index.js';
+export const fieldsRouter = router({
+    tagsAutoComplete: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        fieldName: z.string(),
+        query: z.string().max(100),
+        locale: z.string().optional(),
+    }))
+        .query(async ({ ctx, input }) => {
+        const sectionConfig = await SectionFactory.getSectionForAdmin({
+            name: input.sectionName,
+            admin: {
+                id: ctx.session.user.id,
+            },
+        });
+        if (!sectionConfig?.name) {
+            throw new TRPCError({
+                code: 'NOT_FOUND',
+                message: getString('sectionNotFound', ctx.session.user.language),
+            });
+        }
+        const section = sectionConfig.build();
+        section.buildFields();
+        const field = section.fields.find((f) => f.name === input.fieldName);
+        if (!field || !is(field, TagsField) || !field.autoCompletion || !field.destinationDb) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: `Field "${input.fieldName}" does not support auto-completion`,
+            });
+        }
+        const { table, selectIdentifier } = field.destinationDb;
+        const searchPattern = `%${input.query}%`;
+        const query = sql `SELECT DISTINCT \`${sql.raw(selectIdentifier)}\` as value
+                    FROM \`${sql.raw(table)}\`
+                    WHERE \`${sql.raw(selectIdentifier)}\` LIKE ${searchPattern}`;
+        if (field.localized) {
+            const cmsConfig = await getCMSConfig();
+            const localeResult = resolveLocale({
+                localization: cmsConfig.localization,
+                locale: input.locale,
+            });
+            if (input.locale !== undefined && !localeResult.localizationEnabled) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: getString('localizationNotEnabledForSection', ctx.session.user.language),
+                });
+            }
+            if (input.locale !== undefined && !localeResult.resolvedLocale) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: getString('invalidLocale', ctx.session.user.language, {
+                        locale: input.locale,
+                        locales: localeResult.availableLocales.map((l) => l.code).join(', '),
+                    }),
+                });
+            }
+            if (localeResult.localizationEnabled) {
+                const localeForQuery = localeResult.isDefault
+                    ? cmsConfig.localization.defaultLocale
+                    : (localeResult.resolvedLocale?.code ?? undefined);
+                if (localeForQuery !== undefined) {
+                    query.append(sql ` AND \`locale\` = ${localeForQuery}`);
+                }
+            }
+        }
+        query.append(sql ` ORDER BY \`${sql.raw(selectIdentifier)}\` ASC LIMIT 20`);
+        const [rows] = await db.execute(query);
+        return rows.map((row) => row.value);
+    }),
+});

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

@@ -0,0 +1,34 @@
+import * as z from 'zod';
+export declare const filesRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        headers: Headers;
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema.js")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../../index.js").Session | null;
+    };
+    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<{
+    getPhoto: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            name: string;
+            folder: string;
+            isThumb?: boolean | undefined;
+        };
+        output: string;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=files.d.ts.map

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

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

package/dist/api/routers/files.js

@@ -0,0 +1,14 @@
+import { privateProcedure, router } from '../trpc.js';
+import * as z from 'zod';
+import { getPhoto } from '../lib/serverActions.js';
+export const filesRouter = router({
+    getPhoto: privateProcedure
+        .input(z.object({
+        name: z.string(),
+        folder: z.string(),
+        isThumb: z.boolean().optional(),
+    }))
+        .query(async ({ ctx, input }) => {
+        return await getPhoto(input);
+    }),
+});

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

@@ -0,0 +1,34 @@
+import * as z from 'zod';
+export declare const galleryRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: {
+        headers: Headers;
+        db: import("drizzle-orm/mysql2").MySql2Database<typeof import("../../db/schema.js")> & {
+            $client: import("mysql2/promise").Pool;
+        };
+        session: import("../../index.js").Session | null;
+    };
+    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<{
+    deletePhoto: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            sectionName: string;
+            photoName: string;
+            referenceId: string;
+        };
+        output: boolean;
+        meta: object;
+    }>;
+}>>;
+//# sourceMappingURL=gallery.d.ts.map

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

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

package/dist/api/routers/gallery.js

@@ -0,0 +1,64 @@
+import { privateProcedure, router } from '../trpc.js';
+import * as z from 'zod';
+import fs from 'fs';
+import path from 'path';
+import { SectionFactory } from '../../core/factories/index.js';
+import { TRPCError } from '@trpc/server';
+import getString from '../../translations/index.js';
+import { db } from '../../db/client.js';
+import { sql } from 'drizzle-orm';
+import { MysqlTableChecker } from '../../core/db/index.js';
+import { getCMSConfig } from '../../core/config/index.js';
+export const galleryRouter = router({
+    deletePhoto: privateProcedure
+        .input(z.object({
+        sectionName: z.string(),
+        photoName: z.string(),
+        referenceId: z.string(),
+    }))
+        .mutation(async ({ ctx, input }) => {
+        const uploadsFolder = (await getCMSConfig()).media.upload.path;
+        /**
+         * Get the section information
+         */
+        const sectionConfig = await SectionFactory.getSectionForAdmin({
+            name: input.sectionName,
+            admin: {
+                id: ctx.session.user.id,
+                requiredRole: 'D',
+            },
+        });
+        if (sectionConfig?.name !== input.sectionName) {
+            throw new TRPCError({
+                code: 'BAD_REQUEST',
+                message: getString('sectionNotFound', ctx.session.user.language),
+            });
+        }
+        const section = sectionConfig?.build();
+        /**
+         * Delete the photo from the database
+         */
+        const gallery = await section.getGallery();
+        if (gallery?.db.tableName) {
+            const columns = await MysqlTableChecker.getColumns(gallery.db.tableName);
+            if (columns.includes(gallery.db.photoNameField) &&
+                columns.includes(gallery.db.referenceIdentifierField)) {
+                await db.execute(sql `DELETE FROM ${sql.raw(gallery.db.tableName)} WHERE ${sql.raw(gallery.db.photoNameField)} = ${input.photoName} AND ${sql.raw(gallery.db.referenceIdentifierField)} = ${input.referenceId}`);
+            }
+        }
+        /**
+         * Delete the photo from disk
+         */
+        try {
+            await fs.promises.unlink(path.join(uploadsFolder, '.photos', section.name, input.photoName));
+            /**
+             * TODO: Thumbs are not being deleted, it throws an error that they are being used by nodejs. Fix this
+             */
+            await fs.promises.unlink(path.join(uploadsFolder, '.thumbs', section.name, input.photoName));
+        }
+        catch (error) {
+            console.error(error);
+        }
+        return true;
+    }),
+});