@gov-cy/govcy-express-services 0.1.1

package/src/utils/govcyDataLayer.mjs

@@ -0,0 +1,311 @@
+/**
+ * @module govcyDataLayer
+ * @fileoverview This utility provides functions for storing and retrieving data from the session store.
+ * It includes functions to initialize the data layer, store page validation errors, store form data,
+ * retrieve validation errors, and clear site data.
+ * 
+ */
+
+/**
+ * Initialize the data layer
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId The site id 
+ * @param {string} pageUrl The page url
+ */
+export function initializeSiteData(store, siteId, pageUrl = null) {
+    if (!store.siteData) store.siteData = {};
+    if (!store.siteData[siteId]) store.siteData[siteId] = {};
+    if (!store.siteData[siteId].inputData) store.siteData[siteId].inputData = {};
+    if (!store.siteData[siteId].submissionData) store.siteData[siteId].submissionData = {};
+
+    if (pageUrl && !store.siteData[siteId].inputData[pageUrl]) {
+        store.siteData[siteId].inputData[pageUrl] = { formData: {} };
+    }
+}
+
+// export function getSubmissionData(store, siteId, pageUrl) {
+//     return store.siteData?.[siteId]?.inputData?.[pageUrl]?.formData || {};
+// }
+
+/**
+ * Store the page errors in the data layer
+ * 
+ * The following is an example of the data that will be stored:
+```json
+{
+"errors": {
+    "Iban": {
+        "id": "Iban",
+        "message": {
+            "en": "Enter your IBAN",
+            "el": "Εισαγάγετε το IBAN σας"
+        },
+        "pageUrl": ""
+    },
+    "Swift": {
+        "id": "Swift",
+        "message": {
+            "en": "Enter your SWIFT",
+            "el": "Εισαγάγετε το SWIFT σας"
+        },
+        "pageUrl": ""
+    }
+}
+```
+ * @param {object} store The session store 
+ * @param {string} siteId The site id 
+ * @param {string} pageUrl The page url 
+ * @param {object} validationErrors The validation errors 
+ * @param {object} formData The form data that produced the errors 
+ */
+export function storePageValidationErrors(store, siteId, pageUrl, validationErrors, formData) {
+    // Ensure session structure is initialized
+    initializeSiteData(store, siteId, pageUrl);
+
+    // Store the validation errors
+    store.siteData[siteId].inputData[pageUrl]["validationErrors"] = {
+        errors: validationErrors,
+        formData: formData,
+        errorSummary: []
+    };
+}
+
+/**
+ * Stores the page's form data in the data layer
+ * 
+ * The following is an example of the data that will be stored:
+ ```json
+{
+    field1: [
+        "value1",
+        "value2"
+    ],
+    field2: "value2",
+    _csrf: "1234567890"
+}
+ ```
+ * 
+ * @param {object} store The session store 
+ * @param {string} siteId The site id
+ * @param {string} pageUrl The page url 
+ * @param {object} formData The form data to be stored 
+ */
+export function storePageData(store, siteId, pageUrl, formData) {
+    // Ensure session structure is initialized
+    initializeSiteData(store, siteId, pageUrl);
+
+    store.siteData[siteId].inputData[pageUrl]["formData"] = formData;
+}
+
+/**
+ * Stores the site validation errors in the data layer 
+ * 
+ * The following is an example of the data that will be stored:
+ * 
+```json 
+{
+  "errors": {
+    "bank-detailsIban": {
+      "id": "Iban",
+      "message": {
+        "en": "Enter your IBAN",
+        "el": "Εισαγάγετε το IBAN σας"
+      },
+      "pageUrl": "bank-details"
+    },
+    "bank-detailsSwift": {
+      "id": "Swift",
+      "message": {
+        "en": "Enter your SWIFT",
+        "el": "Εισαγάγετε το SWIFT σας"
+      },
+      "pageUrl": "bank-details"
+    }
+  },
+  "errorSummary": []
+}
+```
+ * @param {object} store The session store
+ * @param {string} siteId The site id
+ * @param {object} validationErrors The validation errors to be stored
+ */
+export function storeSiteValidationErrors(store, siteId, validationErrors) {
+    initializeSiteData(store, siteId); // Ensure the structure exists
+
+    store.siteData[siteId]["submissionErrors"] = {
+        errors: validationErrors,
+        errorSummary: []
+    };
+}
+
+
+/**
+ * Stores the submitted site's input data in the data layer and clears the input data 
+ * 
+ * Check NOTES.md for sample of the data
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId The site id
+ * @param {object} submissionData The submission data to be stored
+ */
+export function storeSiteSubmissionData(store, siteId, submissionData) {
+    initializeSiteData(store, siteId); // Ensure the structure exists
+
+    // let rawData = getSiteInputData(store, siteId);
+    // Store the submission data
+    store.siteData[siteId].submissionData = submissionData;
+      
+      // Clear validation errors from the session
+    store.siteData[siteId].inputData = {};
+}
+
+
+/**
+ * Store eligibility result for a site and endpoint
+ * @param {object} store - session store
+ * @param {string} siteId
+ * @param {string} endpointKey - unique key for the eligibility endpoint (e.g. resolved URL)
+ * @param {object} result - API response
+ */
+export function storeSiteEligibilityResult(store, siteId, endpointKey, result) {
+    
+    initializeSiteData(store, siteId); // Ensure the structure exists
+
+    if (!store.siteData[siteId].eligibility) store.siteData[siteId].eligibility = {};
+    store.siteData[siteId].eligibility[endpointKey] = {
+        result,
+        timestamp: Date.now()
+    };
+}
+
+/**
+ * Get eligibility result for a site and endpoint
+ * @param {object} store - session store
+ * @param {string} siteId
+ * @param {string} endpointKey
+ * @param {number} maxAgeMs - max age in ms (optional)
+ * @returns {object|null}
+ */
+export function getSiteEligibilityResult(store, siteId, endpointKey, maxAgeMs = null) {
+    const entry = store?.siteData?.[siteId]?.eligibility?.[endpointKey];
+    if (!entry) return null;
+    if (maxAgeMs === 0) return null; // 0 Never caches
+    if (maxAgeMs && Date.now() - entry.timestamp > maxAgeMs) return null; // Expired
+    return entry.result;
+}
+
+/**
+ * Get the page validation errors from the store and clear them
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId The site id
+ * @param {string} pageUrl The page url
+ * @returns The validation errors for the page or null if none exist. Also clears the errors from the store.
+ */
+export function getPageValidationErrors(store, siteId, pageUrl) {
+    const validationErrors = store?.siteData?.[siteId]?.inputData?.[pageUrl]?.validationErrors || null;
+    
+    if (validationErrors) {
+        // Clear validation errors from the session
+        delete store.siteData[siteId].inputData[pageUrl].validationErrors;
+        return validationErrors;
+    }
+
+    return null;
+}
+
+/**
+ * Get the posted page data from the store
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId The site id
+ * @param {string} pageUrl The page url
+ * @returns The form data for the page or an empty object if none exist.
+ */
+export function getPageData(store, siteId, pageUrl) {
+    return store?.siteData?.[siteId]?.inputData?.[pageUrl]?.formData || {};
+}
+
+/**
+ * Get the site validation errors from the store and clear them
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId |The site id
+ * @returns The validation errors for the site or null if none exist. Also clears the errors from the store.
+ */
+export function getSiteSubmissionErrors(store, siteId) {
+    const validationErrors = store?.siteData?.[siteId]?.submissionErrors || null;
+    
+    if (validationErrors) {
+        // Clear validation errors from the session
+        delete store.siteData[siteId].submissionErrors;
+        return validationErrors;
+    }
+
+    return null;
+}
+
+/**
+ * Get the site's input data from the store 
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId |The site id
+ * @returns The site input data or null if none exist.
+ */
+export function getSiteInputData(store, siteId) {
+    const inputData = store?.siteData?.[siteId]?.inputData || {};
+    
+    if (inputData) {
+        return inputData;
+    }
+
+    return null;
+}
+
+/**
+ * Get the site's input data from the store 
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId |The site id
+ * @returns The site input data or null if none exist.
+ */
+export function getSiteSubmissionData(store, siteId) {
+    initializeSiteData(store, siteId); // Ensure the structure exists
+    
+    const submission = store?.siteData?.[siteId]?.submissionData || {};
+    
+    if (submission) {
+        return submission;
+    }
+
+    return null;
+}
+
+/**
+ * Get the value of a specific form data element from the store
+ * 
+ * @param {object} store The session store
+ * @param {string} siteId The site id
+ * @param {string} pageUrl The page url
+ * @param {string} elementName The element name
+ * @returns The value of the form data for the element or an empty string if none exist.
+ */
+export function getFormDataValue(store, siteId, pageUrl, elementName) {
+    return store?.siteData?.[siteId]?.inputData?.[pageUrl]?.formData?.[elementName] || "";
+}
+
+/**
+ * Get the user object from the session store
+ * 
+ * @param {object} store The session store 
+ * @returns The user object from the store or null if it doesn't exist.
+ */
+export function getUser(store){
+    return store.user || null;
+}
+
+export function clearSiteData(store, siteId) {
+    delete store?.siteData[siteId];
+}
+

package/src/utils/govcyEnvVariables.mjs

@@ -0,0 +1,45 @@
+/**
+ * @module govcyEnvVariables
+ * @fileoverview This module manages environment variables and settings for the application.
+ * It loads environment variables from a .env file in non-production environments,
+ * and provides functions to check the current environment and retrieve environment variables.
+ */
+
+import * as dotenv from 'dotenv';
+
+// Load environment variables from .env file only in non-production environments
+if (process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'staging') {
+    dotenv.config();
+}
+
+/**
+ * Check if the current environment is production or staging
+ * 
+ * @returns {boolean} true if the environment is production or staging, false otherwise
+ */
+export function isProdOrStaging() {
+    // Determine environment settings
+    const ENV = whatsIsMyEnvironment();
+    return ENV === 'production' || ENV === 'staging';
+}
+
+/**
+ * Get the value of an environment variable
+ * 
+ * @param {string} key The environment variable key
+ * @param {string} defaultValue The default value to return if the key is not found
+ * @returns The value of the environment variable or the default value
+ */
+export function getEnvVariable(key, defaultValue = undefined) {
+    return process.env[key] || defaultValue;
+}
+
+/**
+ * Return the current environment (development, staging, production)
+ * 
+ * @returns {string} The current environment (development, staging, production)
+ */
+export function whatsIsMyEnvironment() {
+    // Determine environment 
+    return process.env.NODE_ENV || 'development';
+}

package/src/utils/govcyFormHandling.mjs

@@ -0,0 +1,148 @@
+/**
+ * @module govcyFormHandling
+ * @fileoverview This module provides utility functions for handling form data in a web application.
+ * It includes functions to populate form data with session data, handle conditional elements,
+ * and show error summary when there are validation errors.
+ */
+import { ALLOWED_FORM_ELEMENTS } from "./govcyConstants.mjs";
+
+
+/**
+ * Helper function to populate form data with session data
+ * @param {Array} formElements The form elements  
+ * @param {*} theData The data either from session or request
+ */
+export function populateFormData(formElements, theData, validationErrors) {
+    const inputElements = ALLOWED_FORM_ELEMENTS;
+
+    // Recursively populate form data with session data
+    formElements.forEach(element => {
+        if (inputElements.includes(element.element)) {
+            const fieldName = element.params.name;
+
+            // Handle `dateInput` separately
+            if (element.element === "dateInput") {
+                element.params.dayValue = theData[`${fieldName}_day`] || "";
+                element.params.monthValue = theData[`${fieldName}_month`] || "";
+                element.params.yearValue = theData[`${fieldName}_year`] || "";
+            //Handle `datePicker` separately
+            } else if (element.element === "datePicker") {
+                const val = theData[fieldName];
+
+                // Check if the value exists and matches the D/M/YYYY or DD/MM/YYYY pattern
+                if (val && /^\d{1,2}\/\d{1,2}\/\d{4}$/.test(val)) {
+                    const [day, month, year] = val.split("/").map(Number); // Convert parts to numbers
+                    const date = new Date(year, month - 1, day); // Month is zero-based in JS
+
+                    // Check if the date is valid (e.g., not 31/02/2020)
+                    if (
+                        date.getFullYear() === year &&
+                        date.getMonth() === month - 1 &&
+                        date.getDate() === day
+                    ) {
+                        // Format it as YYYY-MM-DD for the <input type="date"> value
+                        const yyyy = year;
+                        const mm = String(month).padStart(2, '0');
+                        const dd = String(day).padStart(2, '0');
+                        element.params.value = `${yyyy}-${mm}-${dd}`;
+                    } else {
+                        // Invalid date (e.g., 31/02/2020)
+                        element.params.value = "";
+                    }
+                } else {
+                    // Invalid format (not matching D/M/YYYY or DD/MM/YYYY)
+                    element.params.value = "";
+                }
+            // Handle all other input elements (textInput, checkboxes, radios, etc.)
+            } else {
+                element.params.value = theData[fieldName] || "";
+            }
+
+            // if there are validation errors, populate the error message
+            if (validationErrors?.errors?.[fieldName]) {
+                element.params.error = validationErrors.errors[fieldName].message;
+                //populate the error summary
+                const elementId = (element.element === "checkboxes" || element.element === "radios") // if checkboxes or radios
+                    ? `${element.params.id}-option-1` // use the id of the first option
+                    : (element.element === "dateInput") //if dateInput
+                    ? `${element.params.id}_day`  // use the id of the day input
+                    : element.params.id; // else use the id of the element
+                validationErrors.errorSummary.push({
+                    link: `#${elementId}`,
+                    text: validationErrors.errors[fieldName].message
+                });
+            }
+        }
+
+        // Handle conditional elements inside radios
+        if (element.element === "radios" && element.params.items) {
+            element.params.items.forEach(item => {
+                if (item.conditionalElements) {
+                    populateFormData(item.conditionalElements, theData, validationErrors);
+                  
+                    // Check if any conditional element has an error and add to the parent "conditionalHasErrors": true
+                    if (item.conditionalElements.some(condEl => condEl.params?.error)) {
+                        item.conditionalHasErrors = true;
+                    }
+                }
+            });
+        }
+    });
+}
+
+
+/**
+ * Filters form data based on the form definition, including conditionals.
+ * 
+ * @param {Array} elements - The form elements (including conditional ones).
+ * @param {Object} formData - The submitted form data.
+ * @returns {Object} filteredData - The filtered form data.
+ */
+export function getFormData(elements, formData) {
+    const filteredData = {};
+    elements.forEach(element => {
+        const { name } = element.params || {};
+
+        // Check if the element is allowed and has a name
+        if (ALLOWED_FORM_ELEMENTS.includes(element.element) && name) {
+            // Handle conditional elements (e.g., checkboxes, radios, select)
+            if (["checkboxes", "radios", "select"].includes(element.element)) {
+                const value = formData[name];
+                filteredData[name] = value !== undefined && value !== null ? value : "";
+                // Process conditional elements inside items
+                if (element.element === "radios" && element.params.items) {
+                    element.params.items.forEach(item => {
+                        if (item.conditionalElements) {
+                            Object.assign(
+                                filteredData,
+                                getFormData(item.conditionalElements, formData)
+                            );
+                        }
+                    });
+                }
+                
+            }
+            // Handle dateInput
+            else if (element.element === "dateInput") {
+                const day = formData[`${name}_day`];
+                const month = formData[`${name}_month`];
+                const year = formData[`${name}_year`];
+                filteredData[`${name}_day`] = day !== undefined && day !== null ? day : "";
+                filteredData[`${name}_month`] = month !== undefined && month !== null ? month : "";
+                filteredData[`${name}_year`] = year !== undefined && year !== null ? year : "";
+            // Handle other elements (e.g., textInput, textArea, datePicker)
+            } else {
+                filteredData[name] = formData[name] !== undefined && formData[name] !== null ? formData[name] : "";
+            }
+
+            // Always process conditional elements directly attached to the current element
+            // if (element.conditionalElements) {
+            //     Object.assign(filteredData, getFormData(element.conditionalElements, formData));
+            // }
+        }
+    
+    });
+    
+
+    return filteredData;
+}

package/src/utils/govcyLoadConfigData.mjs

@@ -0,0 +1,135 @@
+/**
+ * @module govcyLoadConfigData
+ * @fileoverview This module provides functions to load and manipulate configuration data for services.
+ * It includes functions to load service data from JSON files, handle language settings, and check for staging environments.
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { whatsIsMyEnvironment } from './govcyEnvVariables.mjs';
+import { logger } from "./govcyLogger.mjs";
+
+
+/**
+ * Load JSON data from `/data` by siteId
+ * @param {string} siteId The siteId
+ * @returns {Array} services - Array of JSON data
+ */
+function loadConfigDataById(siteId) {
+//   const __filename = fileURLToPath(import.meta.url);
+//   const __dirname = path.dirname(__filename);
+//   const dataPath = path.join(__dirname, '..', '..', 'data'); // Adjust if needed
+  const dataPath = path.join(process.cwd(), 'data'); // Adjust if needed
+  const filePath = path.join(dataPath, `${siteId}.json`);
+
+  try {
+      if (!fs.existsSync(filePath)) {
+          logger.debug(`Service data for '${siteId}' not found.`);
+          return null; // Return null so caller can handle 404 response
+      }
+
+      return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch (error) {
+      logger.error(`Error loading ${siteId}.json:`, error.message);
+      logger.debug(`Error loading ${siteId}.json:`, error);
+      return null;
+  }
+}
+
+
+/**
+ * Load service by siteId and return a deep copy
+ * 
+ * @param {string} siteId The siteId
+ * @param {string} lang The desired language
+ * @returns {Array} services - Array of JSON data
+ */
+export function getServiceConfigData(siteId,lang) {
+    //Load data from source
+    const service = loadConfigDataById(siteId);
+    if (!service) {
+        const error = new Error('Service not found');
+        error.status = 404;
+        throw error;  // Let Express catch this
+    }
+    //Handle deep copy: Deep copy to avoid mutations
+    let serviceCopy = JSON.parse(JSON.stringify(service));
+
+    //Handle lang: Set language based on provided `lang` parameter
+    if (Array.isArray(serviceCopy.site.languages)) {
+        if (serviceCopy.site.languages.length === 1) {
+            // If there's only one language, set it to that language
+            serviceCopy.site.lang = serviceCopy.site.languages[0].code;
+            serviceCopy.site.languages = undefined;
+        } else if (serviceCopy.site.languages.some(l => l.code === lang)) {
+            // If the provided lang exists in the languages array, set it
+            serviceCopy.site.lang = lang;
+        } else if (!serviceCopy.site.lang) {
+            // Default to 'el' if no language is set
+            serviceCopy.site.lang = "el";
+        }
+    } else if (!serviceCopy.site.lang) {
+        // Default to 'el' if languages is not defined and no language is set
+        serviceCopy.site.lang = "el";
+    }
+    
+    //Handle TESTING banner: check if staging and set isTesting
+    serviceCopy.site.isTesting = (whatsIsMyEnvironment() === "staging");
+
+    // Add manifest path
+    serviceCopy.site.manifest = `/${siteId}/manifest.json`;
+
+    return serviceCopy; 
+}
+
+/**
+ * Load page by pageUrl and return a deep copy
+ * 
+ * @param {object} service The service object containing page configurations
+ * @param {string} pageUrl The page URL
+ * @returns The page configuration object
+ */
+export function getPageConfigData(service, pageUrl) {
+   
+    // Find the page by pageUrl
+    let page = service.pages.find(p => p.pageData.url === pageUrl);
+    
+    if (!page) {
+        const error = new Error('Page not found');
+        error.status = 404;
+        throw error;  // Let Express catch this
+    }
+    
+    return page; 
+}
+
+/**
+ * Get a list of available site configs with their titles.
+ * @returns {Array<{filename: string, title: string}>}
+ */
+export function listAvailableSiteConfigs() {
+    const dataPath = path.join(process.cwd(), 'data');
+    let result = [];
+    try {
+        const files = fs.readdirSync(dataPath)
+            .filter(f => f.endsWith('.json'));
+
+        for (const file of files) {
+            const siteId = path.basename(file, '.json');
+            try {
+                const config = getServiceConfigData(siteId);
+                result.push({
+                    filename: siteId,
+                    title: config.site?.title || {el: "Unknown Service", en: "Unknown Service", tr: "Unknown Service"}
+                });
+            } catch (e) {
+                // Skip files that can't be loaded
+                logger.debug(`Skipping ${file}: ${e.message}`);
+            }
+        }
+    } catch (err) {
+        logger.error('Error reading data directory:', err.message);
+        return result; // Return empty array if there's an error
+    }
+    return result;
+}

package/src/utils/govcyLogger.mjs

@@ -0,0 +1,30 @@
+/**
+ * Logs a message to the console with a given level.
+ * Falls back to console.log if an unknown level is used.
+ * 
+ * @param {'info'|'warn'|'error'|'debug'} level - The log level.
+ * @param {...any} args - The content to log.
+ */
+export function logger(level, ...args) {
+    const timestamp = new Date().toISOString();
+  
+    const logMethods = {
+      info: console.log,
+      warn: console.warn,
+      error: console.error,
+      debug: (...msg) => {
+        if (process.env.DEBUG === 'true') {
+          console.debug(...msg);
+        }
+      }
+    };
+  
+    const logFn = logMethods[level] || console.log;
+  
+    logFn(`[${level.toUpperCase()}] [${timestamp}]`, ...args);
+  }
+// Attach shortcut functions to the main logger function
+logger.info = (...args) => logger('info', ...args);
+logger.warn = (...args) => logger('warn', ...args);
+logger.error = (...args) => logger('error', ...args);
+logger.debug = (...args) => logger('debug', ...args);