@speresps/pdf-module 0.0.0-stage → 1.0.1

package/api/client/clientApi.js

@@ -0,0 +1,45 @@
+"use server";
+
+import generatePdfService from "../../service/generatePdfService.js";
+import pdfFileService from "../../service/pdfFileService.js";
+
+
+
+export async function generatePDFTable(data) {
+    return await generatePdfService.PDFTable(data);
+}
+
+export async function generatePDFText(data) {
+    return await generatePdfService.PDFText(data);
+}
+
+export async function generatePDFTextAndTable(data) {
+    return await generatePdfService.PDFTextAndTable(data);
+}
+
+export async function generatePDFTextAndTableWithPagination(data) {
+    return await generatePdfService.PDFTextAndTableWithPagination(data);
+}
+
+export async function existsPDF(fileName) {
+    return await pdfFileService.exists(fileName);
+}
+
+export async function getPDFFile (fileName) {
+
+    if (typeof fileName !== "string" || !fileName.trim()) {
+        throw new Error("A valid PDF file name is required.");
+    }
+
+    const result = await pdfFileService.read(fileName);
+
+    if (!result?.success || !result.buffer?.length) {
+        throw new Error("PDF file could not be read.");
+    }
+    return {
+        success: true,
+        fileName: result.fileName,
+        mimeType: "application/pdf",
+        data: result.buffer.toString("base64")
+    };
+}

package/api/server/serverApi.js

@@ -0,0 +1,26 @@
+import generatePdfService from "../../service/generatePdfService.js";
+import pdfFileService from "../../service/pdfFileService.js";
+
+export async function generatePDFTable(data) {
+    return await generatePdfService.PDFTable(data);
+}
+
+export async function generatePDFText(data) {
+    return await generatePdfService.PDFText(data);
+}
+
+export async function generatePDFTextAndTable(data) {
+    return await generatePdfService.PDFTextAndTable(data);
+}
+
+export async function generatePDFTextAndTableWithPagination(data) {
+    return await generatePdfService.PDFTextAndTableWithPagination(data);
+}
+
+export async function downloadPDF(fileName) {
+    return await pdfFileService.read(fileName);
+}
+
+export async function existsPDF(fileName) {
+    return await pdfFileService.exists(fileName);
+}

package/configManager/config.js

@@ -0,0 +1,29 @@
+import {loadConfig} from "@speresps/config-module";
+
+const config = loadConfig({
+    fileName: "pdf.conf",
+    defaults: {
+    // table
+    FILENAME_TABLE : "table.pdf",
+
+    // text
+    FILENAME_TEXT : "text.pdf",
+
+    // text table
+    FILENAME_TEXT_TABLE : "text-table.pdf",
+
+    // text table pagination
+    FILENAME_TEXT_TABLE_PAGINATION : "text-table-pagination.pdf",
+
+    // auto download status
+    AUTO_DOWNLOAD : "false",
+
+    // files route
+    MAIN_FOLDER_NAME:"files",
+    PDF_FOLDER_NAME:"pdf"
+
+    },
+    required: true
+});
+
+export default config;

package/logManager/logger.js

@@ -0,0 +1,11 @@
+// logManager/logger.js:
+import { reportLogger } from "@speresps/report-module";
+
+const logger = reportLogger({
+    directory: "./report/logs",
+    level: "debug",
+    console: false,
+    service: "PDF",
+});
+
+export default logger;

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@speresps/pdf-module",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.1",
+  "description": "A reusable PDF generation and document management module for Node.js and Next.js applications, supporting Persian RTL documents, customizable headers and footers, text and table templates, paginated reports, PDF file storage, and browser downloads.",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./server": "./src/server/index.js",
+    "./client": "./src/client/index.js"
+  },
+  "files": [
+    "src/",
+    "api/",
+    "configManager/",
+    "logManager/",
+    "service/",
+    "template/",
+    "README.md"
+  ],
+  "keywords": [
+    "pdf",
+    "pdf-generation",
+    "pdfmake",
+    "persian-pdf",
+    "rtl",
+    "vazirmatn",
+    "pdf-template",
+    "pdf-table",
+    "pdf-pagination",
+    "pdf-download",
+    "nodejs",
+    "nextjs"
+  ],
+  "dependencies": {
+    "@speresps/config-module": "^1.0.1",
+    "@speresps/report-module": "^1.0.0",
+    "pdfmake-rtl": "^2.1.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "author": "speresps",
+  "license": "MIT"
 }

package/service/generatePdfService.js

@@ -0,0 +1,251 @@
+import logger from "../logManager/logger.js";
+import config from "../configManager/config.js";
+
+import {
+    validateTableData,
+    validatePDFTextData,
+    validatePDFTextAndTableData,
+    validatePDFPaginationData
+} from "./validation/validateData.js";
+
+import { generatePDFTable } from '../template/generatePDFTable/generatePDFTable.js';
+import { generatePDFText } from '../template/generatePDFText/generatePDFText.js';
+import { generatePDFTextAndTable } from '../template/generatePDFTextAndTable/generatePDFTextAndTable.js';
+import { generatePDFTextAndTableWithPagination } from '../template/generatePDFTextAndTableWithPagination/generatePDFTextAndTableWithPagination.js';
+
+import pdfBufferService from './pdfBufferService.js';
+import pdfFileService from './pdfFileService.js';
+
+const fileNameTable = config.FILENAME_TABLE;
+const fileNameText = config.FILENAME_TEXT;
+const fileNameTextTable = config.FILENAME_TEXT_TABLE;
+const fileNameTextTablePagination = config.FILENAME_TEXT_TABLE_PAGINATION;
+
+const AUTO_DOWNLOAD = config.AUTO_DOWNLOAD;
+
+
+class generatePdfService {
+
+    async PDFTable(data){
+        try{
+
+            logger.info(`GeneratePdfService in PDFTable Started.`);
+
+            if(!data) {
+                logger.error(`GeneratePdfService in PDFTable, data is required.`);
+                throw new Error("Data in Generate PDF For Table Not Find.")
+            }
+
+            validateTableData(data);
+
+            // تولید pdf
+            let pdfDocument  = await generatePDFTable({
+                ...data,
+                AUTO_DOWNLOAD});
+
+            if(!pdfDocument ){
+                logger.error(`GeneratePdfService in PDFTable, Don't Generate PDF For Table.`);
+                throw new Error("Don't Generate PDF For Table")
+            }
+
+            // تبدیل pdf به بافر
+            const pdfBuffer = await pdfBufferService.getBuffer(pdfDocument);
+
+            if (!pdfBuffer) {
+                logger.error(`GeneratePdfService in PDFTable, Don't Generate PDF Buffer For Table.`);
+                throw new Error("Don't Generate PDF Buffer For Table");
+            }
+
+            // ذخیره ی بافر pdf در پوشه ی files
+            const result =
+                await pdfFileService.save(
+                    pdfBuffer,
+                    data.fileName || fileNameTable
+                );
+
+            if (!result || !result.success) {
+                logger.error(`GeneratePdfService in PDFTable, Don't Save PDF File For Table.`);
+                throw new Error("Don't Save PDF File For Table");
+            }
+
+            return {
+                success : true,
+                result
+            }
+
+        }
+        catch (err){
+            return {
+                success: false,
+                message: err.message,
+            }
+        }
+    }
+
+    async PDFText(data){
+        try{
+            logger.info(`GeneratePdfService in PDFText Started.`);
+
+            if(!data) {
+                logger.error(`GeneratePdfService in PDFText, dats is required.`);
+                throw new Error("Data in Generate PDF For Text Not Find.")
+            }
+
+            validatePDFTextData(data);
+
+            let pdfDocument  = await generatePDFText({
+                ...data,
+                AUTO_DOWNLOAD});
+
+            if(!pdfDocument ){
+                logger.error(`GeneratePdfService in PDFText, Don't Generate PDF For Text.`);
+                throw new Error("Don't Generate PDF For Text")
+            }
+
+            const pdfBuffer = await pdfBufferService.getBuffer(pdfDocument);
+
+            if (!pdfBuffer) {
+                logger.error(`GeneratePdfService in PDFText, Don't Generate PDF Buffer For Text.`);
+                throw new Error("Don't Generate PDF Buffer For Text");
+            }
+
+            const result = await pdfFileService.save(pdfBuffer, data.fileName || fileNameText);
+
+            if (!result || !result.success) {
+                logger.error(`GeneratePdfService in PDFText, Don't Save PDF File For Text.`);
+                throw new Error("Don't Save PDF File For Text");
+            }
+
+            return {
+                success : true,
+                result
+            }
+
+        }
+        catch (err){
+            return {
+                success: false,
+                message: err.message,
+            }
+        }
+    }
+
+    async PDFTextAndTable(data) {
+
+        try {
+
+            logger.info(`GeneratePdfService in PDFTextAndTable Started.`);
+
+            if (!data) {
+                logger.error(`GeneratePdfService in PDFTextAndTable, data is required.`);
+                throw new Error("Data in Generate PDF For Text And Table Not Find.");
+            }
+
+            validatePDFTextAndTableData(data);
+
+            const pdfDocument =
+                await generatePDFTextAndTable({
+                    ...data,
+                    AUTO_DOWNLOAD
+                });
+
+            if (!pdfDocument) {
+                logger.error(`GeneratePdfService in PDFTextAndTable, Don't Generate PDF For Text and Table.`);
+                throw new Error("Don't Generate PDF For Text And Table");
+            }
+
+            const pdfBuffer =
+                await pdfBufferService.getBuffer(
+                    pdfDocument
+                );
+
+            if (!pdfBuffer) {
+                logger.error(`GeneratePdfService in PDFTextAndTable, Don't Generate PDF Buffer For Text And Table.`);
+                throw new Error("Don't Generate PDF Buffer For Text And Table");
+            }
+
+            const result =
+                await pdfFileService.save(
+                    pdfBuffer,
+                    data.fileName || fileNameTextTable
+                );
+
+            if (!result || !result.success) {
+                logger.error(`GeneratePdfService in PDFTextAndTable, Don't Save PDF File For Text And Table.`);
+                throw new Error("Don't Save PDF File For Text And Table");
+            }
+
+            return {
+                success: true,
+                result
+            };
+
+        } catch (err) {
+            return {
+                success: false,
+                message: err.message
+            };
+        }
+    }
+
+    async PDFTextAndTableWithPagination(data) {
+
+        try {
+
+            logger.info(`GeneratePdfService in PDFTextAndTableWithPagination Started.`);
+
+            if (!data) {
+                logger.error(`GeneratePdfService in PDFTextAndTableWithPagination, data is required.`);
+                throw new Error("Data in Generate PDF For Text And Table with Pagination Not Find.");
+            }
+
+            validatePDFPaginationData(data);
+
+            const pdfDocument =
+                await generatePDFTextAndTableWithPagination({
+                    ...data,
+                    AUTO_DOWNLOAD
+                });
+
+            if (!pdfDocument) {
+                logger.error(`GeneratePdfService in PDFTextAndTableWithPagination, Don't Generate PDF For Text And Table with Pagination.`);
+                throw new Error("Don't Generate PDF For Text And Table with Pagination");
+            }
+
+            const pdfBuffer =
+                await pdfBufferService.getBuffer(
+                    pdfDocument
+                );
+
+            if (!pdfBuffer) {
+                logger.error(`GeneratePdfService in PDFTextAndTableWithPagination, Don't Generate PDF Buffer For Text And Table with Pagination.`);
+                throw new Error("Don't Generate PDF Buffer For Text And Table with Pagination");
+            }
+
+            const result =
+                await pdfFileService.save(
+                    pdfBuffer,
+                    data.fileName ||
+                    fileNameTextTablePagination
+                );
+
+            if (!result || !result.success) {
+                logger.error(`GeneratePdfService in PDFTextAndTableWithPagination, Don't Save PDF File For Text And Table with Pagination.`);
+                throw new Error("Don't Save PDF File For Text And Table with Pagination");
+            }
+
+            return {
+                success: true,
+                result
+            };
+
+        } catch (err) {
+            return {
+                success: false,
+                message: err.message
+            };
+        }
+    }
+}
+
+export default new generatePdfService;

package/service/pdfBufferService.js

@@ -0,0 +1,39 @@
+import logger from "../logManager/logger.js";
+
+class PdfBufferService {
+
+    async getBuffer(pdfDocument) {
+
+        if (!pdfDocument || typeof pdfDocument.getBuffer !== "function") {
+            logger.error("PdfBufferService: A valid PDF Document is required.");
+            throw new Error("A valid PDF Document is required.");
+        }
+
+        try {
+
+            const buffer = await pdfDocument.getBuffer();
+
+            if (!buffer || buffer.length === 0) {
+                logger.error("PdfBufferService: PDF Buffer was not generated.");
+                throw new Error("PDF Buffer was not generated.");
+            }
+
+            return buffer;
+
+        } catch (error) {
+
+            logger.error(
+                `PdfBufferService in getBuffer encountered an error: ${error.message}`
+            );
+
+            throw new Error(
+                `Failed to generate PDF Buffer: ${error.message}`,
+                { cause: error }
+            );
+
+        }
+    }
+
+}
+
+export default new PdfBufferService();

package/service/pdfFileService.js

@@ -0,0 +1,187 @@
+import fs from "fs/promises";
+import path from "path";
+
+import logger from "../logManager/logger.js";
+import config from "../configManager/config.js";
+
+const mainFolderName = config.MAIN_FOLDER_NAME;
+const pdfFolderName = config.PDF_FOLDER_NAME;
+
+
+class PdfFileService {
+
+    // مسیر ذخیره pdf
+    getPdfDirectory() {
+
+        return path.resolve(
+            mainFolderName,
+            pdfFolderName
+        );
+
+    }
+
+
+    // save PDF :
+    // در پوشه ی files در سطح پروژه pdf تولید شده را ذخیره میکند
+    async save(buffer, fileName) {
+
+        if (!buffer) {
+            logger.error(`PdfFileService in Save, PDF Buffer is required.`);
+            throw new Error("PDF Buffer is required.");
+        }
+
+        if (!fileName) {
+            logger.error(`PdfFileService in Save, PDF File Name is required.`);
+            throw new Error("PDF File Name is required.");
+        }
+
+        try {
+
+            const pdfDirectory = this.getPdfDirectory();
+
+            await fs.mkdir(pdfDirectory, {
+                recursive: true
+            });
+
+            if (
+                typeof fileName !== "string" ||
+                !fileName.trim() ||
+                path.extname(fileName).toLowerCase() !== ".pdf"
+            ) {
+                throw new Error("A valid PDF filename is required.");
+            }
+
+            const safeFileName = path.basename(fileName);
+
+            const filePath = path.join(
+                pdfDirectory,
+                safeFileName
+            );
+
+            await fs.writeFile(
+                filePath,
+                buffer
+            );
+
+            return {
+                success: true,
+                fileName: safeFileName,
+                filePath
+            };
+
+        } catch (error) {
+            logger.error(`PdfFileService in Save Have a Error: ${error.message}.`);
+            throw new Error(`Save PDF File Have a Error: ${error.message}`);
+        }
+    }
+
+
+    // read PDF :
+    // برای خواندن pdf ذخیره شده از پوشه ی files موقع استفاده برای download
+    async read(fileName) {
+
+        if (!fileName) {
+            logger.error(`PdfFileService in Read, PDF File Name is required.`);
+            throw new Error("PDF File Name is required.");
+        }
+
+        try {
+
+            const pdfDirectory = this.getPdfDirectory();
+
+            if (
+                typeof fileName !== "string" ||
+                !fileName.trim() ||
+                path.extname(fileName).toLowerCase() !== ".pdf"
+            ) {
+                throw new Error("A valid PDF filename is required.");
+            }
+
+            const safeFileName = path.basename(fileName);
+
+            const filePath = path.join(
+                pdfDirectory,
+                safeFileName
+            );
+
+            const buffer = await fs.readFile(
+                filePath
+            );
+
+            return {
+                success: true,
+                fileName: safeFileName,
+                filePath,
+                buffer
+            };
+
+        } catch (error) {
+
+            if (error.code === "ENOENT") {
+                logger.error(`PdfFileService in Read, PDF File Not Found.`);
+                throw new Error("PDF File Not Found.");
+            }
+
+            logger.error(`PdfFileService in Read Have a Error: ${error.message}.`);
+
+            throw new Error(`Read PDF File Have a Error: ${error.message}`);
+
+        }
+    }
+
+
+    // exist PDF :
+    // این متد وجود PDF را بررسی میکند در صورت وجود pdf ، یعنی مراحل ساخت pdf کامل شده
+    async exists(fileName) {
+
+        if (!fileName) {
+            logger.error(`PdfFileService in Exists, PDF File Name is required.`);
+            throw new Error("PDF File Name is required.");
+        }
+
+        try {
+
+            const pdfDirectory = this.getPdfDirectory();
+
+            if (
+                typeof fileName !== "string" ||
+                !fileName.trim() ||
+                path.extname(fileName).toLowerCase() !== ".pdf"
+            ) {
+                throw new Error("A valid PDF filename is required.");
+            }
+
+            const safeFileName = path.basename(fileName);
+
+            const filePath = path.join(pdfDirectory, safeFileName);
+
+            await fs.access(filePath);
+
+            return {
+                exist: true,
+                fileName: safeFileName,
+                filePath
+            };
+
+        } catch (error) {
+
+            if (error.code === "ENOENT") {
+                logger.error(`PdfFileService in Exists, PDF File Not Found.`);
+
+                return {
+                    exist: false,
+                    fileName,
+                    filePath: null
+                };
+            }
+
+            logger.error(`PdfFileService in Exists Have a Error: ${error.message}.`);
+
+            throw new Error(`Check PDF File Have a Error: ${error.message}`);
+        }
+    }
+
+
+}
+
+export default new PdfFileService();