@trayio/commons 4.55.0 → 4.56.0

package/dist/codec/SensitiveRemoveTagAndRedactCodec.d.ts

@@ -0,0 +1,14 @@
+import * as E from 'fp-ts/lib/Either';
+import { Codec } from './Codec';
+export declare class SensitiveRemoveTagAndRedactCodec implements Codec<unknown> {
+    private redactValues;
+    constructor(redactValues?: boolean);
+    static instance(redactValues?: boolean): Codec<unknown>;
+    encode(value: unknown): unknown;
+    decode(value: unknown): E.Either<Error, unknown>;
+    private isObject;
+    private stripTagAndRedactValue;
+    private redactValuesFromArrayIfPresent;
+    private redactValuesFromObjectIfPresent;
+}
+//# sourceMappingURL=SensitiveRemoveTagAndRedactCodec.d.ts.map

package/dist/codec/SensitiveRemoveTagAndRedactCodec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SensitiveRemoveTagAndRedactCodec.d.ts","sourceRoot":"","sources":["../../src/codec/SensitiveRemoveTagAndRedactCodec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,kBAAkB,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,qBAAa,gCAAiC,YAAW,KAAK,CAAC,OAAO,CAAC;IAC1D,OAAO,CAAC,YAAY;gBAAZ,YAAY,GAAE,OAAe;IAEjD,MAAM,CAAC,QAAQ,CAAC,YAAY,UAAQ,GAAG,KAAK,CAAC,OAAO,CAAC;IAIrD,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAI/B,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC;IAIhD,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,sBAAsB;IAa9B,OAAO,CAAC,8BAA8B;IAStC,OAAO,CAAC,+BAA+B;CAyCvC"}

package/dist/codec/{RedactValuesCodec.js → SensitiveRemoveTagAndRedactCodec.js}

@@ -23,21 +23,26 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedactValuesCodec = void 0;
+exports.SensitiveRemoveTagAndRedactCodec = void 0;
 const E = __importStar(require("fp-ts/lib/Either"));
-const Sensitive_1 = require("../sensitive/Sensitive");
-class RedactValuesCodec {
-    static instance = new RedactValuesCodec();
+class SensitiveRemoveTagAndRedactCodec {
+    redactValues;
+    constructor(redactValues = false) {
+        this.redactValues = redactValues;
+    }
+    static instance(redactValues = false) {
+        return new SensitiveRemoveTagAndRedactCodec(redactValues);
+    }
     encode(value) {
-        return this.redactSensitiveValues(value);
+        return this.stripTagAndRedactValue(value);
     }
     decode(value) {
-        return E.right(this.redactSensitiveValues(value));
+        return E.right(this.stripTagAndRedactValue(value));
     }
     isObject(value) {
         return typeof value === 'object' && !Array.isArray(value) && value !== null;
     }
-    redactSensitiveValues(value) {
+    stripTagAndRedactValue(value) {
         if (value === null) {
             return value;
         }
@@ -54,14 +59,33 @@ class RedactValuesCodec {
             if (propertyValue == null) {
                 return acc;
             }
-            return [...acc, this.redactSensitiveValues(propertyValue)];
+            return [...acc, this.stripTagAndRedactValue(propertyValue)];
         }, []);
     }
     redactValuesFromObjectIfPresent(value) {
         return Object.entries(value).reduce((acc, [key, propertyValue]) => {
             if (this.isObject(propertyValue)) {
                 if (propertyValue._tag === 'Sensitive') {
-                    return { ...acc, [key]: Sensitive_1.Sensitive.fromValue('<REDACTED>') };
+                    const { _tag, value: sensitiveValue } = propertyValue;
+                    if (this.redactValues) {
+                        return {
+                            ...acc,
+                            [key]: '<REDACTED>',
+                        };
+                    }
+                    if (this.isObject(sensitiveValue)) {
+                        return {
+                            ...acc,
+                            [key]: this.redactValuesFromObjectIfPresent(sensitiveValue),
+                        };
+                    }
+                    if (Array.isArray(sensitiveValue)) {
+                        return {
+                            ...acc,
+                            [key]: this.redactValuesFromArrayIfPresent(sensitiveValue),
+                        };
+                    }
+                    return { ...acc, [key]: sensitiveValue };
                 }
                 const nestedObject = this.redactValuesFromObjectIfPresent(propertyValue);
                 return { ...acc, [key]: nestedObject };
@@ -74,4 +98,4 @@ class RedactValuesCodec {
         }, {});
     }
 }
-exports.RedactValuesCodec = RedactValuesCodec;
+exports.SensitiveRemoveTagAndRedactCodec = SensitiveRemoveTagAndRedactCodec;

package/dist/codec/SensitiveRemoveTagAndRedactCodec.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=SensitiveRemoveTagAndRedactCodec.unit.test.d.ts.map

package/dist/codec/SensitiveRemoveTagAndRedactCodec.unit.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SensitiveRemoveTagAndRedactCodec.unit.test.d.ts","sourceRoot":"","sources":["../../src/codec/SensitiveRemoveTagAndRedactCodec.unit.test.ts"],"names":[],"mappings":""}

package/dist/codec/SensitiveRemoveTagAndRedactCodec.unit.test.js

@@ -0,0 +1,196 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const O = __importStar(require("fp-ts/Option"));
+const Sensitive_1 = require("../sensitive/Sensitive");
+const Sensitive_unit_test_1 = require("../sensitive/Sensitive.unit.test");
+const CompositeCodec_1 = require("./CompositeCodec");
+const SensitiveRemoveTagAndRedactCodec_1 = require("./SensitiveRemoveTagAndRedactCodec");
+describe('SensitiveRemoveTagAndRedactCodec', () => {
+    it('should redact sensitive typed data', () => {
+        const value = {
+            password: Sensitive_1.Sensitive.fromValue('password'),
+            username: 'username',
+            address: {
+                city: 'city',
+                street: 'street',
+                number: 123,
+            },
+        };
+        const actualValue = SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(true).encode(value);
+        const expectedValue = {
+            password: '<REDACTED>',
+            username: 'username',
+            address: {
+                city: 'city',
+                street: 'street',
+                number: 123,
+            },
+        };
+        expect(actualValue).toStrictEqual(expectedValue);
+    });
+    it('should remove sensitive wrapper and not redact values when redactValues is false', () => {
+        const value = {
+            password: Sensitive_1.Sensitive.fromValue('password'),
+            username: 'username',
+            address: {
+                city: 'city',
+                street: 'street',
+                number: 123,
+            },
+        };
+        const actualValue = SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(false).encode(value);
+        const expectedValue = {
+            password: 'password',
+            username: 'username',
+            address: {
+                city: 'city',
+                street: 'street',
+                number: 123,
+            },
+        };
+        expect(actualValue).toStrictEqual(expectedValue);
+    });
+    it('should redact sensitive typed data in nested arrays', () => {
+        const value = {
+            users: [
+                { password: Sensitive_1.Sensitive.fromValue('password'), username: 'username' },
+            ],
+        };
+        const actualValue = SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(true).encode(value);
+        const expectedValue = {
+            users: [{ password: '<REDACTED>', username: 'username' }],
+        };
+        expect(actualValue).toStrictEqual(expectedValue);
+    });
+    it('should redact sensitive typed data in nested objects', () => {
+        const value = {
+            user: { password: Sensitive_1.Sensitive.fromValue('password'), username: 'username' },
+        };
+        const actualValue = SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(true).encode(value);
+        const expectedValue = {
+            user: {
+                password: '<REDACTED>',
+                username: 'username',
+            },
+        };
+        expect(actualValue).toStrictEqual(expectedValue);
+    });
+    it('should redact sensitive typed data in nested optional objects', () => {
+        const value = {
+            user: {
+                password: Sensitive_1.Sensitive.fromValue(O.some('test')),
+                username: 'username',
+            },
+        };
+        const actualValue = SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(true).encode(value);
+        const expectedValue = {
+            user: {
+                password: '<REDACTED>',
+                username: 'username',
+            },
+        };
+        expect(actualValue).toStrictEqual(expectedValue);
+    });
+    it('should not redact sensitive typed data in nested optional objects when redact values is false', () => {
+        const value = {
+            user: {
+                password: Sensitive_1.Sensitive.fromValue(O.some('test')),
+                username: 'username',
+            },
+        };
+        const actualValue = SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(false).encode(value);
+        const expectedValue = {
+            user: {
+                password: O.some('test'),
+                username: 'username',
+            },
+        };
+        expect(actualValue).toStrictEqual(expectedValue);
+    });
+    it('should redact sensitive typed data and type encode the value', () => {
+        const testValueEncoded = {
+            strField: 'str',
+            intField: Sensitive_1.Sensitive.fromValue(O.some(123)),
+            objectField: Sensitive_1.Sensitive.fromValue({
+                str: 'test',
+                int: 123,
+                optionalObj: Sensitive_1.Sensitive.fromValue(O.some({
+                    test: 'test',
+                    test1: 'test1',
+                    testArray: Sensitive_1.Sensitive.fromValue([
+                        O.some('test1'),
+                        O.some('test2'),
+                        O.some('test3'),
+                    ]),
+                })),
+            }),
+        };
+        const redactAndTypeDecode = CompositeCodec_1.CompositeCodec.fromCodecs(Sensitive_unit_test_1.testTypeSensitiveCodec, SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(true));
+        const result = redactAndTypeDecode.encode(testValueEncoded);
+        const expected = {
+            strField: 'str',
+            intField: '<REDACTED>',
+            objectField: '<REDACTED>',
+        };
+        expect(result).toStrictEqual(expected);
+    });
+    it('should not redact sensitive typed data and type encode the value', () => {
+        const testValueEncoded = {
+            strField: 'str',
+            intField: Sensitive_1.Sensitive.fromValue(O.some(123)),
+            objectField: Sensitive_1.Sensitive.fromValue({
+                str: 'test',
+                int: 123,
+                optionalObj: Sensitive_1.Sensitive.fromValue(O.some({
+                    test: 'test',
+                    test1: 'test1',
+                    testArray: Sensitive_1.Sensitive.fromValue([
+                        O.some('test'),
+                        O.some('test1'),
+                        O.some('test2'),
+                        O.some('test3'),
+                    ]),
+                })),
+            }),
+        };
+        const redactAndTypeDecode = CompositeCodec_1.CompositeCodec.fromCodecs(Sensitive_unit_test_1.testTypeSensitiveCodec, SensitiveRemoveTagAndRedactCodec_1.SensitiveRemoveTagAndRedactCodec.instance(false));
+        const result = redactAndTypeDecode.encode(testValueEncoded);
+        const expected = {
+            strField: 'str',
+            intField: 123,
+            objectField: {
+                int: 123,
+                str: 'test',
+                optionalObj: {
+                    test: 'test',
+                    test1: 'test1',
+                    testArray: ['test', 'test1', 'test2', 'test3'],
+                },
+            },
+        };
+        expect(result).toStrictEqual(expected);
+    });
+});

package/dist/sensitive/Sensitive.d.ts

@@ -6,8 +6,8 @@ export type Sensitive<T> = {
 };
 export interface SensitiveInterface {
     fromValue: <T>(value: T) => Sensitive<T>;
-    typeCodec: Codec<Sensitive<unknown>>;
-    typeDescriptor: <T>(descriptor: t.Type<T, unknown>) => t.Type<Sensitive<T>, unknown>;
+    typeDescriptor: <T>(descriptor: t.Type<T, unknown>) => t.Type<Sensitive<T>, Sensitive<unknown>>;
+    typeCodec: <T>(descriptor: t.Type<T, unknown>) => Codec<Sensitive<T>>;
 }
 export declare const Sensitive: SensitiveInterface;
 //# sourceMappingURL=Sensitive.d.ts.map

package/dist/sensitive/Sensitive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sensitive.d.ts","sourceRoot":"","sources":["../../src/sensitive/Sensitive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;CAC3B,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC;IACzC,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IACrC,cAAc,EAAE,CAAC,CAAC,EACjB,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,KAC1B,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;CACnC;AAeD,eAAO,MAAM,SAAS,EAAE,kBAQvB,CAAC"}
+{"version":3,"file":"Sensitive.d.ts","sourceRoot":"","sources":["../../src/sensitive/Sensitive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,OAAO,CAAC;AAE3B,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAGvC,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAC1B,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;CAC3B,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAClC,SAAS,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC;IACzC,cAAc,EAAE,CAAC,CAAC,EACjB,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,KAC1B,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9C,SAAS,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;CACtE;AAyBD,eAAO,MAAM,SAAS,EAAE,kBAQvB,CAAC"}

package/dist/sensitive/Sensitive.js

@@ -25,14 +25,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sensitive = void 0;
 const t = __importStar(require("io-ts"));
+const E = __importStar(require("fp-ts/Either"));
 const TypeCodec_1 = require("../codec/TypeCodec");
-const sensitiveTypeDescriptor = () => new t.Type('Sensitive', (u) => u instanceof Object && '_tag' in u && u._tag === 'Sensitive', (u, c) => t.success(exports.Sensitive.fromValue(u)), (a) => a.value);
-const sensitiveTypeCodec = TypeCodec_1.TypeCodec.fromDescriptor(sensitiveTypeDescriptor());
+const sensitiveTypeDescriptor = (descriptor) => new t.Type('Sensitive', (u) => u instanceof Object && '_tag' in u && u._tag === 'Sensitive', (u, c) => {
+    const validation = descriptor.validate(u, c);
+    if (E.isLeft(validation)) {
+        return t.failure(u, c, validation.left.map((e) => e.message).join('\n'));
+    }
+    return t.success(exports.Sensitive.fromValue(validation.right));
+}, (a) => exports.Sensitive.fromValue(descriptor.encode(a.value)));
+const sensitiveTypeCodec = (descriptor) => TypeCodec_1.TypeCodec.fromDescriptor(sensitiveTypeDescriptor(descriptor));
 exports.Sensitive = {
     fromValue: (value) => ({
         value,
         _tag: 'Sensitive',
     }),
+    typeDescriptor: (descriptor) => sensitiveTypeDescriptor(descriptor),
     typeCodec: sensitiveTypeCodec,
-    typeDescriptor: (descriptor) => descriptor.pipe(sensitiveTypeDescriptor()),
 };

package/dist/sensitive/Sensitive.unit.test.d.ts

@@ -1,8 +1,18 @@
+import * as O from 'fp-ts/Option';
 import { Codec } from '../codec/Codec';
 import { Sensitive } from './Sensitive';
 export type TestTypeSensitive = {
     strField: string;
-    intField: Sensitive<number>;
+    intField: Sensitive<O.Option<number>>;
+    objectField: Sensitive<{
+        int: number;
+        str: string;
+        optionalObj: Sensitive<O.Option<{
+            test: string;
+            test1: string;
+            testArray: Sensitive<O.Option<string>[]>;
+        }>>;
+    }>;
 };
 export declare const testTypeSensitiveCodec: Codec<TestTypeSensitive>;
 //# sourceMappingURL=Sensitive.unit.test.d.ts.map

package/dist/sensitive/Sensitive.unit.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sensitive.unit.test.d.ts","sourceRoot":"","sources":["../../src/sensitive/Sensitive.unit.test.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,iBAAiB,CAM1D,CAAC"}
+{"version":3,"file":"Sensitive.unit.test.d.ts","sourceRoot":"","sources":["../../src/sensitive/Sensitive.unit.test.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEvC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,MAAM,iBAAiB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IACtC,WAAW,EAAE,SAAS,CAAC;QACtB,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,WAAW,EAAE,SAAS,CACrB,CAAC,CAAC,MAAM,CAAC;YACR,IAAI,EAAE,MAAM,CAAC;YACb,KAAK,EAAE,MAAM,CAAC;YACd,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;SACzC,CAAC,CACF,CAAC;KACF,CAAC,CAAC;CACH,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,KAAK,CAAC,iBAAiB,CAuB1D,CAAC"}

package/dist/sensitive/Sensitive.unit.test.js

@@ -26,35 +26,82 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.testTypeSensitiveCodec = void 0;
 const E = __importStar(require("fp-ts/Either"));
 const t = __importStar(require("io-ts"));
+const O = __importStar(require("fp-ts/Option"));
+const td = __importStar(require("io-ts-types"));
 const TypeCodec_1 = require("../codec/TypeCodec");
 const Sensitive_1 = require("./Sensitive");
 exports.testTypeSensitiveCodec = TypeCodec_1.TypeCodec.fromDescriptor(t.type({
     strField: t.string,
-    intField: Sensitive_1.Sensitive.typeDescriptor(t.number),
+    intField: Sensitive_1.Sensitive.typeDescriptor(td.optionFromNullable(t.number)),
+    objectField: Sensitive_1.Sensitive.typeDescriptor(t.type({
+        int: t.number,
+        str: t.string,
+        optionalObj: Sensitive_1.Sensitive.typeDescriptor(td.optionFromNullable(t.type({
+            test: t.string,
+            test1: t.string,
+            testArray: Sensitive_1.Sensitive.typeDescriptor(t.array(td.optionFromNullable(t.string))),
+        }))),
+    })),
 }));
 describe('Sensitive', () => {
     describe('encode/decode sensitive values', () => {
         it('should encode sensitive typed data without the extra layer', () => {
             const testValueEncoded = {
                 strField: 'str',
-                intField: Sensitive_1.Sensitive.fromValue(123),
+                intField: Sensitive_1.Sensitive.fromValue(O.some(123)),
+                objectField: Sensitive_1.Sensitive.fromValue({
+                    str: 'test',
+                    int: 123,
+                    optionalObj: Sensitive_1.Sensitive.fromValue(O.some({
+                        test: 'test',
+                        test1: 'test1',
+                        testArray: Sensitive_1.Sensitive.fromValue([O.some('test')]),
+                    })),
+                }),
             };
             const result = exports.testTypeSensitiveCodec.encode(testValueEncoded);
             const expected = {
                 strField: 'str',
-                intField: 123,
+                intField: Sensitive_1.Sensitive.fromValue(123),
+                objectField: Sensitive_1.Sensitive.fromValue({
+                    int: 123,
+                    str: 'test',
+                    optionalObj: Sensitive_1.Sensitive.fromValue({
+                        test: 'test',
+                        test1: 'test1',
+                        testArray: Sensitive_1.Sensitive.fromValue(['test']),
+                    }),
+                }),
             };
             expect(result).toStrictEqual(expected);
         });
         it('should decode sensitive typed data without the extra layer', () => {
-            const testValueEncoded = {
+            const testValueDecoded = {
                 strField: 'str',
-                intField: 123,
+                intField: undefined,
+                objectField: {
+                    int: 123,
+                    str: 'test',
+                    optionalObj: {
+                        test: 'test',
+                        test1: 'test1',
+                        testArray: [],
+                    },
+                },
             };
-            const result = exports.testTypeSensitiveCodec.decode(testValueEncoded);
+            const result = exports.testTypeSensitiveCodec.decode(testValueDecoded);
             const expected = E.right({
                 strField: 'str',
-                intField: Sensitive_1.Sensitive.fromValue(123),
+                intField: Sensitive_1.Sensitive.fromValue(O.none),
+                objectField: Sensitive_1.Sensitive.fromValue({
+                    str: 'test',
+                    int: 123,
+                    optionalObj: Sensitive_1.Sensitive.fromValue(O.some({
+                        test: 'test',
+                        test1: 'test1',
+                        testArray: Sensitive_1.Sensitive.fromValue([]),
+                    })),
+                }),
             });
             expect(result).toStrictEqual(expected);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trayio/commons",
-  "version": "4.55.0",
+  "version": "4.56.0",
   "description": "Extensions to the standard/core libraries and basic features",
   "exports": {
     "./*": "./dist/*.js"

package/dist/codec/RedactValuesCodec.d.ts

@@ -1,12 +0,0 @@
-import * as E from 'fp-ts/lib/Either';
-import { Codec } from './Codec';
-export declare class RedactValuesCodec implements Codec<unknown> {
-    static instance: Codec<unknown>;
-    encode(value: unknown): unknown;
-    decode(value: unknown): E.Either<Error, unknown>;
-    private isObject;
-    private redactSensitiveValues;
-    private redactValuesFromArrayIfPresent;
-    private redactValuesFromObjectIfPresent;
-}
-//# sourceMappingURL=RedactValuesCodec.d.ts.map

package/dist/codec/RedactValuesCodec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RedactValuesCodec.d.ts","sourceRoot":"","sources":["../../src/codec/RedactValuesCodec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,kBAAkB,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,qBAAa,iBAAkB,YAAW,KAAK,CAAC,OAAO,CAAC;IACvD,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,OAAO,CAAC,CAA2B;IAE1D,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAI/B,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC;IAIhD,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,8BAA8B;IAStC,OAAO,CAAC,+BAA+B;CAiBvC"}

package/dist/codec/RedactValuesCodec.unit.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=RedactValuesCodec.unit.test.d.ts.map

package/dist/codec/RedactValuesCodec.unit.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RedactValuesCodec.unit.test.d.ts","sourceRoot":"","sources":["../../src/codec/RedactValuesCodec.unit.test.ts"],"names":[],"mappings":""}

package/dist/codec/RedactValuesCodec.unit.test.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Sensitive_1 = require("../sensitive/Sensitive");
-const Sensitive_unit_test_1 = require("../sensitive/Sensitive.unit.test");
-const CompositeCodec_1 = require("./CompositeCodec");
-const RedactValuesCodec_1 = require("./RedactValuesCodec");
-describe('redactValue Codec', () => {
-    it('should redact sensitive typed data', () => {
-        const value = {
-            password: Sensitive_1.Sensitive.fromValue('password'),
-            username: 'username',
-            address: {
-                city: 'city',
-                street: 'street',
-                number: 123,
-            },
-        };
-        const actualValue = RedactValuesCodec_1.RedactValuesCodec.instance.encode(value);
-        const expectedValue = {
-            password: Sensitive_1.Sensitive.fromValue('<REDACTED>'),
-            username: 'username',
-            address: {
-                city: 'city',
-                street: 'street',
-                number: 123,
-            },
-        };
-        expect(actualValue).toStrictEqual(expectedValue);
-    });
-    it('should redact sensitive typed data in nested arrays', () => {
-        const value = {
-            users: [
-                { password: Sensitive_1.Sensitive.fromValue('password'), username: 'username' },
-            ],
-        };
-        const actualValue = RedactValuesCodec_1.RedactValuesCodec.instance.encode(value);
-        const expectedValue = {
-            users: [
-                { password: Sensitive_1.Sensitive.fromValue('<REDACTED>'), username: 'username' },
-            ],
-        };
-        expect(actualValue).toStrictEqual(expectedValue);
-    });
-    it('should redact sensitive typed data in nested objects', () => {
-        const value = {
-            user: { password: Sensitive_1.Sensitive.fromValue('password'), username: 'username' },
-        };
-        const actualValue = RedactValuesCodec_1.RedactValuesCodec.instance.encode(value);
-        const expectedValue = {
-            user: {
-                password: Sensitive_1.Sensitive.fromValue('<REDACTED>'),
-                username: 'username',
-            },
-        };
-        expect(actualValue).toStrictEqual(expectedValue);
-    });
-    it('should redact sensitive typed data and type encode the value', () => {
-        const testValueEncoded = {
-            strField: 'str',
-            intField: Sensitive_1.Sensitive.fromValue(123),
-        };
-        const redactAndTypeDecode = CompositeCodec_1.CompositeCodec.fromCodecs(RedactValuesCodec_1.RedactValuesCodec.instance, Sensitive_unit_test_1.testTypeSensitiveCodec);
-        const result = redactAndTypeDecode.encode(testValueEncoded);
-        const expected = {
-            strField: 'str',
-            intField: '<REDACTED>',
-        };
-        expect(result).toStrictEqual(expected);
-    });
-});