@futdevpro/fsm-dynamo 1.16.39 → 1.20.2

package/build/_modules/ci-tools/_models/cit-ci-step-result.interface.d.ts

@@ -1,10 +1,10 @@
-import { DyFM_CIT_CIStepResultCode } from '../_enums/cit-ci-step-result-code.enum';
-export interface DyFM_CIT_CIStepResult {
-    stepName: string;
-    resultCode: DyFM_CIT_CIStepResultCode;
-    duration: number;
-    message?: string;
-    details?: string;
-    error?: any;
-}
+import { DyFM_CIT_CIStepResultCode } from '../_enums/cit-ci-step-result-code.enum';
+export interface DyFM_CIT_CIStepResult {
+    stepName: string;
+    resultCode: DyFM_CIT_CIStepResultCode;
+    duration: number;
+    message?: string;
+    details?: string;
+    error?: any;
+}
 //# sourceMappingURL=cit-ci-step-result.interface.d.ts.map

package/build/_modules/ci-tools/_models/cit-ci-step-result.interface.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=cit-ci-step-result.interface.js.map

package/build/_modules/ci-tools/index.d.ts

@@ -1,5 +1,5 @@
-export * from './_enums/cit-ci-result-code.enum';
-export * from './_enums/cit-ci-step-result-code.enum';
-export * from './_models/cit-ci-result-info.data-models';
-export * from './_models/cit-ci-step-result.interface';
+export * from './_enums/cit-ci-result-code.enum';
+export * from './_enums/cit-ci-step-result-code.enum';
+export * from './_models/cit-ci-result-info.data-models';
+export * from './_models/cit-ci-step-result.interface';
 //# sourceMappingURL=index.d.ts.map

package/build/_modules/ci-tools/index.js

@@ -1,10 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-// ENUMS
-tslib_1.__exportStar(require("./_enums/cit-ci-result-code.enum"), exports);
-tslib_1.__exportStar(require("./_enums/cit-ci-step-result-code.enum"), exports);
-// MODELS
-tslib_1.__exportStar(require("./_models/cit-ci-result-info.data-models"), exports);
-tslib_1.__exportStar(require("./_models/cit-ci-step-result.interface"), exports);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// ENUMS
+tslib_1.__exportStar(require("./_enums/cit-ci-result-code.enum"), exports);
+tslib_1.__exportStar(require("./_enums/cit-ci-step-result-code.enum"), exports);
+// MODELS
+tslib_1.__exportStar(require("./_models/cit-ci-result-info.data-models"), exports);
+tslib_1.__exportStar(require("./_models/cit-ci-step-result.interface"), exports);
 //# sourceMappingURL=index.js.map

package/build/_modules/crypto/_collections/crypto-v1.util.d.ts

@@ -1,48 +1,48 @@
-/**
- * A utility class for secure encryption and decryption of data
- * Uses AES-256-CBC with deterministic IV and salt for consistent results
- */
-export declare class DyFM_Crypto {
-    private static readonly defaultErrorUserMsg;
-    /**
-     * Validates the encryption key
-     */
-    private static validateKey;
-    /**
-     * Safely serializes data to JSON
-     */
-    private static safeSerialize;
-    /**
-     * Safely deserializes JSON data
-     */
-    private static safeDeserialize;
-    /**
-     * Derives a 256-bit key from the passphrase using SHA256
-     */
-    private static deriveKey;
-    /**
-     * Creates a deterministic IV from the key only
-     */
-    private static createDeterministicIV;
-    /**
-     * Encrypts data using AES-256-CBC with deterministic key and IV
-     * @param data The data to encrypt
-     * @param key The encryption key
-     * @returns URL-safe encrypted string
-     * @throws {DyFM_Error} if encryption fails
-     */
-    static encrypt<T>(data: T, key: string): string;
-    /**
-     * Decrypts data that was encrypted using encrypt()
-     * @param encryptedData The encrypted data
-     * @param key The decryption key
-     * @returns The decrypted data
-     * @throws {DyFM_Error} if decryption fails
-     */
-    static decrypt<T>(encryptedData: string, key: string): T;
-    /**
-     * Gets default error settings
-     */
-    private static getDefaultErrorSettings;
-}
+/**
+ * A utility class for secure encryption and decryption of data
+ * Uses AES-256-CBC with deterministic IV and salt for consistent results
+ */
+export declare class DyFM_Crypto {
+    private static readonly defaultErrorUserMsg;
+    /**
+     * Validates the encryption key
+     */
+    private static validateKey;
+    /**
+     * Safely serializes data to JSON
+     */
+    private static safeSerialize;
+    /**
+     * Safely deserializes JSON data
+     */
+    private static safeDeserialize;
+    /**
+     * Derives a 256-bit key from the passphrase using SHA256
+     */
+    private static deriveKey;
+    /**
+     * Creates a deterministic IV from the key only
+     */
+    private static createDeterministicIV;
+    /**
+     * Encrypts data using AES-256-CBC with deterministic key and IV
+     * @param data The data to encrypt
+     * @param key The encryption key
+     * @returns URL-safe encrypted string
+     * @throws {DyFM_Error} if encryption fails
+     */
+    static encrypt<T>(data: T, key: string): string;
+    /**
+     * Decrypts data that was encrypted using encrypt()
+     * @param encryptedData The encrypted data
+     * @param key The decryption key
+     * @returns The decrypted data
+     * @throws {DyFM_Error} if decryption fails
+     */
+    static decrypt<T>(encryptedData: string, key: string): T;
+    /**
+     * Gets default error settings
+     */
+    private static getDefaultErrorSettings;
+}
 //# sourceMappingURL=crypto-v1.util.d.ts.map

package/build/_modules/crypto/_collections/crypto-v1.util.js

@@ -1,205 +1,205 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyFM_Crypto = void 0;
-const tslib_1 = require("tslib");
-const CryptoJS = tslib_1.__importStar(require("crypto-js"));
-const error_control_model_1 = require("../../../_models/control-models/error.control-model");
-const object_util_1 = require("../../../_collections/utils/object.util");
-/**
- * A utility class for secure encryption and decryption of data
- * Uses AES-256-CBC with deterministic IV and salt for consistent results
- */
-class DyFM_Crypto {
-    static defaultErrorUserMsg = `We encountered an unhandled Authentication Error, ` +
-        `\nplease contact the responsible development team.`;
-    /**
-     * Validates the encryption key
-     */
-    static validateKey(key) {
-        if (!key || typeof key !== 'string') {
-            throw new error_control_model_1.DyFM_Error({
-                status: 401,
-                message: 'Encryption key is required and must be a string',
-                errorCode: 'DyFM-CRY-KEY-REQ'
-            });
-        }
-        if (key.trim().length === 0) {
-            throw new error_control_model_1.DyFM_Error({
-                status: 401,
-                message: 'Encryption key cannot be empty or whitespace-only',
-                errorCode: 'DyFM-CRY-KEY-EMPTY'
-            });
-        }
-    }
-    /**
-     * Safely serializes data to JSON
-     */
-    static safeSerialize(data) {
-        try {
-            return JSON.stringify(data);
-        }
-        catch (error) {
-            throw new error_control_model_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('safeSerialize', error),
-                errorCode: 'DyFM-CRY-SER',
-                message: 'Failed to serialize data'
-            });
-        }
-    }
-    /**
-     * Safely deserializes JSON data
-     */
-    static safeDeserialize(data) {
-        try {
-            let parsed = object_util_1.DyFM_Object.failableSafeParseJSON(data);
-            // Handle double-stringified JSON
-            if (typeof parsed === 'string') {
-                try {
-                    parsed = object_util_1.DyFM_Object.failableSafeParseJSON(parsed);
-                }
-                catch {
-                    // If second parse fails, return the string as is
-                    return parsed;
-                }
-            }
-            // Handle primitive values
-            if (typeof parsed === 'string' || typeof parsed === 'number' || typeof parsed === 'boolean') {
-                return parsed;
-            }
-            return parsed;
-        }
-        catch (error) {
-            throw new error_control_model_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('safeDeserialize', error),
-                errorCode: 'DyFM-CRY-DES',
-                message: 'Failed to deserialize data'
-            });
-        }
-    }
-    /**
-     * Derives a 256-bit key from the passphrase using SHA256
-     */
-    static deriveKey(key) {
-        return CryptoJS.SHA256(key);
-    }
-    /**
-     * Creates a deterministic IV from the key only
-     */
-    static createDeterministicIV(key) {
-        const hash = CryptoJS.SHA256(key + ':iv');
-        return CryptoJS.lib.WordArray.create(hash.words.slice(0, 4)); // Use first 16 bytes (128 bits)
-    }
-    /**
-     * Encrypts data using AES-256-CBC with deterministic key and IV
-     * @param data The data to encrypt
-     * @param key The encryption key
-     * @returns URL-safe encrypted string
-     * @throws {DyFM_Error} if encryption fails
-     */
-    static encrypt(data, key) {
-        try {
-            // Validate key
-            this.validateKey(key);
-            // Validate data
-            if (data === undefined || data === null) {
-                throw new error_control_model_1.DyFM_Error({
-                    status: 401,
-                    message: 'Data cannot be undefined or null',
-                    errorCode: 'DyFM-CRY-DATA-NULL'
-                });
-            }
-            // Convert data to string
-            const dataStr = this.safeSerialize(data);
-            // Derive key and IV
-            const aesKey = this.deriveKey(key);
-            const iv = this.createDeterministicIV(key);
-            // Encrypt the data with deterministic key and IV
-            const encrypted = CryptoJS.AES.encrypt(dataStr, aesKey, {
-                iv: iv,
-                mode: CryptoJS.mode.CBC,
-                padding: CryptoJS.pad.Pkcs7
-            });
-            // Convert to URL-safe base64
-            const base64 = encrypted.ciphertext.toString(CryptoJS.enc.Base64);
-            return base64
-                .replace(/\+/g, '-')
-                .replace(/\//g, '_')
-                .replace(/=+$/, '');
-        }
-        catch (error) {
-            throw new error_control_model_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('encrypt', error),
-                errorCode: 'DyFM-CRY-ENC',
-            });
-        }
-    }
-    /**
-     * Decrypts data that was encrypted using encrypt()
-     * @param encryptedData The encrypted data
-     * @param key The decryption key
-     * @returns The decrypted data
-     * @throws {DyFM_Error} if decryption fails
-     */
-    static decrypt(encryptedData, key) {
-        try {
-            // Validate key
-            this.validateKey(key);
-            // Validate encrypted data
-            if (!encryptedData || typeof encryptedData !== 'string') {
-                throw new error_control_model_1.DyFM_Error({
-                    status: 401,
-                    message: 'Encrypted data is required and must be a string',
-                    errorCode: 'DyFM-CRY-DATA-REQ'
-                });
-            }
-            // Convert from URL-safe base64
-            let base64 = encryptedData
-                .replace(/-/g, '+')
-                .replace(/_/g, '/');
-            // Add padding if needed
-            const padLength = 4 - (base64.length % 4);
-            if (padLength < 4) {
-                base64 += '='.repeat(padLength);
-            }
-            // Derive key and IV
-            const aesKey = this.deriveKey(key);
-            const iv = this.createDeterministicIV(key);
-            // Decrypt the data
-            const encryptedWA = CryptoJS.enc.Base64.parse(base64);
-            const decrypted = CryptoJS.AES.decrypt({ ciphertext: encryptedWA }, aesKey, {
-                iv: iv,
-                mode: CryptoJS.mode.CBC,
-                padding: CryptoJS.pad.Pkcs7
-            });
-            // Parse JSON
-            const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
-            if (!decryptedStr) {
-                throw new error_control_model_1.DyFM_Error({
-                    status: 401,
-                    message: 'Failed to decrypt data - invalid key or corrupted data',
-                    errorCode: 'DyFM-CRY-DEC-FAIL'
-                });
-            }
-            return this.safeDeserialize(decryptedStr);
-        }
-        catch (error) {
-            throw new error_control_model_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('decrypt', error),
-                errorCode: 'DyFM-CRY-DRY',
-            });
-        }
-    }
-    /**
-     * Gets default error settings
-     */
-    static getDefaultErrorSettings(operation, error) {
-        return {
-            status: error?.___status ?? error?.status ?? 401,
-            message: `Crypto operation "${operation}" failed; ` + error_control_model_1.DyFM_Error.getAnyMessage(error),
-            error: error,
-            errorCode: 'DyFM-CRY-ERR'
-        };
-    }
-}
-exports.DyFM_Crypto = DyFM_Crypto;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyFM_Crypto = void 0;
+const tslib_1 = require("tslib");
+const CryptoJS = tslib_1.__importStar(require("crypto-js"));
+const error_control_model_1 = require("../../../_models/control-models/error.control-model");
+const object_util_1 = require("../../../_collections/utils/object.util");
+/**
+ * A utility class for secure encryption and decryption of data
+ * Uses AES-256-CBC with deterministic IV and salt for consistent results
+ */
+class DyFM_Crypto {
+    static defaultErrorUserMsg = `We encountered an unhandled Authentication Error, ` +
+        `\nplease contact the responsible development team.`;
+    /**
+     * Validates the encryption key
+     */
+    static validateKey(key) {
+        if (!key || typeof key !== 'string') {
+            throw new error_control_model_1.DyFM_Error({
+                status: 401,
+                message: 'Encryption key is required and must be a string',
+                errorCode: 'DyFM-CRY-KEY-REQ'
+            });
+        }
+        if (key.trim().length === 0) {
+            throw new error_control_model_1.DyFM_Error({
+                status: 401,
+                message: 'Encryption key cannot be empty or whitespace-only',
+                errorCode: 'DyFM-CRY-KEY-EMPTY'
+            });
+        }
+    }
+    /**
+     * Safely serializes data to JSON
+     */
+    static safeSerialize(data) {
+        try {
+            return JSON.stringify(data);
+        }
+        catch (error) {
+            throw new error_control_model_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('safeSerialize', error),
+                errorCode: 'DyFM-CRY-SER',
+                message: 'Failed to serialize data'
+            });
+        }
+    }
+    /**
+     * Safely deserializes JSON data
+     */
+    static safeDeserialize(data) {
+        try {
+            let parsed = object_util_1.DyFM_Object.failableSafeParseJSON(data);
+            // Handle double-stringified JSON
+            if (typeof parsed === 'string') {
+                try {
+                    parsed = object_util_1.DyFM_Object.failableSafeParseJSON(parsed);
+                }
+                catch {
+                    // If second parse fails, return the string as is
+                    return parsed;
+                }
+            }
+            // Handle primitive values
+            if (typeof parsed === 'string' || typeof parsed === 'number' || typeof parsed === 'boolean') {
+                return parsed;
+            }
+            return parsed;
+        }
+        catch (error) {
+            throw new error_control_model_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('safeDeserialize', error),
+                errorCode: 'DyFM-CRY-DES',
+                message: 'Failed to deserialize data'
+            });
+        }
+    }
+    /**
+     * Derives a 256-bit key from the passphrase using SHA256
+     */
+    static deriveKey(key) {
+        return CryptoJS.SHA256(key);
+    }
+    /**
+     * Creates a deterministic IV from the key only
+     */
+    static createDeterministicIV(key) {
+        const hash = CryptoJS.SHA256(key + ':iv');
+        return CryptoJS.lib.WordArray.create(hash.words.slice(0, 4)); // Use first 16 bytes (128 bits)
+    }
+    /**
+     * Encrypts data using AES-256-CBC with deterministic key and IV
+     * @param data The data to encrypt
+     * @param key The encryption key
+     * @returns URL-safe encrypted string
+     * @throws {DyFM_Error} if encryption fails
+     */
+    static encrypt(data, key) {
+        try {
+            // Validate key
+            this.validateKey(key);
+            // Validate data
+            if (data === undefined || data === null) {
+                throw new error_control_model_1.DyFM_Error({
+                    status: 401,
+                    message: 'Data cannot be undefined or null',
+                    errorCode: 'DyFM-CRY-DATA-NULL'
+                });
+            }
+            // Convert data to string
+            const dataStr = this.safeSerialize(data);
+            // Derive key and IV
+            const aesKey = this.deriveKey(key);
+            const iv = this.createDeterministicIV(key);
+            // Encrypt the data with deterministic key and IV
+            const encrypted = CryptoJS.AES.encrypt(dataStr, aesKey, {
+                iv: iv,
+                mode: CryptoJS.mode.CBC,
+                padding: CryptoJS.pad.Pkcs7
+            });
+            // Convert to URL-safe base64
+            const base64 = encrypted.ciphertext.toString(CryptoJS.enc.Base64);
+            return base64
+                .replace(/\+/g, '-')
+                .replace(/\//g, '_')
+                .replace(/=+$/, '');
+        }
+        catch (error) {
+            throw new error_control_model_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('encrypt', error),
+                errorCode: 'DyFM-CRY-ENC',
+            });
+        }
+    }
+    /**
+     * Decrypts data that was encrypted using encrypt()
+     * @param encryptedData The encrypted data
+     * @param key The decryption key
+     * @returns The decrypted data
+     * @throws {DyFM_Error} if decryption fails
+     */
+    static decrypt(encryptedData, key) {
+        try {
+            // Validate key
+            this.validateKey(key);
+            // Validate encrypted data
+            if (!encryptedData || typeof encryptedData !== 'string') {
+                throw new error_control_model_1.DyFM_Error({
+                    status: 401,
+                    message: 'Encrypted data is required and must be a string',
+                    errorCode: 'DyFM-CRY-DATA-REQ'
+                });
+            }
+            // Convert from URL-safe base64
+            let base64 = encryptedData
+                .replace(/-/g, '+')
+                .replace(/_/g, '/');
+            // Add padding if needed
+            const padLength = 4 - (base64.length % 4);
+            if (padLength < 4) {
+                base64 += '='.repeat(padLength);
+            }
+            // Derive key and IV
+            const aesKey = this.deriveKey(key);
+            const iv = this.createDeterministicIV(key);
+            // Decrypt the data
+            const encryptedWA = CryptoJS.enc.Base64.parse(base64);
+            const decrypted = CryptoJS.AES.decrypt({ ciphertext: encryptedWA }, aesKey, {
+                iv: iv,
+                mode: CryptoJS.mode.CBC,
+                padding: CryptoJS.pad.Pkcs7
+            });
+            // Parse JSON
+            const decryptedStr = decrypted.toString(CryptoJS.enc.Utf8);
+            if (!decryptedStr) {
+                throw new error_control_model_1.DyFM_Error({
+                    status: 401,
+                    message: 'Failed to decrypt data - invalid key or corrupted data',
+                    errorCode: 'DyFM-CRY-DEC-FAIL'
+                });
+            }
+            return this.safeDeserialize(decryptedStr);
+        }
+        catch (error) {
+            throw new error_control_model_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('decrypt', error),
+                errorCode: 'DyFM-CRY-DRY',
+            });
+        }
+    }
+    /**
+     * Gets default error settings
+     */
+    static getDefaultErrorSettings(operation, error) {
+        return {
+            status: error?.___status ?? error?.status ?? 401,
+            message: `Crypto operation "${operation}" failed; ` + error_control_model_1.DyFM_Error.getAnyMessage(error),
+            error: error,
+            errorCode: 'DyFM-CRY-ERR'
+        };
+    }
+}
+exports.DyFM_Crypto = DyFM_Crypto;
 //# sourceMappingURL=crypto-v1.util.js.map