opticedge-cloud-utils 1.0.3 → 1.0.5

package/.eslintrc.js

@@ -2,28 +2,29 @@ module.exports = {
   root: true,
   parser: '@typescript-eslint/parser',
   parserOptions: {
-    ecmaVersion: 2020,  // modern JS features
-    sourceType: 'module',
+    ecmaVersion: 2020, // modern JS features
+    sourceType: 'module'
   },
   env: {
     node: true,
     jest: true,
-    es2020: true,
+    es2020: true
   },
   plugins: ['@typescript-eslint', 'jest'],
   extends: [
     'eslint:recommended',
     'plugin:@typescript-eslint/recommended',
     'plugin:jest/recommended',
+    'plugin:prettier/recommended'
   ],
   rules: {
     // Your custom rules here, for example:
     'no-console': 'warn',
-    '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }],
+    '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_' }]
   },
   settings: {
     jest: {
-      version: 29,  // or your jest version
-    },
-  },
-};
+      version: 29 // or your jest version
+    }
+  }
+}

package/.prettierignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+build
+coverage

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "singleQuote": true,
+  "semi": false,
+  "trailingComma": "none",
+  "printWidth": 100,
+  "tabWidth": 2,
+  "arrowParens": "avoid"
+}

package/dist/auth/verify.js

@@ -12,7 +12,7 @@ async function verifyRequest(req, options) {
     try {
         const ticket = await client.verifyIdToken({
             idToken: token,
-            audience: options.allowedAudience,
+            audience: options.allowedAudience
         });
         const payload = ticket.getPayload();
         return payload?.email === options.allowedServiceAccount;

package/dist/auth/verify.test.js

@@ -9,70 +9,70 @@ jest.mock('google-auth-library', () => {
                 if (idToken === 'valid-token' && audience === 'audience') {
                     return {
                         getPayload: () => ({
-                            email: 'allowed@example.com',
-                        }),
+                            email: 'allowed@example.com'
+                        })
                     };
                 }
                 else if (idToken === 'wrong-email-token' && audience === 'audience') {
                     return {
                         getPayload: () => ({
-                            email: 'unauthorized@example.com',
-                        }),
+                            email: 'unauthorized@example.com'
+                        })
                     };
                 }
                 throw new Error('Invalid token');
-            }),
-        })),
+            })
+        }))
     };
 });
 describe('verifyRequest', () => {
     it('returns true for valid token and matching email', async () => {
         const mockReq = {
             headers: {
-                authorization: 'Bearer valid-token',
-            },
+                authorization: 'Bearer valid-token'
+            }
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const result = await (0, verify_1.verifyRequest)(mockReq, {
             allowedAudience: 'audience',
-            allowedServiceAccount: 'allowed@example.com',
+            allowedServiceAccount: 'allowed@example.com'
         });
         expect(result).toBe(true);
     });
     it('returns false for invalid token', async () => {
         const mockReq = {
             headers: {
-                authorization: 'Bearer invalid-token',
-            },
+                authorization: 'Bearer invalid-token'
+            }
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const result = await (0, verify_1.verifyRequest)(mockReq, {
             allowedAudience: 'audience',
-            allowedServiceAccount: 'allowed@example.com',
+            allowedServiceAccount: 'allowed@example.com'
         });
         expect(result).toBe(false);
     });
     it('returns false for missing authorization header', async () => {
         const mockReq = {
-            headers: {},
+            headers: {}
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const result = await (0, verify_1.verifyRequest)(mockReq, {
             allowedAudience: 'audience',
-            allowedServiceAccount: 'allowed@example.com',
+            allowedServiceAccount: 'allowed@example.com'
         });
         expect(result).toBe(false);
     });
     it('returns false for incorrect email', async () => {
         const mockReq = {
             headers: {
-                authorization: 'Bearer wrong-email-token',
-            },
+                authorization: 'Bearer wrong-email-token'
+            }
         };
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const result = await (0, verify_1.verifyRequest)(mockReq, {
             allowedAudience: 'audience',
-            allowedServiceAccount: 'allowed@example.com',
+            allowedServiceAccount: 'allowed@example.com'
         });
         expect(result).toBe(false);
     });

package/dist/db/mongo.d.ts

@@ -0,0 +1,3 @@
+import { Collection, Document } from 'mongodb';
+export declare function connectToMongo(projectId: string, uriSecret: string, dbName: string): Promise<void>;
+export declare function getCollection<T extends Document = Document>(name: string): Collection<T>;

package/dist/db/mongo.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectToMongo = connectToMongo;
+exports.getCollection = getCollection;
+const mongodb_1 = require("mongodb");
+const secrets_1 = require("../utils/secrets"); // reuse your secret manager util
+let client;
+let db;
+async function connectToMongo(projectId, uriSecret, dbName) {
+    if (client)
+        return;
+    const uri = await (0, secrets_1.getSecret)(projectId, uriSecret);
+    client = new mongodb_1.MongoClient(uri);
+    await client.connect();
+    db = client.db(dbName); // or pass DB name if needed
+}
+function getCollection(name) {
+    if (!db)
+        throw new Error('Mongo not initialized');
+    return db.collection(name);
+}

package/dist/db/mongo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/db/mongo.test.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongo_1 = require("./mongo");
+const mongodb_1 = require("mongodb");
+const secretsModule = __importStar(require("../utils/secrets"));
+jest.mock('mongodb');
+jest.mock('../utils/secrets');
+const mockDb = {
+    collection: jest.fn()
+};
+const mockConnect = jest.fn();
+const mockClient = {
+    connect: mockConnect,
+    db: jest.fn().mockReturnValue(mockDb)
+};
+beforeEach(() => {
+    jest.clearAllMocks();
+    secretsModule.getSecret.mockResolvedValue('mongodb://mock-uri');
+    mongodb_1.MongoClient.mockImplementation(() => mockClient);
+});
+describe('Mongo Utils', () => {
+    it('should connect to MongoDB and store client/db', async () => {
+        await (0, mongo_1.connectToMongo)('test-project', 'mongo-uri-secret', 'test-db');
+        expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', 'mongo-uri-secret');
+        expect(mockConnect).toHaveBeenCalled();
+        expect(mockClient.db).toHaveBeenCalledWith('test-db');
+    });
+    it('should return a collection when db is initialized', async () => {
+        await (0, mongo_1.connectToMongo)('test-project', 'mongo-uri-secret', 'test-db');
+        (0, mongo_1.getCollection)('users');
+        expect(mockDb.collection).toHaveBeenCalledWith('users');
+    });
+    it('should throw error if db is not initialized', () => {
+        jest.isolateModules(() => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const { getCollection } = require('./mongo');
+            expect(() => getCollection('users')).toThrow('Mongo not initialized');
+        });
+    });
+});

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './auth/verify';
 export * from './utils/secrets';
+export * from './db/mongo';

package/dist/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./auth/verify"), exports);
 __exportStar(require("./utils/secrets"), exports);
+__exportStar(require("./db/mongo"), exports);

package/dist/utils/secrets.js

@@ -16,7 +16,7 @@ async function getSecret(projectId, secretName) {
         throw new Error('secretName is required');
     const secretClient = new secret_manager_1.SecretManagerServiceClient();
     const [version] = await secretClient.accessSecretVersion({
-        name: `projects/${projectId}/secrets/${secretName}/versions/latest`,
+        name: `projects/${projectId}/secrets/${secretName}/versions/latest`
     });
     return version.payload?.data?.toString('utf-8') ?? '';
 }

package/dist/utils/secrets.test.js

@@ -6,7 +6,7 @@ jest.mock('@google-cloud/secret-manager');
 // Mock implementation
 const mockAccessSecretVersion = jest.fn();
 secret_manager_1.SecretManagerServiceClient.mockImplementation(() => ({
-    accessSecretVersion: mockAccessSecretVersion,
+    accessSecretVersion: mockAccessSecretVersion
 }));
 describe('getSecret', () => {
     beforeEach(() => {
@@ -15,13 +15,13 @@ describe('getSecret', () => {
     it('returns secret value as string', async () => {
         mockAccessSecretVersion.mockResolvedValue([
             {
-                payload: { data: Buffer.from('super-secret-value') },
-            },
+                payload: { data: Buffer.from('super-secret-value') }
+            }
         ]);
         const result = await (0, secrets_1.getSecret)('test-project', 'test-secret');
         expect(result).toBe('super-secret-value');
         expect(mockAccessSecretVersion).toHaveBeenCalledWith({
-            name: 'projects/test-project/secrets/test-secret/versions/latest',
+            name: 'projects/test-project/secrets/test-secret/versions/latest'
         });
     });
     it('throws if projectId is missing', async () => {

package/jest.config.js

@@ -1,12 +1,12 @@
-const { createDefaultPreset } = require("ts-jest");
+const { createDefaultPreset } = require('ts-jest')
 
-const tsJestTransformCfg = createDefaultPreset().transform;
+const tsJestTransformCfg = createDefaultPreset().transform
 
 /** @type {import("jest").Config} **/
 module.exports = {
-  testEnvironment: "node",
+  testEnvironment: 'node',
   transform: {
-    ...tsJestTransformCfg,
+    ...tsJestTransformCfg
   },
-  testPathIgnorePatterns: ['/node_modules/', '/dist/'],
-};
+  testPathIgnorePatterns: ['/node_modules/', '/dist/']
+}

package/package.json

@@ -1,20 +1,23 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "test": "jest --coverage",
-    "lint": "eslint . --ext .ts",
+    "lint": "eslint . --ext .ts --fix",
+    "format": "prettier --write .",
+    "fix": "npm run lint && npm run format",
     "prepare": "npm run build"
   },
   "author": "Evans Musonda",
   "license": "MIT",
   "dependencies": {
     "@google-cloud/secret-manager": "^6.0.1",
-    "google-auth-library": "^9.15.1"
+    "google-auth-library": "^9.15.1",
+    "mongodb": "^6.16.0"
   },
   "devDependencies": {
     "@google-cloud/functions-framework": "^4.0.0",
@@ -23,8 +26,11 @@
     "@typescript-eslint/eslint-plugin": "^8.33.0",
     "@typescript-eslint/parser": "^8.33.0",
     "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-jest": "^28.11.1",
+    "eslint-plugin-prettier": "^5.4.0",
     "jest": "^29.7.0",
+    "prettier": "^3.5.3",
     "ts-jest": "^29.3.4",
     "typescript": "^5.8.3"
   }

package/src/auth/verify.test.ts

@@ -1,4 +1,4 @@
-import { verifyRequest } from './verify';
+import { verifyRequest } from './verify'
 
 // Mock the google-auth-library
 jest.mock('google-auth-library', () => {
@@ -8,82 +8,82 @@ jest.mock('google-auth-library', () => {
         if (idToken === 'valid-token' && audience === 'audience') {
           return {
             getPayload: () => ({
-              email: 'allowed@example.com',
-            }),
-          };
+              email: 'allowed@example.com'
+            })
+          }
         } else if (idToken === 'wrong-email-token' && audience === 'audience') {
           return {
             getPayload: () => ({
-              email: 'unauthorized@example.com',
-            }),
-          };
+              email: 'unauthorized@example.com'
+            })
+          }
         }
-        throw new Error('Invalid token');
-      }),
-    })),
-  };
-});
+        throw new Error('Invalid token')
+      })
+    }))
+  }
+})
 
 describe('verifyRequest', () => {
   it('returns true for valid token and matching email', async () => {
     const mockReq = {
       headers: {
-        authorization: 'Bearer valid-token',
-      },
-    };
+        authorization: 'Bearer valid-token'
+      }
+    }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result = await verifyRequest(mockReq as any, {
       allowedAudience: 'audience',
-      allowedServiceAccount: 'allowed@example.com',
-    });
+      allowedServiceAccount: 'allowed@example.com'
+    })
 
-    expect(result).toBe(true);
-  });
+    expect(result).toBe(true)
+  })
 
   it('returns false for invalid token', async () => {
     const mockReq = {
       headers: {
-        authorization: 'Bearer invalid-token',
-      },
-    };
+        authorization: 'Bearer invalid-token'
+      }
+    }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result = await verifyRequest(mockReq as any, {
       allowedAudience: 'audience',
-      allowedServiceAccount: 'allowed@example.com',
-    });
+      allowedServiceAccount: 'allowed@example.com'
+    })
 
-    expect(result).toBe(false);
-  });
+    expect(result).toBe(false)
+  })
 
   it('returns false for missing authorization header', async () => {
     const mockReq = {
-      headers: {},
-    };
+      headers: {}
+    }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result = await verifyRequest(mockReq as any, {
       allowedAudience: 'audience',
-      allowedServiceAccount: 'allowed@example.com',
-    });
+      allowedServiceAccount: 'allowed@example.com'
+    })
 
-    expect(result).toBe(false);
-  });
+    expect(result).toBe(false)
+  })
 
   it('returns false for incorrect email', async () => {
     const mockReq = {
       headers: {
-        authorization: 'Bearer wrong-email-token',
-      },
-    };
+        authorization: 'Bearer wrong-email-token'
+      }
+    }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const result = await verifyRequest(mockReq as any, {
       allowedAudience: 'audience',
-      allowedServiceAccount: 'allowed@example.com',
-    });
+      allowedServiceAccount: 'allowed@example.com'
+    })
 
-    expect(result).toBe(false);
-  });
-});
+    expect(result).toBe(false)
+  })
+})

package/src/auth/verify.ts

@@ -1,32 +1,29 @@
-import { OAuth2Client } from 'google-auth-library';
-import { Request } from '@google-cloud/functions-framework';
+import { OAuth2Client } from 'google-auth-library'
+import { Request } from '@google-cloud/functions-framework'
 
 interface VerifyOptions {
-  allowedAudience: string;
-  allowedServiceAccount: string;
+  allowedAudience: string
+  allowedServiceAccount: string
 }
 
-export async function verifyRequest(
-  req: Request,
-  options: VerifyOptions
-): Promise<boolean> {
-  const authHeader = req.headers['authorization'];
+export async function verifyRequest(req: Request, options: VerifyOptions): Promise<boolean> {
+  const authHeader = req.headers['authorization']
   if (!authHeader || !authHeader.startsWith('Bearer ')) {
-    return false;
+    return false
   }
 
-  const token = authHeader.split(' ')[1];
-  const client = new OAuth2Client();
+  const token = authHeader.split(' ')[1]
+  const client = new OAuth2Client()
 
   try {
     const ticket = await client.verifyIdToken({
       idToken: token,
-      audience: options.allowedAudience,
-    });
+      audience: options.allowedAudience
+    })
 
-    const payload = ticket.getPayload();
-    return payload?.email === options.allowedServiceAccount;
+    const payload = ticket.getPayload()
+    return payload?.email === options.allowedServiceAccount
   } catch {
-    return false;
+    return false
   }
 }

package/src/db/mongo.test.ts

@@ -0,0 +1,47 @@
+import { connectToMongo, getCollection } from './mongo'
+import { MongoClient, Db } from 'mongodb'
+import * as secretsModule from '../utils/secrets'
+
+jest.mock('mongodb')
+jest.mock('../utils/secrets')
+
+const mockDb = {
+  collection: jest.fn()
+} as unknown as Db
+
+const mockConnect = jest.fn()
+const mockClient = {
+  connect: mockConnect,
+  db: jest.fn().mockReturnValue(mockDb)
+} as unknown as MongoClient
+
+beforeEach(() => {
+  jest.clearAllMocks()
+  ;(secretsModule.getSecret as jest.Mock).mockResolvedValue('mongodb://mock-uri')
+  ;(MongoClient as unknown as jest.Mock).mockImplementation(() => mockClient)
+})
+
+describe('Mongo Utils', () => {
+  it('should connect to MongoDB and store client/db', async () => {
+    await connectToMongo('test-project', 'mongo-uri-secret', 'test-db')
+
+    expect(secretsModule.getSecret).toHaveBeenCalledWith('test-project', 'mongo-uri-secret')
+    expect(mockConnect).toHaveBeenCalled()
+    expect(mockClient.db).toHaveBeenCalledWith('test-db')
+  })
+
+  it('should return a collection when db is initialized', async () => {
+    await connectToMongo('test-project', 'mongo-uri-secret', 'test-db')
+    getCollection('users')
+
+    expect(mockDb.collection).toHaveBeenCalledWith('users')
+  })
+
+  it('should throw error if db is not initialized', () => {
+    jest.isolateModules(() => {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { getCollection } = require('./mongo')
+      expect(() => getCollection('users')).toThrow('Mongo not initialized')
+    })
+  })
+})

package/src/db/mongo.ts

@@ -0,0 +1,19 @@
+import { MongoClient, Db, Collection, Document } from 'mongodb'
+import { getSecret } from '../utils/secrets' // reuse your secret manager util
+
+let client: MongoClient
+let db: Db
+
+export async function connectToMongo(projectId: string, uriSecret: string, dbName: string) {
+  if (client) return
+
+  const uri = await getSecret(projectId, uriSecret)
+  client = new MongoClient(uri)
+  await client.connect()
+  db = client.db(dbName) // or pass DB name if needed
+}
+
+export function getCollection<T extends Document = Document>(name: string): Collection<T> {
+  if (!db) throw new Error('Mongo not initialized')
+  return db.collection<T>(name)
+}

package/src/index.ts

@@ -1,2 +1,3 @@
-export * from './auth/verify';
-export * from './utils/secrets';
+export * from './auth/verify'
+export * from './utils/secrets'
+export * from './db/mongo'

package/src/utils/secrets.test.ts

@@ -1,44 +1,44 @@
-import { getSecret } from './secrets';
-import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
+import { getSecret } from './secrets'
+import { SecretManagerServiceClient } from '@google-cloud/secret-manager'
 
-jest.mock('@google-cloud/secret-manager');
+jest.mock('@google-cloud/secret-manager')
 
 // Mock implementation
-const mockAccessSecretVersion = jest.fn();
-(SecretManagerServiceClient as unknown as jest.Mock).mockImplementation(() => ({
-  accessSecretVersion: mockAccessSecretVersion,
-}));
+const mockAccessSecretVersion = jest.fn()
+;(SecretManagerServiceClient as unknown as jest.Mock).mockImplementation(() => ({
+  accessSecretVersion: mockAccessSecretVersion
+}))
 
 describe('getSecret', () => {
   beforeEach(() => {
-    jest.clearAllMocks();
-  });
+    jest.clearAllMocks()
+  })
 
   it('returns secret value as string', async () => {
     mockAccessSecretVersion.mockResolvedValue([
       {
-        payload: { data: Buffer.from('super-secret-value') },
-      },
-    ]);
+        payload: { data: Buffer.from('super-secret-value') }
+      }
+    ])
 
-    const result = await getSecret('test-project', 'test-secret');
-    expect(result).toBe('super-secret-value');
+    const result = await getSecret('test-project', 'test-secret')
+    expect(result).toBe('super-secret-value')
     expect(mockAccessSecretVersion).toHaveBeenCalledWith({
-      name: 'projects/test-project/secrets/test-secret/versions/latest',
-    });
-  });
+      name: 'projects/test-project/secrets/test-secret/versions/latest'
+    })
+  })
 
   it('throws if projectId is missing', async () => {
-    await expect(getSecret('', 'secret')).rejects.toThrow('projectId is required');
-  });
+    await expect(getSecret('', 'secret')).rejects.toThrow('projectId is required')
+  })
 
   it('throws if secretName is missing', async () => {
-    await expect(getSecret('project', '')).rejects.toThrow('secretName is required');
-  });
+    await expect(getSecret('project', '')).rejects.toThrow('secretName is required')
+  })
 
   it('returns empty string if payload or data is missing', async () => {
-    mockAccessSecretVersion.mockResolvedValue([{}]); // no payload
-    const result = await getSecret('project', 'secret');
-    expect(result).toBe('');
-  });
-});
+    mockAccessSecretVersion.mockResolvedValue([{}]) // no payload
+    const result = await getSecret('project', 'secret')
+    expect(result).toBe('')
+  })
+})

package/src/utils/secrets.ts

@@ -1,4 +1,4 @@
-import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
+import { SecretManagerServiceClient } from '@google-cloud/secret-manager'
 
 /**
  * Returns the latest value of a Secret Manager secret.
@@ -7,18 +7,15 @@ import { SecretManagerServiceClient } from '@google-cloud/secret-manager';
  * @param secretName  – Secret name (without version).
  * @returns           – UTF-8 string value.
  */
-export async function getSecret(
-  projectId: string,
-  secretName: string
-): Promise<string> {
-  if (!projectId) throw new Error('projectId is required');
-  if (!secretName) throw new Error('secretName is required');
+export async function getSecret(projectId: string, secretName: string): Promise<string> {
+  if (!projectId) throw new Error('projectId is required')
+  if (!secretName) throw new Error('secretName is required')
 
-  const secretClient = new SecretManagerServiceClient();
+  const secretClient = new SecretManagerServiceClient()
 
   const [version] = await secretClient.accessSecretVersion({
-    name: `projects/${projectId}/secrets/${secretName}/versions/latest`,
-  });
+    name: `projects/${projectId}/secrets/${secretName}/versions/latest`
+  })
 
-  return (version.payload?.data as Buffer)?.toString('utf-8') ?? '';
+  return (version.payload?.data as Buffer)?.toString('utf-8') ?? ''
 }