feat: embed json certificate into pdf

package.json

@@ -91,6 +91,7 @@
     "lodash.merge": "^4.6.2",
     "lodash.set": "^4.3.2",
     "node-cache": "^5.1.2",
+    "pdf-lib": "1.17.1",
     "pdfmake": "0.2.9",
     "reflect-metadata": "^0.2.1",
     "semver-lite": "0.0.6"

packages/generate-pdf/.eslintrc.json

@@ -2,18 +2,6 @@
   "extends": ["../../.eslintrc.json"],
   "ignorePatterns": ["!**/*", "node_modules"],
   "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    },
     {
       "files": ["*.json"],
       "parser": "jsonc-eslint-parser",

packages/generate-pdf/example_coa.ts

@@ -1,8 +1,9 @@
-/* eslint-disable no-console */
-/* eslint-disable @typescript-eslint/no-var-requires */
-import { createWriteStream, readFileSync } from 'fs';
+import { readFileSync } from 'fs';
+import { writeFile } from 'fs/promises';
 
 import { generatePdf, TDocumentDefinitions } from './src/index';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const styles = require(`${__dirname}/../generate-coa-pdf-template/utils/styles.js`);
 
 const CoACertificate = JSON.parse(readFileSync(`${__dirname}/../../fixtures/CoA/v1.1.0/valid_cert_1.json`, 'utf-8'));
@@ -51,29 +52,19 @@ const generatorPath = '../generate-coa-pdf-template/dist/generateContent.cjs';
 
     const pdfDoc = await generatePdf(CoACertificate, {
       docDefinition,
-      outputType: 'stream',
+      outputType: 'buffer',
       generatorPath,
       fonts,
       extraTranslations,
       translations,
       languageFontMap,
+      attachCertificate: true,
     });
 
     const outputFilePath = './coa-test.pdf';
-    const writeStream = createWriteStream(outputFilePath);
-    pdfDoc.pipe(writeStream);
-    pdfDoc.end();
-
-    await new Promise((resolve, reject) => {
-      writeStream
-        .on('finish', () => {
-          resolve(true);
-        })
-        .on('error', (err) => {
-          reject(err);
-        });
-    });
+    await writeFile(outputFilePath, pdfDoc);
   } catch (error) {
+    // eslint-disable-next-line no-console
     console.error(error.message);
   }
 })();

packages/generate-pdf/package.json

@@ -28,6 +28,7 @@
   "dependencies": {
     "@s1seven/schema-tools-types": "0.5.6",
     "@s1seven/schema-tools-utils": "0.2.9",
+    "pdf-lib": "1.17.1",
     "lodash.clone": "^4.5.0",
     "lodash.get": "^4.4.2",
     "lodash.merge": "^4.6.2",

packages/generate-pdf/src/attach-file-to-pdf.ts

@@ -0,0 +1,22 @@
+import { AttachmentOptions, PDFDocument } from 'pdf-lib';
+
+/**
+ * Attaches a file to a PDF document. The file can be viewed and downloaded in advanced PDF viewers like Adobe Acrobat Reader.
+ * @param pdfBuffer - The buffer of the PDF to which the file will be attached.
+ * @param fileContent - The content of the file to attach.
+ * @param fileName - The name of the file to attach.
+ * @param options - The options for the attachment, including mimeType, description, creationDate, and modificationDate.
+ * @returns A Promise that resolves with a Buffer of the updated PDF document.
+ */
+export const attachFileToPdf = async (
+  pdfBuffer: Buffer,
+  fileContent: string,
+  fileName: string,
+  options: AttachmentOptions,
+): Promise<Buffer> => {
+  const pdfDoc = await PDFDocument.load(pdfBuffer);
+  const encodedFileContent = Buffer.from(fileContent).toString('base64');
+  await pdfDoc.attach(encodedFileContent, fileName, options);
+  const uint8Array = await pdfDoc.save();
+  return Buffer.from(uint8Array);
+};

packages/generate-pdf/src/index.ts

@@ -24,6 +24,8 @@ import {
   loadExternalFile,
 } from '@s1seven/schema-tools-utils';
 
+import { attachFileToPdf } from './attach-file-to-pdf';
+
 export { Content, StyleDictionary, TDocumentDefinitions, TFontDictionary } from 'pdfmake/interfaces';
 
 export interface GeneratePdfOptions {
@@ -35,6 +37,7 @@ export interface GeneratePdfOptions {
   translations?: Translations;
   extraTranslations?: ExtraTranslations;
   languageFontMap?: LanguageFontMap;
+  attachCertificate?: boolean;
 }
 
 export interface GeneratePdfOptionsExtended<T extends 'stream' | 'buffer'> extends GeneratePdfOptions {
@@ -146,13 +149,11 @@ async function getPdfMakeContentFromObject(
   const schemaConfig = getSchemaConfig(refSchemaUrl);
   const certificateLanguages = getCertificateLanguages(certificate);
   translations ||= certificateLanguages?.length ? await getTranslations(certificateLanguages, schemaConfig) : {};
-
   const type = getCertificateType(schemaConfig);
-  const externalStandards: ExternalStandards[] = schemaToExternalStandardsMap[type]
-    ? schemaToExternalStandardsMap[type]
-        .map((schemaType) => get(certificate, schemaType, undefined))
-        .filter((externalStandards) => externalStandards) || []
-    : [];
+  const externalStandards: ExternalStandards[] =
+    schemaToExternalStandardsMap[type]
+      ?.map((schemaType: keyof Schemas) => get(certificate, schemaType, undefined))
+      .filter(Boolean) ?? [];
 
   extraTranslations ||=
     certificateLanguages?.length && externalStandards?.length
@@ -203,6 +204,20 @@ async function buildPdfContent(
   return pdfMakeContent;
 }
 
+async function attachCertificateToPdf(
+  pdfBuffer: Buffer,
+  certificate: Record<string, unknown> | string,
+): Promise<Buffer> {
+  const today = new Date();
+  const fileContent = typeof certificate === 'string' ? certificate : JSON.stringify(certificate, null, 2);
+  return await attachFileToPdf(pdfBuffer, fileContent, 'certificate.json', {
+    mimeType: 'application/json',
+    description: 'The certificate in JSON format',
+    creationDate: today,
+    modificationDate: today,
+  });
+}
+
 export async function generatePdf(
   certificateInput: Record<string, unknown> | string,
   options: {
@@ -214,6 +229,7 @@ export async function generatePdf(
     translations?: Translations;
     extraTranslations?: ExtraTranslations;
     languageFontMap?: LanguageFontMap;
+    attachCertificate?: boolean;
   },
 ): Promise<Buffer>;
 
@@ -241,9 +257,15 @@ export async function generatePdf(
   options: GeneratePdfOptions = {},
 ): Promise<Buffer | PDFKit.PDFDocument> {
   const opts: GeneratePdfOptions = options ? { ...generatePdfOptions, ...options } : generatePdfOptions;
+
+  if (opts.attachCertificate && opts.outputType === 'stream') {
+    throw new Error('Cannot attach certificate to a stream output type. Please use buffer output type.');
+  }
+
   if (opts.outputType !== 'stream' && opts.outputType !== 'buffer') {
     throw new Error('Invalid outputType, should be one of buffer | stream');
   }
+
   const pdfMakeContent = await buildPdfContent(certificateInput, opts);
   const docDefinition: TDocumentDefinitions = opts.docDefinition
     ? merge(baseDocDefinition(pdfMakeContent), clone(opts.docDefinition))
@@ -254,7 +276,8 @@ export async function generatePdf(
   if (opts.outputType === 'stream') {
     return pdfDoc;
   }
-  return new Promise((resolve, reject) => {
+
+  const pdfBuffer = await new Promise<Buffer>((resolve, reject) => {
     let buffer: Buffer = Buffer.alloc(0);
     pdfDoc.on('data', (data) => {
       buffer = Buffer.concat([buffer, data], buffer.length + data.length);
@@ -263,4 +286,6 @@ export async function generatePdf(
     pdfDoc.on('error', reject);
     pdfDoc.end();
   });
+
+  return opts.attachCertificate ? await attachCertificateToPdf(pdfBuffer, certificateInput) : pdfBuffer;
 }

packages/generate-pdf/test/generate-pdf.spec.ts

@@ -10,6 +10,10 @@ import { SchemaDirUnion, SupportedSchemas, SupportedSchemasDirMap } from '@s1sev
 import { EN10168Schema, Schemas } from '@s1seven/schema-tools-types';
 
 import { type GeneratePdfOptionsExtended, buildModule, generateInSandbox, generatePdf } from '../src';
+import { attachFileToPdf } from '../src/attach-file-to-pdf';
+
+jest.mock('../src/attach-file-to-pdf');
+(attachFileToPdf as jest.Mock).mockImplementation((buf) => Promise.resolve(buf));
 
 type PDFGenerationTestProperties = {
   name: string;
@@ -133,11 +137,11 @@ const generatePaths = (
   const expectedPdfPath = `${dirPath}/${name}.pdf`;
   const translationsPath = `${dirPath}/translations.json`;
   const coaCertsWithoutExtraTranslations = ['v0.0.4', 'v0.1.0'];
-  let generatorPath: string;
+  let generatorPath: string | undefined;
   if (isLatestVersion) {
     generatorPath = resolve(`${__dirname}/../../generate-${type.toLowerCase()}-pdf-template/dist/generateContent.cjs`);
   }
-  let extraTranslationsPath: string;
+  let extraTranslationsPath: string | undefined;
 
   if (type.toLowerCase() === SupportedSchemas.COA && !coaCertsWithoutExtraTranslations.includes(version)) {
     extraTranslationsPath = `${dirPath}/extra_translations.json`;
@@ -205,7 +209,7 @@ const runPDFGenerationTests = (testSuite: PDFGenerationTestProperties) => {
             generatorPath,
             languageFontMap,
           };
-      //
+
       const pdfDoc = await generatePdf(validCertificate, generatePdfOptions);
       const writeStream = createWriteStream(outputFilePath);
       pdfDoc.pipe(writeStream);
@@ -248,6 +252,42 @@ const runPDFGenerationTests = (testSuite: PDFGenerationTestProperties) => {
       expect(resultHash).toEqual(expectedHash);
     }, 10000);
 
+    it('should attach the certificate as JSON document if `attachCertificate` is true', async () => {
+      const translations = JSON.parse(readFileSync(translationsPath, 'utf8'));
+      (attachFileToPdf as jest.Mock).mockClear();
+      await generatePdf(validCertificate, {
+        docDefinition: { ...docDefinition, styles },
+        outputType: 'buffer',
+        translations,
+        attachCertificate: true,
+      });
+      expect(attachFileToPdf).toHaveBeenCalled();
+    }, 10000);
+
+    it('should not attach the certificate as JSON document if `attachCertificate` is false', async () => {
+      const translations = JSON.parse(readFileSync(translationsPath, 'utf8'));
+      (attachFileToPdf as jest.Mock).mockClear();
+      await generatePdf(validCertificate, {
+        docDefinition: { ...docDefinition, styles },
+        outputType: 'buffer',
+        translations,
+        attachCertificate: false,
+      });
+      expect(attachFileToPdf).not.toHaveBeenCalled();
+    }, 10000);
+
+    it('should throw an error if `attachCertificate` is true and `outputType` is `stream`', async () => {
+      const translations = JSON.parse(readFileSync(translationsPath, 'utf8'));
+      await expect(
+        generatePdf(validCertificate, {
+          docDefinition: { ...docDefinition, styles },
+          outputType: 'stream',
+          translations,
+          attachCertificate: true,
+        } as any),
+      ).rejects.toThrow('Cannot attach certificate to a stream output type. Please use buffer output type.');
+    }, 10000);
+
     it('should render PDF certificate using certificate object and remote PDF generator script', async () => {
       const outputFilePath = `./${type}-${version}-test.pdf`;
       const translations = JSON.parse(readFileSync(translationsPath, 'utf8'));

packages/versioning/package.json

@@ -31,6 +31,7 @@
     "@s1seven/schema-tools-types": "0.5.6",
     "@s1seven/schema-tools-utils": "0.2.9",
     "@apidevtools/json-schema-ref-parser": "^11.1.0",
+    "pdf-lib": "1.17.1",
     "ajv": "8.12.0",
     "axios": "^1.2.1",
     "class-transformer": "^0.5.1",