@tmlmobilidade/backupd 20251229.1441.35

package/Dockerfile

@@ -0,0 +1,55 @@
+# # # # # # # # #
+
+FROM node:alpine AS base
+
+ENV APP=backupd
+
+RUN npm install -g turbo@^2
+
+# Install MongoDB
+RUN echo 'http://dl-cdn.alpinelinux.org/alpine/v3.6/main' >> /etc/apk/repositories
+RUN echo 'http://dl-cdn.alpinelinux.org/alpine/v3.6/community' >> /etc/apk/repositories
+RUN apk update
+RUN apk add mongodb-tools
+
+# # # # # # # # #
+
+
+# # #
+# BUILDER STAGE
+
+FROM base AS pruner
+
+WORKDIR /app
+
+COPY . .
+
+RUN turbo prune --scope=@tmlmobilidade/${APP} --docker
+
+
+# # #
+# INSTALLER STAGE
+
+FROM base AS builder
+
+WORKDIR /app
+
+# First install the dependencies (as they change less often)
+COPY --from=pruner /app/out/json/ .
+RUN npm install
+
+# Build the app
+COPY --from=pruner /app/out/full/ .
+RUN turbo run build --filter=@tmlmobilidade/${APP}
+
+
+# # #
+# RUNNER STAGE
+
+FROM base AS runner
+
+WORKDIR /app
+
+COPY --from=builder /app .
+
+CMD node configs/${APP}/dist/index.js

package/README.md

@@ -0,0 +1,125 @@
+## Overview
+
+The service will run continuously, performing backups at the interval specified in the configuration file.
+
+## Setup
+
+This service uses a configuration file in YAML format. There is an example file in the repository (`config.example.yaml`).
+
+In addition to the configuration file, this service uses the environment variable `BACKUPD_CONFIG_PATH` to locate the configuration file.
+
+## Configuration File Template
+
+The configuration file includes **storage**, **database**,**backup schedule**, and optional **email notification** settings. This file enables you to specify the exact setup for these operations.
+
+### Structure of `config.yaml`
+
+- **Storage Configuration**
+- **Database Configuration**
+- **Backup Configuration**
+- **Email Configuration**
+
+---
+
+### Configuration Parameters
+
+#### 1. Storage Configuration
+Defines the storage service for backups.
+
+```yaml
+storage:
+  type: STORAGE_TYPE
+  aws_config:
+    aws_access_key_id: YOUR_AWS_ACCESS_KEY_ID
+    aws_secret_access_key: YOUR_AWS_SECRET_ACCESS_KEY
+    bucket_name: YOUR_BUCKET_NAME
+    region: YOUR_REGION
+  oci_config:
+    tenancy: YOUR_TENANCY
+    user: YOUR_USER
+    fingerprint: YOUR_FINGERPRINT
+    private_key_path: YOUR_PRIVATE_KEY_PATH
+```
+
+- `type`: Set to `"aws"` for AWS S3 or `"oci"` for Oracle Cloud Storage.
+- **AWS Config**: (Required if `type` is `"aws"`)
+  - `aws_access_key_id`, `aws_secret_access_key`: AWS credentials.
+  - `bucket_name`, `region`: Define the S3 bucket and region.
+- **OCI Config**: (Required if `type` is `"oci"`)
+  - `tenancy`, `user`, `fingerprint`, `private_key_path`: Required fields for Oracle Cloud access.
+
+#### 2. Database Configuration
+Specifies the database type and connection parameters.
+
+```yaml
+database:
+  type: DATABASE_TYPE
+  mongodb_config:
+    uri: YOUR_MONGODB_URI
+    options:
+      connectTimeoutMS: 10000
+      ...
+  postgres_config:
+    uri: YOUR_POSTGRES_URI
+    options:
+      max: 10
+      min: 5
+      ...
+```
+
+- `type`: Database service to use (`mongodb` or `postgres`).
+- **MongoDB Config**: (Required if `type` is `"mongodb"`)
+  - `uri`: MongoDB connection URI.
+  - `options`: Optional connection parameters (timeout, pooling, and read preferences).
+- **PostgreSQL Config**: (Required if `type` is `"postgres"`)
+  - `uri`: PostgreSQL connection URI.
+  - `options`: Pooling options.
+
+#### 3. Backup Configuration
+Manages backup intervals, destinations, and retention.
+
+```yaml
+backup:
+  interval: 360
+  destination: backup/PROJECT_NAME/
+  max_remote_backups: 10
+  max_local_backups: 10
+```
+
+- `interval`: Frequency of backups in minutes (e.g., `360` for every 6 hours).
+- `destination`: Local directory path for storing backups.
+- `max_remote_backups`: Set retention limits for remote backups. (If set to 0, there will be no limit stored in the remote storage.)
+- `max_local_backups`: Set retention limits for local backups. (If set to 0, all local backups will be deleted.)
+
+#### 4. Email Configuration (Optional)
+Enables email notifications upon backup success or failure.
+
+```yaml
+email:
+  send_success: true
+  send_failure: true
+  mail_options:
+    from: FROM_EMAIL_ADDRESS
+    to: TO_EMAIL_ADDRESS
+    subject: BACKUP_REPORT_SUBJECT
+  smtp:
+    host: YOUR_SMTP_HOST
+    port: YOUR_SMTP_PORT
+    auth:
+      user: YOUR_SMTP_USER
+      pass: YOUR_SMTP_PASSWORD
+```
+
+- `send_success`, `send_failure`: Set to `true` to enable email notifications.
+- `mail_options`: Sender and recipient details.
+- `smtp`: SMTP server configuration for outgoing emails.
+
+---
+
+### Usage
+1. Copy this template file as `config.yaml`.
+2. Replace the placeholder values with your actual configurations.
+3. Save and start the `backupd` service.
+
+This file enables `backupd` to seamlessly back up and monitor your databases across different storage services.
+

package/config.example.yaml

@@ -0,0 +1,106 @@
+# This is an example configuration file for backupd.
+# It is not used by the application, but it is a template for the configuration file needed to run the backupd service
+
+# The configuration file is a YAML file, which is a human-readable data serialization format.
+# It is used to configure the backupd service.
+
+# The Storage Configuration
+storage:
+  # The type of storage service to use. Options: "aws" (AWS) | "oci" (Oracle Cloud Infrastructure Object Storage)
+  type: STORAGE_TYPE
+
+  # The AWS configuration
+  aws_config:
+    aws_access_key_id: YOUR_AWS_ACCESS_KEY_ID
+    aws_secret_access_key: YOUR_AWS_SECRET_ACCESS_KEY
+    bucket_name: YOUR_BUCKET_NAME
+    region: YOUR_REGION
+
+  # The Oracle Cloud Infrastructure Object Storage configuration
+  oci_config:
+    user: OCI_USER
+    fingerprint: OCI_FINGERPRINT
+    tenancy: OCI_TENANCY
+    region: OCI_REGION
+    private_key: OCI_PRIVATE_KEY # The private key of the user in PEM format
+    namespace: OCI_NAMESPACE
+    bucket_name: OCI_BUCKET_NAME
+
+  # The Cloudflare R2 configuration
+  r2_config:
+    account_id: YOUR_ACCOUNT_ID
+    access_key_id: YOUR_ACCESS_KEY_ID
+    secret_access_key: YOUR_SECRET_ACCESS_KEY
+    bucket_name: YOUR_BUCKET_NAME
+    endpoint: YOUR_ENDPOINT # https://<account_id>.r2.cloudflarestorage.com
+
+# The Database Configuration
+database:
+  # The type of database service to use. Options: "mongodb" (MongoDB) | "postgres" (PostgreSQL)
+  type: DATABASE_TYPE
+
+  # The MongoDB configuration (required if type is mongodb)
+  mongodb_config:
+    uri: YOUR_MONGODB_URI
+    options: # (Optional) The options to pass to the MongoDB client.
+      # The time in milliseconds to attempt a connection before timing out.
+      connectTimeoutMS: 10000
+      # Whether to use direct connection to the MongoDB server.
+      directConnection: true
+      # The maximum number of connections in the connection pool.
+      maxPoolSize: 10
+      # The minimum number of connections in the connection pool.
+      minPoolSize: 5
+      # The read preference to use. Options: "primary" | "primaryPreferred" | "secondary" | "secondaryPreferred" | "nearest"
+      readPreference: YOUR_READ_PREFERENCE
+      # The time in milliseconds to wait for a server to respond to a request before timing out.
+      serverSelectionTimeoutMS: 10000
+    # (Optional) The MongoDB dump options.
+    dump_options:
+      # (Optional) The database name to dump.
+      database: YOUR_DATABASE_NAME
+      # (Optional) The collections to exclude from the dump.
+      exclude_collections:
+        - YOUR_COLLECTION_NAME
+        - YOUR_COLLECTION_NAME
+
+  # The PostgreSQL configuration (required if type is postgres)
+  postgres_config:
+    uri: YOUR_POSTGRES_URI
+    options: # (Optional) The options to pass to the PostgreSQL client.
+      # The maximum number of connections in the connection pool.
+      max: 10
+      # The minimum number of connections in the connection pool.
+      min: 5
+
+# The Backup Configuration
+backup:
+  # The interval between backups in minutes.
+  interval: 360 # 6 hour
+  # Backup destination directory.
+  destination: PATH_TO_BACKUP_DESTINATION_DIRECTORY
+  # The remote destination directory.
+  remote_destination: PATH_TO_REMOTE_DESTINATION_DIRECTORY
+  # The maximum number of backups to keep. (If undefined or 0, no backups will be deleted.)
+  max_remote_backups: 10
+  # The maximum number of backup files to keep in the storage. (If set to 0, no backups will be stored in the device storage.)
+  max_local_backups: 10
+
+# The Email Configuration (if not set, no email will be sent)
+email:
+  # Whether to send the backup success report.
+  send_success: true
+  # Whether to send the backup failure report.
+  send_failure: true
+  # The mail options.
+  mail_options:
+    from: FROM_EMAIL_ADDRESS
+    to: TO_EMAIL_ADDRESS
+    subject: BACKUP_REPORT_SUBJECT
+  # The SMTP server configuration.
+  smtp:
+    host: YOUR_SMTP_HOST
+    port: YOUR_SMTP_PORT
+    auth:
+      user: YOUR_SMTP_USER
+      pass: YOUR_SMTP_PASSWORD

package/eslint.config.mjs

@@ -0,0 +1,14 @@
+/* * */
+
+import { node } from '@carrismetropolitana/eslint'
+
+/* * */
+
+export default [
+  {
+    rules: {
+      'no-extraneous-class': 'off',
+    },
+  },
+  ...node,
+]

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "@tmlmobilidade/backupd",
+	"description": "A backup service for databases.",
+	"version": "20251229.1441.35",
+	"author": {
+		"email": "iso@tmlmobilidade.pt",
+		"name": "TML-ISO"
+	},
+	"license": "AGPL-3.0-or-later",
+	"type": "module",
+	"main": "./dist/index.js",
+	"scripts": {
+		"build": "tsc && resolve-tspaths",
+		"lint": "eslint ./src && tsc --noEmit",
+		"start": "npm run build && node dist/index.js"
+	},
+	"dependencies": {
+		"@tmlmobilidade/consts": "*",
+		"@tmlmobilidade/dates": "*",
+		"@tmlmobilidade/emails": "*",
+		"@tmlmobilidade/interfaces": "*",
+		"@tmlmobilidade/logger": "*",
+		"@tmlmobilidade/types": "*",
+		"@tmlmobilidade/utils": "*",
+		"@types/archiver": "7.0.0",
+		"archiver": "7.0.1",
+		"mongodb": "7.0.0",
+		"nodemailer": "7.0.12",
+		"pg": "8.16.3",
+		"react": "19.2.3",
+		"resolve-tspaths": "0.8.23",
+		"yaml": "2.8.2"
+	},
+	"devDependencies": {
+		"@tmlmobilidade/tsconfig": "*",
+		"@types/node": "25.0.3",
+		"@types/nodemailer": "7.0.4",
+		"typescript": "5.9.3"
+	}
+}

package/src/backup/backup.service.ts

@@ -0,0 +1,84 @@
+import { IDatabaseService } from '@/database/database.interface.js';
+import { IStorageProvider } from '@tmlmobilidade/interfaces';
+import fs from 'fs';
+import path from 'path';
+
+export interface BackupConfig {
+	destination: string
+	interval: number
+	max_local_backups: number
+	max_remote_backups: number
+	remote_destination: string
+}
+
+export class BackupService {
+	private readonly config: BackupConfig;
+	private readonly databaseService: IDatabaseService;
+	private readonly storageService: IStorageProvider;
+
+	constructor(config: BackupConfig, databaseService: IDatabaseService, storageService: IStorageProvider) {
+		this.config = config;
+		this.databaseService = databaseService;
+		this.storageService = storageService;
+	}
+
+	/**
+	 * Perform a backup of the database and upload it to the storage.
+	 */
+	public async backup(): Promise<void> {
+		// Create a backup directory with the current timestamp
+		const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+		const backupDir = path.join(this.config.destination, timestamp);
+		fs.mkdirSync(backupDir, { recursive: true });
+
+		// Perform backup
+		await this.databaseService.backup(backupDir);
+
+		// Upload backup to storage
+		const backupFile = fs.readFileSync(backupDir + '.zip');
+		await this.storageService.uploadFile(path.join(this.config.remote_destination, timestamp + '.zip'), backupFile);
+
+		// Delete old backups
+		console.log('Deleting old backups...', {
+			max_local_backups: this.config.max_local_backups,
+			max_remote_backups: this.config.max_remote_backups,
+		});
+		if (this.config.max_local_backups > 0) {
+			await this.deleteLocalBackups();
+		}
+		else if (this.config.max_local_backups === 0) { // Delete all local backups
+			fs.rmSync(this.config.destination, { recursive: true });
+		}
+
+		if (this.config.max_remote_backups > 0) {
+			await this.deleteRemoteBackups();
+		}
+	}
+
+	/**
+	 * Delete old backups from the local storage.
+	 */
+	private async deleteLocalBackups(): Promise<void> {
+		// Delete old local backups
+		const localBackups = fs.readdirSync(this.config.destination).sort();
+		if (localBackups.length > this.config.max_local_backups) {
+			// Delete oldest local backups first
+			const localBackupsToDelete = localBackups.slice(0, localBackups.length - this.config.max_local_backups);
+			for (const backup of localBackupsToDelete) {
+				fs.rmSync(path.join(this.config.destination, backup), { recursive: true });
+			}
+		}
+	}
+
+	/**
+	 * Delete old backups from the local storage.
+	 */
+	private async deleteRemoteBackups(): Promise<void> {
+		const backups = await this.storageService.listFiles(this.config.remote_destination);
+		backups.sort(); // Sort by timestamp since they're ISO format strings
+		if (backups.length > this.config.max_remote_backups) {
+			const backupsToDelete = backups.slice(0, backups.length - this.config.max_remote_backups);
+			await Promise.all(backupsToDelete.map(backup => this.storageService.deleteFile(backup)));
+		}
+	}
+}

package/src/config/config-loader.ts

@@ -0,0 +1,168 @@
+// configLoader.ts
+import * as fs from 'fs';
+import * as yaml from 'yaml';
+
+import { AppConfig } from './config-types.js';
+
+function validateConfig(config: AppConfig) {
+	//
+
+	//
+	// Validate storage configuration
+	if (!config.storage) {
+		throw new Error('Missing required field \'storage\' configuration.');
+	}
+
+	if (config.storage.type !== 'oci') {
+		throw new Error('Invalid storage type. Supported types are \'oci\'.');
+	}
+
+	if (config.storage.type === 'oci') {
+		if (!config.storage.oci_config) {
+			throw new Error('Storage type is \'oci\' but \'oci_config\' is missing.');
+		}
+
+		const keys_missing: string[] = [];
+		for (const key of ['user', 'fingerprint', 'tenancy', 'region', 'private_key', 'namespace', 'bucket_name']) {
+			if (!config.storage.oci_config[key]) {
+				keys_missing.push(key);
+			}
+		}
+		if (keys_missing.length > 0) {
+			throw new Error(`Missing required fields in 'oci_config'. Ensure ${keys_missing.join(', ')} are set.`);
+		}
+	}
+
+	//
+	// Validate database configuration
+	if (!config.database) {
+		throw new Error('Missing required field \'database\' configuration.');
+	}
+
+	if (config.database.type !== 'mongodb' && config.database.type !== 'postgres') {
+		throw new Error('Invalid database type. Supported types are \'mongodb\' and \'postgres\'.');
+	}
+
+	if (config.database.type === 'mongodb') {
+		if (!config.database.mongodb_config) {
+			throw new Error('Database type is \'mongodb\' but \'mongodb_config\' is missing.');
+		}
+		if (!config.database.mongodb_config.uri) {
+			throw new Error('Missing required field \'uri\' in \'mongodb_config\'.');
+		}
+	}
+	else if (config.database.type === 'postgres') {
+		if (!config.database.postgres_config) {
+			throw new Error('Database type is \'postgres\' but \'postgres_config\' is missing.');
+		}
+		if (!config.database.postgres_config.uri) {
+			throw new Error('Missing required field \'uri\' in \'postgres_config\'.');
+		}
+	}
+
+	//
+	// Validate Backup configuration
+	if (!config.backup) {
+		throw new Error('Missing required field \'backup\' configuration.');
+	}
+
+	if (!config.backup.interval) {
+		throw new Error('Missing required field \'interval\' in \'backup\' configuration.');
+	}
+	else if (config.backup.interval <= 0 || typeof config.backup.interval !== 'number') {
+		throw new Error('\'interval\' must be a number greater than 0 in \'backup\' configuration.');
+	}
+
+	if (!config.backup.destination) {
+		throw new Error('Missing required field \'destination\' in \'backup\' configuration.');
+	}
+
+	if (!config.backup.max_local_backups) {
+		console.warn('\'max_local_backups\' is not set in \'backup\' configuration. No backups will be deleted.');
+	}
+	else if (config.backup.max_local_backups <= 0 || typeof config.backup.max_local_backups !== 'number') {
+		throw new Error('\'max_local_backups\' must be a number greater than 0 in \'backup\' configuration.');
+	}
+
+	if (!config.backup.max_remote_backups) {
+		console.warn('\'max_remote_backups\' is not set in \'backup\' configuration. No backups will be stored in the device storage.');
+	}
+	else if (config.backup.max_remote_backups <= 0 || typeof config.backup.max_remote_backups !== 'number') {
+		throw new Error('\'max_remote_backups\' must be a number greater than 0 in \'backup\' configuration.');
+	}
+	else if (!config.backup.remote_destination) {
+		throw new Error('\'remote_destination\' is not set in \'backup\' configuration.');
+	}
+
+	//
+	// Validate Email configuration
+	if (!config.email) {
+		console.warn('\'email\' configuration is not set. No email will be sent.');
+	}
+	else {
+		const { mail_options, send_failure, send_success, smtp } = config.email;
+		if (typeof send_success !== 'boolean') {
+			throw new Error('\'email.send_success\' should be a boolean.');
+		}
+		if (typeof send_failure !== 'boolean') {
+			throw new Error('\'email.send_failure\' should be a boolean.');
+		}
+
+		if (!mail_options) {
+			throw new Error('Missing \'mail_options\' in email configuration.');
+		}
+		else {
+			if (!mail_options.from || typeof mail_options.from !== 'string') {
+				throw new Error('\'from\' in \'mail_options\' configuration should be a string.');
+			}
+			if (!mail_options.subject || typeof mail_options.subject !== 'string') {
+				throw new Error('\'subject\' in \'mail_options\' configuration should be a string.');
+			}
+			if (!mail_options.to || (typeof mail_options.to !== 'string' && !Array.isArray(mail_options.to))) {
+				throw new Error('\'to\' in \'mail_options\' configuration should be a string or an array of strings.');
+			}
+		}
+
+		if (!smtp) {
+			throw new Error('Missing \'smtp\' configuration in email.');
+		}
+		else {
+			const { host, port } = smtp;
+			if (!host) {
+				throw new Error('Missing \'host\' in \'smtp\' configuration.');
+			}
+			if (typeof port !== 'number' || port <= 0) {
+				throw new Error('\'smtp.port\' should be a positive number.');
+			}
+			if (!smtp.auth.user) {
+				throw new Error('Missing \'user\' in \'smtp.auth\' configuration.');
+			}
+			if (!smtp.auth.pass) {
+				throw new Error('Missing \'password\' in \'smtp.auth\' configuration.');
+			}
+		}
+	}
+}
+
+export function loadConfig(path: string): AppConfig {
+	try {
+		const fileContents = fs.readFileSync(path, 'utf8');
+		const config = yaml.parse(fileContents) as AppConfig;
+
+		// Validate the parsed configuration
+		validateConfig(config);
+
+		return config;
+	}
+	catch (error) {
+		if (error instanceof SyntaxError) {
+			throw new Error(`YAML Syntax Error in config file: ${error.message}`);
+		}
+		else if (error.code === 'ENOENT') {
+			throw new Error(`Configuration file not found at path: ${path}`);
+		}
+		else {
+			throw new Error(`Failed to load configuration: ${error.message}`);
+		}
+	}
+}

package/src/config/config-types.ts

@@ -0,0 +1,35 @@
+import { BackupConfig } from '@/backup/backup.service.js';
+import { MongoDbConfig } from '@/database/mongo.service.js';
+import { PostgresConfig } from '@/database/postgres.service.js';
+import { EmailConfig } from '@/mailer/mailer.service.js';
+import { OCIStorageProviderConfiguration } from '@tmlmobilidade/interfaces';
+
+export interface StorageConfig {
+	oci_config?: OCIStorageProviderConfiguration
+	type: 'oci'
+}
+
+export interface MongoDBOptions {
+	connectTimeoutMS: number
+	directConnection: boolean
+	dump_options?: {
+		exclude_collections?: string[]
+	}
+	maxPoolSize: number
+	minPoolSize: number
+	readPreference: string
+	serverSelectionTimeoutMS: number
+}
+
+export interface DatabaseConfig {
+	mongodb_config?: MongoDbConfig
+	postgres_config?: PostgresConfig
+	type: 'mongodb' | 'postgres'
+}
+
+export interface AppConfig {
+	backup: BackupConfig
+	database: DatabaseConfig
+	email?: EmailConfig
+	storage: StorageConfig
+}

package/src/database/database.factory.ts

@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/no-extraneous-class */
+import { IDatabaseService } from './database.interface.js';
+import { MongoDbConfig, MongoDbService } from './mongo.service.js';
+import { PostgresConfig, PostgresService } from './postgres.service.js';
+
+export interface DatabaseConfiguration {
+	mongodb_config?: MongoDbConfig
+	postgres_config?: PostgresConfig
+	type: 'mongodb' | 'postgres'
+}
+
+export class DatabaseFactory {
+	/**
+     * Creates and returns an instance of a database service based on the provided configuration.
+     *
+     * @param config - The database configuration object.
+     * @returns An instance of a class that implements IDatabaseService.
+     */
+	public static create(config: DatabaseConfiguration): IDatabaseService {
+		switch (config.type) {
+			case 'mongodb':
+				if (!config.mongodb_config || !config.mongodb_config.uri) {
+					throw new Error('MongoDB configuration is missing or incomplete.');
+				}
+				return MongoDbService.getInstance(config.mongodb_config);
+			case 'postgres':
+				if (!config.postgres_config || !config.postgres_config.uri) {
+					throw new Error('PostgreSQL configuration is missing or incomplete.');
+				}
+				return new PostgresService(config.postgres_config);
+			default:
+				throw new Error(`Unsupported database type: ${config.type}`);
+		}
+	}
+}

package/src/database/database.interface.ts

@@ -0,0 +1,21 @@
+export interface IDatabaseService {
+	/**
+     * Backs up the database.
+     */
+	backup(outputPath: string): Promise<void>
+
+	/**
+     * Connects to the database.
+     */
+	connect(): Promise<unknown>
+
+	/**
+     * Disconnects from the database.
+     */
+	disconnect(): Promise<unknown>
+
+	/**
+     * Restores the database from the latest backup.
+     */
+	restore(backupPath: string): Promise<void>
+}

package/src/database/mongo.service.ts

@@ -0,0 +1,172 @@
+import archiver from 'archiver';
+import { exec } from 'child_process';
+import fs from 'fs';
+import { Collection, Db, DbOptions, MongoClient, MongoClientOptions } from 'mongodb';
+import path from 'path';
+
+import { IDatabaseService } from './database.interface.js';
+
+export interface MongoDbConfig {
+	/** Options to control dump behavior */
+	dump_options?: {
+		database?: string
+		exclude_collections?: string[]
+	}
+	options?: MongoClientOptions
+	uri: string
+}
+
+export class MongoDbService implements IDatabaseService {
+	private static _instance: MongoDbService;
+	get client(): MongoClient {
+		return this._client;
+	}
+
+	private _client: MongoClient;
+
+	private _dumpOptions?: MongoDbConfig['dump_options'];
+	private _uri: string;
+
+	constructor(config: MongoDbConfig) {
+		this._client = new MongoClient(config.uri, config.options);
+		this._uri = config.uri;
+		this._dumpOptions = config.dump_options;
+
+		this._client.on('close', () => {
+			console.warn('MongoDB connection closed unexpectedly.');
+		});
+		this._client.on('reconnect', () => {
+			console.log('MongoDB reconnected.');
+		});
+	}
+
+	/**
+   * Get the singleton instance of MongoDbService.
+   */
+	public static getInstance(config?: MongoDbConfig): MongoDbService {
+		if (!MongoDbService._instance) {
+			if (!config?.uri) {
+				throw new Error('MongoDB URI is required');
+			}
+
+			MongoDbService._instance = new MongoDbService(config);
+		}
+
+		return MongoDbService._instance;
+	}
+
+	/**
+	 * Perform a MongoDB dump using mongodump command.
+	 * @param outputPath - The directory path where the dump will be saved.
+	 * @returns A promise that resolves on successful dump or rejects on error.
+	 */
+	async backup(outputPath: string): Promise<void> {
+		const dumpDir = path.resolve(outputPath);
+
+		return new Promise((resolve, reject) => {
+			const excludeFlags = this._dumpOptions?.exclude_collections?.map(c => `--excludeCollection="${c}"`).join(' ') || '';
+			const databaseFlag = this._dumpOptions?.database ? `--db="${this._dumpOptions.database}"` : '';
+
+			const command = `mongodump --uri="${this._uri}" --out="${dumpDir}" ${excludeFlags} ${databaseFlag}`.trim();
+
+			exec(command, (error, stdout, stderr) => {
+				if (error) {
+					console.error(`⤷ Error running mongodump: ${stderr}`);
+					reject(new Error(`Mongodump failed: ${stderr}`));
+				}
+				else {
+					console.log(`⤷ Mongodump completed successfully`);
+
+					// Create a file to stream archive data to.
+					const output = fs.createWriteStream(`${dumpDir}.zip`);
+					const archive = archiver('zip', {
+						zlib: { level: 9 }, // Sets the compression level.
+					});
+
+					archive.on('error', (err) => {
+						console.error(`⤷ Error creating zip: ${err.message}`);
+						reject(err);
+					});
+
+					// Pipe archive data to the file.
+					archive.pipe(output);
+
+					// Append files from the dump directory.
+					archive.directory(dumpDir, false);
+
+					// Finalize the archive (i.e., finish the compression).
+					archive.finalize();
+
+					// Remove the dump directory after zipping.
+					output.on('close', () => {
+						fs.rmSync(dumpDir, { recursive: true });
+						console.log(`⤷ Backup has been zipped successfully. Total bytes: ${archive.pointer()}`);
+						resolve();
+					});
+				}
+			});
+		});
+	}
+
+	/**
+     * Connect to MongoDB and return the database instance.
+     */
+	async connect(): Promise<MongoClient> {
+		if (!this._client) {
+			try {
+				await this._client.connect();
+				console.log('⤷ Connected to MongoDB.');
+			}
+			catch (error) {
+				throw new Error('Error connecting to MongoDB', { cause: error });
+			}
+		}
+		return this._client;
+	}
+
+	/**
+     * Create a new Db instance sharing the current socket connections.
+     *
+     * @param dbName - The name of the database we want to use. If not provided, use database name from connection string.
+     * @param options - Optional settings for Db construction
+     */
+	db(dbName?: string, options?: DbOptions): Db {
+		return this._client.db(dbName, options);
+	}
+
+	/**
+   * Close the MongoDB connection.
+   */
+	async disconnect(): Promise<void> {
+		if (this._client) {
+			await this._client.close();
+			console.log('⤷ Disconnected from MongoDB.');
+		}
+	}
+
+	/**
+     * Get a specific collection by name.
+     * @param db - The database instance.
+     * @param collectionName - The name of the collection to retrieve.
+     * @returns The collection instance.
+     */
+	async getCollection<T>(db: Db, collectionName: string): Promise<Collection<T>> {
+		return db.collection<T>(collectionName);
+	}
+
+	/**
+     * Restores the database from the provided backup file.
+     */
+	async restore(backupPath: string): Promise<void> {
+		const command = `mongorestore --uri="${this._uri}" --drop "${backupPath}"`;
+
+		exec(command, (error, stdout, stderr) => {
+			if (error) {
+				console.error(`⤷ Error running mongorestore: ${stderr}`);
+			}
+			else {
+				console.log(`⤷ Mongorestore completed successfully:\n${stdout}`);
+			}
+		});
+	}
+}

package/src/database/postgres.service.ts

@@ -0,0 +1,95 @@
+/* * */
+
+import { IDatabaseService } from '@/database/database.interface.js';
+import { exec, spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Client, type ClientConfig } from 'pg';
+
+/* * */
+
+export interface PostgresConfig {
+	options?: ClientConfig
+	uri: string
+}
+
+export class PostgresService implements IDatabaseService {
+	private client: InstanceType<typeof Client>;
+
+	constructor(config: PostgresConfig) {
+		this.client = new Client({ connectionString: config.uri, ...config.options });
+	}
+
+	/**
+     * Backs up the database to the specified output path.
+     */
+	async backup(outputPath: string): Promise<void> {
+		return new Promise((resolve, reject) => {
+			// Ensure the output directory exists
+			const outputDir = path.dirname(outputPath);
+			if (!fs.existsSync(outputDir)) {
+				fs.mkdirSync(outputDir, { recursive: true });
+			}
+
+			// Prepare the pg_dump command arguments
+			const args = [
+				'--dbname', this.client.database,
+				'--format', 'custom',
+				'--file', outputPath,
+			];
+
+			// Spawn the pg_dump process
+			const dump = spawn('pg_dump', args);
+
+			dump.stdout.on('data', (data) => {
+				console.log(`pg_dump stdout: ${data}`);
+			});
+
+			dump.stderr.on('data', (data) => {
+				console.error(`pg_dump stderr: ${data}`);
+			});
+
+			dump.on('close', (code) => {
+				if (code === 0) {
+					console.log(`Backup completed successfully. File saved to ${outputPath}`);
+					resolve();
+				}
+				else {
+					reject(new Error(`pg_dump exited with code ${code}`));
+				}
+			});
+
+			dump.on('error', (err) => {
+				reject(err);
+			});
+		});
+	}
+
+	/**
+     * Connects to the PostgreSQL database.
+     */
+	async connect(): Promise<void> {
+		await this.client.connect();
+		console.log('Connected to PostgreSQL.');
+	}
+
+	/**
+     * Disconnects from the PostgreSQL database.
+     */
+	async disconnect(): Promise<void> {
+		await this.client.end();
+		console.log('Disconnected from PostgreSQL.');
+	}
+
+	/**
+     * Restores the database from the provided backup file.
+     */
+	async restore(backupPath: string): Promise<void> {
+		const command = `pg_restore --dbname="${this.client.database}" --file="${backupPath}"`;
+		exec(command, (error, stdout, stderr) => {
+			if (error) {
+				console.error(`⤷ Error running pg_restore: ${stderr}`);
+			}
+		});
+	}
+}

package/src/index.ts

@@ -0,0 +1,61 @@
+import { StorageConfiguration, StorageFactory } from '@tmlmobilidade/interfaces';
+
+import { BackupService } from './backup/backup.service.js';
+import { loadConfig } from './config/config-loader.js';
+import { DatabaseConfiguration, DatabaseFactory } from './database/database.factory.js';
+import { MailerService } from './mailer/mailer.service.js';
+
+async function main() {
+	const config = loadConfig(process.env.CONFIG_PATH || './config.yaml');
+
+	const databaseConfig: DatabaseConfiguration = {
+		mongodb_config: config.database.mongodb_config,
+		postgres_config: config.database.postgres_config,
+		type: config.database.type,
+	};
+
+	const storageConfig: StorageConfiguration = {
+		oci_config: config.storage.oci_config,
+		type: config.storage.type,
+	};
+
+	// Create database and storage services
+	const database = DatabaseFactory.create(databaseConfig);
+	const storage = StorageFactory.create(storageConfig);
+	const backup = new BackupService(config.backup, database, storage);
+	const mailer = new MailerService(config.email);
+
+	console.log('Running backup...');
+
+	try {
+		// Connect to the database
+		await database.connect();
+
+		// Perform backup
+		await backup.backup();
+
+		if (config.email?.send_success) {
+			await mailer.sendSuccessMail();
+		}
+	}
+	catch (error) {
+		console.error('Error during backup:', error);
+
+		if (config.email?.send_failure) {
+			await mailer.sendFailureMail(error.message);
+		}
+	}
+	finally {
+		// Disconnect from the database
+		await database.disconnect();
+	}
+
+	await new Promise(resolve => setTimeout(resolve, config.backup.interval * 1000 * 60));
+	main();
+}
+
+main().catch(async (err) => {
+	console.error(err);
+	await new Promise(resolve => setTimeout(resolve, 1000 * 60)); // Wait for 1 minute before running again
+	main();
+});

package/src/mailer/mailer.service.ts

@@ -0,0 +1,71 @@
+import { Dates } from '@tmlmobilidade/dates';
+import { RenderFailedBackupEmail } from '@tmlmobilidade/emails';
+import nodemailer, { Transporter } from 'nodemailer';
+
+export interface MailOptions {
+	from: string
+	html?: string
+	subject: string
+	text?: string
+	to: string | string[]
+}
+
+export interface SmtpConfig {
+	auth: {
+		pass: string
+		user: string
+	}
+	host: string
+	port: number
+}
+
+export interface EmailConfig {
+	mail_options: Omit<MailOptions, 'html' | 'text'>
+	send_failure: boolean
+	send_success: boolean
+	smtp: SmtpConfig
+}
+
+export class MailerService {
+	private transporter: Transporter;
+
+	constructor(private config: EmailConfig) {
+		this.transporter = nodemailer.createTransport(this.config.smtp);
+	}
+
+	public async sendFailureMail(error: string): Promise<void> {
+		const emailHtml = await RenderFailedBackupEmail({
+			backup_service: this.config.mail_options.subject,
+			error_message: error,
+			failure_time: Dates.now('Europe/Lisbon').toLocaleString(Dates.FORMATS.DATETIME_FULL_WITH_SECONDS),
+		});
+
+		const mail_options = {
+			...this.config.mail_options,
+			html: emailHtml,
+			subject: `${this.config.mail_options.subject}: Falha na execução do backup`,
+		};
+
+		await this.sendMail(mail_options);
+	}
+
+	public async sendSuccessMail(): Promise<void> {
+		const mail_options = {
+			...this.config.mail_options,
+			subject: `${this.config.mail_options.subject}: Backup successful`,
+			text: 'Backup was successful',
+		};
+
+		await this.sendMail(mail_options);
+	}
+
+	private async sendMail(mail_options: MailOptions): Promise<void> {
+		try {
+			const info = await this.transporter.sendMail(mail_options);
+			console.log(`Email sent: ${info.messageId}`);
+		}
+		catch (error) {
+			console.error('Error sending email:', error);
+		}
+	}
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+	"extends": "@tmlmobilidade/tsconfig/nodejs.json",
+	"compilerOptions": {
+		"baseUrl": ".",
+		"outDir": "dist",
+		"paths": {
+			"@/*": ["./src/*"]
+		}
+	},
+	"include": ["src"],
+	"exclude": ["node_modules", "dist"]
+}