@frontegg/entitlements-javascript-commons 1.0.0-alpha.4 → 1.0.0-alpha.5

package/dist/conditions/condition.evaluator.js

@@ -2,8 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createConditionEvaluator = void 0;
 const operation_resolver_1 = require("../operations/components/operation.resolver");
+const sanitizers_resolver_1 = require("../operations/components/sanitizers.resolver");
+function failingConditionEvaluator() {
+    return () => false;
+}
 function createConditionEvaluator(payload) {
-    const operation = (0, operation_resolver_1.useOperation)(payload.condition.op, payload.condition.value);
+    const sanitizer = (0, sanitizers_resolver_1.useSanitizer)(payload.condition.op);
+    if (!sanitizer) {
+        return failingConditionEvaluator();
+    }
+    const { isSanitized, sanitizedValue } = sanitizer(payload.condition.value);
+    if (!isSanitized || sanitizedValue === undefined) {
+        return failingConditionEvaluator();
+    }
+    const operation = (0, operation_resolver_1.useOperation)(payload.condition.op, sanitizedValue);
     return (attributes) => {
         const attributeKey = payload.condition.attribute;
         const value = attributes[attributeKey];

package/dist/conditions/condition.evaluator.js.map

@@ -1 +1 @@
-{"version":3,"file":"condition.evaluator.js","sourceRoot":"","sources":["../../src/conditions/condition.evaluator.ts"],"names":[],"mappings":";;;AACA,oFAA2E;AAQ3E,SAAgB,wBAAwB,CAAC,OAAwC;IAC/E,MAAM,SAAS,GAAG,IAAA,iCAAY,EAAC,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAE9E,OAAO,CAAC,UAAmC,EAAE,EAAE;QAC7C,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC;QACjD,MAAM,KAAK,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;QACvC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,KAAK,KAAK,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAErG,OAAO,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;IACrD,CAAC,CAAC;AACJ,CAAC;AAVD,4DAUC"}
+{"version":3,"file":"condition.evaluator.js","sourceRoot":"","sources":["../../src/conditions/condition.evaluator.ts"],"names":[],"mappings":";;;AACA,oFAA2E;AAC3E,sFAA4E;AAQ5E,SAAS,yBAAyB;IAChC,OAAO,GAAG,EAAE,CAAC,KAAK,CAAC;AACrB,CAAC;AAED,SAAgB,wBAAwB,CAAC,OAAwC;IAC/E,MAAM,SAAS,GAAG,IAAA,kCAAY,EAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;IACrD,IAAI,CAAC,SAAS,EAAE;QACd,OAAO,yBAAyB,EAAE,CAAC;KACpC;IAED,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,GAAG,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC3E,IAAI,CAAC,WAAW,IAAI,cAAc,KAAK,SAAS,EAAE;QAChD,OAAO,yBAAyB,EAAE,CAAC;KACpC;IAED,MAAM,SAAS,GAAG,IAAA,iCAAY,EAAC,OAAO,CAAC,SAAS,CAAC,EAAE,EAAE,cAAc,CAAC,CAAC;IAErE,OAAO,CAAC,UAAmC,EAAE,EAAE;QAC7C,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,CAAC,SAAS,CAAC;QACjD,MAAM,KAAK,GAAG,UAAU,CAAC,YAAY,CAAC,CAAC;QACvC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,KAAK,KAAK,SAAS,IAAI,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;QAErG,OAAO,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;IACrD,CAAC,CAAC;AACJ,CAAC;AApBD,4DAoBC"}

package/dist/conditions/types.d.ts

@@ -1,7 +1,7 @@
-import { ConditionValue, OperationEnum } from '../operations/types';
+import { OperationEnum, RawConditionValue } from '../operations/types';
 export interface Condition {
     attribute: string;
     negate: boolean;
     op: OperationEnum;
-    value: ConditionValue;
+    value: RawConditionValue;
 }

package/dist/operations/boolean/index.d.ts

@@ -1,3 +1,4 @@
 import { OperationsMapper } from '../types';
 export * from './operations';
+export * from './sanitizers';
 export declare const BooleanOperationsMapper: OperationsMapper;

package/dist/operations/boolean/index.js

@@ -18,6 +18,7 @@ exports.BooleanOperationsMapper = void 0;
 const types_1 = require("../types");
 const operations_1 = require("./operations");
 __exportStar(require("./operations"), exports);
+__exportStar(require("./sanitizers"), exports);
 exports.BooleanOperationsMapper = {
     [types_1.OperationEnum.Is]: (value) => (0, operations_1.useIsOperation)(value),
 };

package/dist/operations/boolean/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/operations/boolean/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,oCAA2D;AAC3D,6CAA8C;AAG9C,+CAA6B;AAEhB,QAAA,uBAAuB,GAAqB;IACvD,CAAC,qBAAa,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,2BAAc,EAAC,KAAgC,CAAC;CAChF,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/operations/boolean/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,oCAA2D;AAC3D,6CAA8C;AAG9C,+CAA6B;AAC7B,+CAA6B;AAEhB,QAAA,uBAAuB,GAAqB;IACvD,CAAC,qBAAa,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,2BAAc,EAAC,KAAgC,CAAC;CAChF,CAAC"}

package/dist/operations/boolean/sanitizers.d.ts

@@ -0,0 +1,4 @@
+import { Sanitizer, SanitizersMapper } from '../types';
+import { BooleanOperationPayload } from './types';
+export declare const singleBooleanSanitizer: Sanitizer<BooleanOperationPayload>;
+export declare const BooleanSanitizersMapper: SanitizersMapper<BooleanOperationPayload>;

package/dist/operations/boolean/sanitizers.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanSanitizersMapper = exports.singleBooleanSanitizer = void 0;
+const types_1 = require("../types");
+const isBoolean = (value) => typeof value === 'boolean';
+const singleBooleanSanitizer = (value) => {
+    const sanitizedValue = value.boolean !== undefined && isBoolean(value.boolean) ? { boolean: value.boolean } : undefined;
+    return {
+        isSanitized: !!sanitizedValue,
+        sanitizedValue,
+    };
+};
+exports.singleBooleanSanitizer = singleBooleanSanitizer;
+exports.BooleanSanitizersMapper = {
+    [types_1.OperationEnum.Is]: exports.singleBooleanSanitizer,
+};
+//# sourceMappingURL=sanitizers.js.map

package/dist/operations/boolean/sanitizers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizers.js","sourceRoot":"","sources":["../../../src/operations/boolean/sanitizers.ts"],"names":[],"mappings":";;;AAAA,oCAAyF;AAGzF,MAAM,SAAS,GAAG,CAAC,KAAc,EAAoB,EAAE,CAAC,OAAO,KAAK,KAAK,SAAS,CAAC;AAE5E,MAAM,sBAAsB,GAAuC,CAAC,KAAwB,EAAE,EAAE;IACrG,MAAM,cAAc,GAClB,KAAK,CAAC,OAAO,KAAK,SAAS,IAAI,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAEnG,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,cAAc;QAC7B,cAAc;KACf,CAAC;AACJ,CAAC,CAAC;AARW,QAAA,sBAAsB,0BAQjC;AAEW,QAAA,uBAAuB,GAA8C;IAChF,CAAC,qBAAa,CAAC,EAAE,CAAC,EAAE,8BAAsB;CAC3C,CAAC"}

package/dist/operations/components/sanitizers.resolver.d.ts

@@ -0,0 +1,2 @@
+import { ConditionValue, OperationEnum, Sanitizer } from '../types';
+export declare function useSanitizer(operation: OperationEnum): Sanitizer<ConditionValue> | undefined;

package/dist/operations/components/sanitizers.resolver.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSanitizer = void 0;
+const boolean_1 = require("../boolean");
+const sanitizers_1 = require("../string/sanitizers");
+const sanitizers_2 = require("../date/sanitizers");
+const numeric_1 = require("../numeric");
+const SanitizersMapper = {
+    ...sanitizers_1.StringSanitizersMapper,
+    ...numeric_1.NumericSanitizersMapper,
+    ...sanitizers_2.DateSanitizersMapper,
+    ...boolean_1.BooleanSanitizersMapper,
+};
+function useSanitizer(operation) {
+    return SanitizersMapper[operation];
+}
+exports.useSanitizer = useSanitizer;
+//# sourceMappingURL=sanitizers.resolver.js.map

package/dist/operations/components/sanitizers.resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizers.resolver.js","sourceRoot":"","sources":["../../../src/operations/components/sanitizers.resolver.ts"],"names":[],"mappings":";;;AACA,wCAAqD;AACrD,qDAA8D;AAC9D,mDAA0D;AAC1D,wCAAqD;AAErD,MAAM,gBAAgB,GAAqC;IACzD,GAAG,mCAAsB;IACzB,GAAG,iCAAuB;IAC1B,GAAG,iCAAoB;IACvB,GAAG,iCAAuB;CAC3B,CAAC;AAEF,SAAgB,YAAY,CAAC,SAAwB;IACnD,OAAO,gBAAgB,CAAC,SAAS,CAAC,CAAC;AACrC,CAAC;AAFD,oCAEC"}

package/dist/operations/date/sanitizers.d.ts

@@ -0,0 +1,5 @@
+import { Sanitizer, SanitizersMapper } from '../types';
+import { BetweenDateOperationPayload, DateOperationPayload, SingleDateOperationPayload } from './types';
+export declare const sanitizeSingleDate: Sanitizer<SingleDateOperationPayload>;
+export declare const sanitizeDateRange: Sanitizer<BetweenDateOperationPayload>;
+export declare const DateSanitizersMapper: SanitizersMapper<DateOperationPayload>;

package/dist/operations/date/sanitizers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateSanitizersMapper = exports.sanitizeDateRange = exports.sanitizeSingleDate = void 0;
+const types_1 = require("../types");
+const sanitizeSingleDate = (value) => {
+    const sanitizedValue = value.date ? { date: value.date } : undefined;
+    return {
+        isSanitized: !!sanitizedValue,
+        sanitizedValue,
+    };
+};
+exports.sanitizeSingleDate = sanitizeSingleDate;
+const sanitizeDateRange = (value) => {
+    const sanitizedValue = value.start && value.end ? { start: value.start, end: value.end } : undefined;
+    return {
+        isSanitized: !!sanitizedValue,
+        sanitizedValue,
+    };
+};
+exports.sanitizeDateRange = sanitizeDateRange;
+exports.DateSanitizersMapper = {
+    [types_1.OperationEnum.On]: exports.sanitizeSingleDate,
+    [types_1.OperationEnum.OnOrAfter]: exports.sanitizeDateRange,
+    [types_1.OperationEnum.OnOrBefore]: exports.sanitizeSingleDate,
+    [types_1.OperationEnum.BetweenDate]: exports.sanitizeSingleDate,
+};
+//# sourceMappingURL=sanitizers.js.map

package/dist/operations/date/sanitizers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizers.js","sourceRoot":"","sources":["../../../src/operations/date/sanitizers.ts"],"names":[],"mappings":";;;AAAA,oCAAsE;AAG/D,MAAM,kBAAkB,GAA0C,CAAC,KAAK,EAAE,EAAE;IACjF,MAAM,cAAc,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAY,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAE7E,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,cAAc;QAC7B,cAAc;KACf,CAAC;AACJ,CAAC,CAAC;AAPW,QAAA,kBAAkB,sBAO7B;AAEK,MAAM,iBAAiB,GAA2C,CAAC,KAAK,EAAE,EAAE;IACjF,MAAM,cAAc,GAAG,KAAK,CAAC,KAAK,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAa,EAAE,GAAG,EAAE,KAAK,CAAC,GAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAErH,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,cAAc;QAC7B,cAAc;KACf,CAAC;AACJ,CAAC,CAAC;AAPW,QAAA,iBAAiB,qBAO5B;AAEW,QAAA,oBAAoB,GAA2C;IAC1E,CAAC,qBAAa,CAAC,EAAE,CAAC,EAAE,0BAAkB;IACtC,CAAC,qBAAa,CAAC,SAAS,CAAC,EAAE,yBAAiB;IAC5C,CAAC,qBAAa,CAAC,UAAU,CAAC,EAAE,0BAAkB;IAC9C,CAAC,qBAAa,CAAC,WAAW,CAAC,EAAE,0BAAkB;CAChD,CAAC"}

package/dist/operations/numeric/index.d.ts

@@ -1,4 +1,5 @@
 import { OperationsMapper } from '../types';
 export * from './operations';
+export * from './sanitizers';
 export * from './types';
 export declare const NumericOperationsMapper: OperationsMapper;

package/dist/operations/numeric/index.js

@@ -18,6 +18,7 @@ exports.NumericOperationsMapper = void 0;
 const types_1 = require("../types");
 const operations_1 = require("./operations");
 __exportStar(require("./operations"), exports);
+__exportStar(require("./sanitizers"), exports);
 __exportStar(require("./types"), exports);
 exports.NumericOperationsMapper = {
     [types_1.OperationEnum.Equal]: (value) => (0, operations_1.useEqualsOperation)(value),

package/dist/operations/numeric/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/operations/numeric/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,oCAA2D;AAC3D,6CAOsB;AAGtB,+CAA6B;AAC7B,0CAAwB;AAEX,QAAA,uBAAuB,GAAqB;IACvD,CAAC,qBAAa,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,+BAAkB,EAAC,KAAsC,CAAC;IAC5F,CAAC,qBAAa,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,oCAAuB,EAAC,KAAsC,CAAC;IACvG,CAAC,qBAAa,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,yCAA4B,EAAC,KAAsC,CAAC;IACjH,CAAC,qBAAa,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,mCAAsB,EAAC,KAAsC,CAAC;IACrG,CAAC,qBAAa,CAAC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,wCAA2B,EAAC,KAAsC,CAAC;IAC/G,CAAC,qBAAa,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,uCAA0B,EAAC,KAAuC,CAAC;CAC/G,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/operations/numeric/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;AAAA,oCAA2D;AAC3D,6CAOsB;AAGtB,+CAA6B;AAC7B,+CAA6B;AAC7B,0CAAwB;AAEX,QAAA,uBAAuB,GAAqB;IACvD,CAAC,qBAAa,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,+BAAkB,EAAC,KAAsC,CAAC;IAC5F,CAAC,qBAAa,CAAC,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,oCAAuB,EAAC,KAAsC,CAAC;IACvG,CAAC,qBAAa,CAAC,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,yCAA4B,EAAC,KAAsC,CAAC;IACjH,CAAC,qBAAa,CAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,mCAAsB,EAAC,KAAsC,CAAC;IACrG,CAAC,qBAAa,CAAC,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,wCAA2B,EAAC,KAAsC,CAAC;IAC/G,CAAC,qBAAa,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAA,uCAA0B,EAAC,KAAuC,CAAC;CAC/G,CAAC"}

package/dist/operations/numeric/sanitizers.d.ts

@@ -0,0 +1,5 @@
+import { Sanitizer, SanitizersMapper } from '../types';
+import { BetweenNumericOperationPayload, NumericOperationPayload, SingleNumericOperationPayload } from './types';
+export declare const sanitizeSingleNumber: Sanitizer<SingleNumericOperationPayload>;
+export declare const sanitizeNumericRange: Sanitizer<BetweenNumericOperationPayload>;
+export declare const NumericSanitizersMapper: SanitizersMapper<NumericOperationPayload>;

package/dist/operations/numeric/sanitizers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumericSanitizersMapper = exports.sanitizeNumericRange = exports.sanitizeSingleNumber = void 0;
+const types_1 = require("../types");
+const isNumber = (value) => typeof value === 'number';
+const sanitizeSingleNumber = (value) => {
+    const sanitizedValue = value.number !== undefined && isNumber(value.number) ? { number: value.number } : undefined;
+    return {
+        isSanitized: !!sanitizedValue,
+        sanitizedValue,
+    };
+};
+exports.sanitizeSingleNumber = sanitizeSingleNumber;
+const sanitizeNumericRange = (value) => {
+    const sanitizedValue = value.start !== undefined && value.end !== undefined && isNumber(value.start) && isNumber(value.end)
+        ? { start: value.start, end: value.end }
+        : undefined;
+    return {
+        isSanitized: !!sanitizedValue,
+        sanitizedValue,
+    };
+};
+exports.sanitizeNumericRange = sanitizeNumericRange;
+exports.NumericSanitizersMapper = {
+    [types_1.OperationEnum.Equal]: exports.sanitizeSingleNumber,
+    [types_1.OperationEnum.GreaterThan]: exports.sanitizeNumericRange,
+    [types_1.OperationEnum.GreaterThanEqual]: exports.sanitizeSingleNumber,
+    [types_1.OperationEnum.LesserThan]: exports.sanitizeSingleNumber,
+    [types_1.OperationEnum.LesserThanEqual]: exports.sanitizeNumericRange,
+    [types_1.OperationEnum.BetweenNumeric]: exports.sanitizeNumericRange,
+};
+//# sourceMappingURL=sanitizers.js.map

package/dist/operations/numeric/sanitizers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizers.js","sourceRoot":"","sources":["../../../src/operations/numeric/sanitizers.ts"],"names":[],"mappings":";;;AAAA,oCAAsE;AAGtE,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAmB,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;AAEzE,MAAM,oBAAoB,GAA6C,CAAC,KAAK,EAAE,EAAE;IACtF,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAEnH,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,cAAc;QAC7B,cAAc;KACf,CAAC;AACJ,CAAC,CAAC;AAPW,QAAA,oBAAoB,wBAO/B;AAEK,MAAM,oBAAoB,GAA8C,CAAC,KAAK,EAAE,EAAE;IACvF,MAAM,cAAc,GAClB,KAAK,CAAC,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,KAAK,SAAS,IAAI,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC;QAClG,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,EAAE;QACxC,CAAC,CAAC,SAAS,CAAC;IAEhB,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,cAAc;QAC7B,cAAc;KACf,CAAC;AACJ,CAAC,CAAC;AAVW,QAAA,oBAAoB,wBAU/B;AAEW,QAAA,uBAAuB,GAA8C;IAChF,CAAC,qBAAa,CAAC,KAAK,CAAC,EAAE,4BAAoB;IAC3C,CAAC,qBAAa,CAAC,WAAW,CAAC,EAAE,4BAAoB;IACjD,CAAC,qBAAa,CAAC,gBAAgB,CAAC,EAAE,4BAAoB;IACtD,CAAC,qBAAa,CAAC,UAAU,CAAC,EAAE,4BAAoB;IAChD,CAAC,qBAAa,CAAC,eAAe,CAAC,EAAE,4BAAoB;IACrD,CAAC,qBAAa,CAAC,cAAc,CAAC,EAAE,4BAAoB;CACrD,CAAC"}

package/dist/operations/string/sanitizers.d.ts

@@ -0,0 +1,5 @@
+import { Sanitizer, SanitizersMapper } from '../types';
+import { ListStringOperationPayload, SingleStringOperationPayload, StringOperationPayload } from './types';
+export declare const sanitizeSingleString: Sanitizer<SingleStringOperationPayload>;
+export declare const sanitizeListString: Sanitizer<ListStringOperationPayload>;
+export declare const StringSanitizersMapper: SanitizersMapper<StringOperationPayload>;

package/dist/operations/string/sanitizers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringSanitizersMapper = exports.sanitizeListString = exports.sanitizeSingleString = void 0;
+const types_1 = require("../types");
+const isString = (value) => typeof value === 'string';
+const sanitizeSingleString = (value) => {
+    const sanitizedValue = value.string !== undefined && isString(value.string) ? { string: value.string } : undefined;
+    return {
+        isSanitized: !!sanitizedValue,
+        sanitizedValue,
+    };
+};
+exports.sanitizeSingleString = sanitizeSingleString;
+const sanitizeListString = (value) => {
+    const sanitizedValue = value.list !== undefined && value.list.every((str) => isString(str))
+        ? { list: value.list }
+        : undefined;
+    return {
+        isSanitized: !!sanitizedValue,
+        sanitizedValue,
+    };
+};
+exports.sanitizeListString = sanitizeListString;
+exports.StringSanitizersMapper = {
+    [types_1.OperationEnum.Matches]: exports.sanitizeSingleString,
+    [types_1.OperationEnum.Contains]: exports.sanitizeListString,
+    [types_1.OperationEnum.StartsWith]: exports.sanitizeSingleString,
+    [types_1.OperationEnum.EndsWith]: exports.sanitizeSingleString,
+    [types_1.OperationEnum.InList]: exports.sanitizeListString,
+};
+//# sourceMappingURL=sanitizers.js.map

package/dist/operations/string/sanitizers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizers.js","sourceRoot":"","sources":["../../../src/operations/string/sanitizers.ts"],"names":[],"mappings":";;;AAAA,oCAAsE;AAGtE,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAmB,EAAE,CAAC,OAAO,KAAK,KAAK,QAAQ,CAAC;AAEzE,MAAM,oBAAoB,GAA4C,CAAC,KAAK,EAAE,EAAE;IACrF,MAAM,cAAc,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,IAAI,QAAQ,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAEnH,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,cAAc;QAC7B,cAAc;KACf,CAAC;AACJ,CAAC,CAAC;AAPW,QAAA,oBAAoB,wBAO/B;AAEK,MAAM,kBAAkB,GAA0C,CAAC,KAAK,EAAE,EAAE;IACjF,MAAM,cAAc,GAClB,KAAK,CAAC,IAAI,KAAK,SAAS,IAAgB,KAAK,CAAC,IAAK,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC/E,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,IAAgB,EAAE;QAClC,CAAC,CAAC,SAAS,CAAC;IAEhB,OAAO;QACL,WAAW,EAAE,CAAC,CAAC,cAAc;QAC7B,cAAc;KACf,CAAC;AACJ,CAAC,CAAC;AAVW,QAAA,kBAAkB,sBAU7B;AAEW,QAAA,sBAAsB,GAA6C;IAC9E,CAAC,qBAAa,CAAC,OAAO,CAAC,EAAE,4BAAoB;IAC7C,CAAC,qBAAa,CAAC,QAAQ,CAAC,EAAE,0BAAkB;IAC5C,CAAC,qBAAa,CAAC,UAAU,CAAC,EAAE,4BAAoB;IAChD,CAAC,qBAAa,CAAC,QAAQ,CAAC,EAAE,4BAAoB;IAC9C,CAAC,qBAAa,CAAC,MAAM,CAAC,EAAE,0BAAkB;CAC3C,CAAC"}

package/dist/operations/types/index.d.ts

@@ -6,10 +6,19 @@ import { BooleanOperationPayload } from '../boolean/types';
 export interface OperationResult {
     isValid: boolean;
 }
+export type RawConditionValue = Record<string, unknown>;
 export type ConditionValue = StringOperationPayload | NumericOperationPayload | DateOperationPayload | BooleanOperationPayload;
 export type OperationHandler = (attribute: any) => OperationResult;
 export type OperationContextEnricher = (value: ConditionValue) => OperationHandler;
 export type OperationsMapper = {
     [key in OperationEnum]?: OperationContextEnricher;
 };
+export interface SanitizationResult<T extends ConditionValue> {
+    isSanitized: boolean;
+    sanitizedValue: T | undefined;
+}
+export type Sanitizer<T extends ConditionValue> = (value: RawConditionValue) => SanitizationResult<T>;
+export type SanitizersMapper<T extends ConditionValue> = {
+    [key in OperationEnum]?: Sanitizer<T>;
+};
 export * from './operation.enum';

package/dist/operations/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/operations/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAqBA,mDAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/operations/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AA6BA,mDAAiC"}

package/docs/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [1.0.0-alpha.5](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0-alpha.4...v-1.0.0-alpha.5) (2023-10-10)
+
+
+### Features
+
+* **sanitizers:** add value sanitizers ([#12](https://github.com/frontegg/entitlements-javascript-commons/issues/12)) ([1decf2c](https://github.com/frontegg/entitlements-javascript-commons/commit/1decf2c01e0a86055bc856db5ff115a2318f1c59))
+
 # [1.0.0-alpha.4](https://github.com/frontegg/entitlements-javascript-commons/compare/v-1.0.0-alpha.3...v-1.0.0-alpha.4) (2023-10-10)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frontegg/entitlements-javascript-commons",
-  "version": "1.0.0-alpha.4",
+  "version": "1.0.0-alpha.5",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/conditions/condition.evaluator.ts

@@ -1,5 +1,6 @@
 import { Condition } from './types';
 import { useOperation } from '../operations/components/operation.resolver';
+import { useSanitizer } from '../operations/components/sanitizers.resolver';
 
 export interface CreateConditionEvaluatorPayload {
   condition: Condition;
@@ -7,8 +8,22 @@ export interface CreateConditionEvaluatorPayload {
 
 export type ConditionEvaluator = (attributes: Record<string, unknown>) => boolean;
 
+function failingConditionEvaluator(): ConditionEvaluator {
+  return () => false;
+}
+
 export function createConditionEvaluator(payload: CreateConditionEvaluatorPayload): ConditionEvaluator {
-  const operation = useOperation(payload.condition.op, payload.condition.value);
+  const sanitizer = useSanitizer(payload.condition.op);
+  if (!sanitizer) {
+    return failingConditionEvaluator();
+  }
+
+  const { isSanitized, sanitizedValue } = sanitizer(payload.condition.value);
+  if (!isSanitized || sanitizedValue === undefined) {
+    return failingConditionEvaluator();
+  }
+
+  const operation = useOperation(payload.condition.op, sanitizedValue);
 
   return (attributes: Record<string, unknown>) => {
     const attributeKey = payload.condition.attribute;

package/src/conditions/types.ts

@@ -1,8 +1,8 @@
-import { ConditionValue, OperationEnum } from '../operations/types';
+import { OperationEnum, RawConditionValue } from '../operations/types';
 
 export interface Condition {
   attribute: string;
   negate: boolean;
   op: OperationEnum;
-  value: ConditionValue;
+  value: RawConditionValue;
 }

package/src/operations/boolean/index.ts

@@ -3,6 +3,7 @@ import { useIsOperation } from './operations';
 import { BooleanOperationPayload } from './types';
 
 export * from './operations';
+export * from './sanitizers';
 
 export const BooleanOperationsMapper: OperationsMapper = {
   [OperationEnum.Is]: (value) => useIsOperation(value as BooleanOperationPayload),

package/src/operations/boolean/sanitizers.ts

@@ -0,0 +1,18 @@
+import { OperationEnum, RawConditionValue, Sanitizer, SanitizersMapper } from '../types';
+import { BooleanOperationPayload } from './types';
+
+const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';
+
+export const singleBooleanSanitizer: Sanitizer<BooleanOperationPayload> = (value: RawConditionValue) => {
+  const sanitizedValue =
+    value.boolean !== undefined && isBoolean(value.boolean) ? { boolean: value.boolean } : undefined;
+
+  return {
+    isSanitized: !!sanitizedValue,
+    sanitizedValue,
+  };
+};
+
+export const BooleanSanitizersMapper: SanitizersMapper<BooleanOperationPayload> = {
+  [OperationEnum.Is]: singleBooleanSanitizer,
+};

package/src/operations/boolean/{operations.spec.ts → tests/operations.spec.ts}

@@ -1,5 +1,5 @@
 import { fc, test } from '@fast-check/jest';
-import { useIsOperation } from './operations';
+import { useIsOperation } from '../operations';
 
 describe('Boolean operations', () => {
   test.prop([fc.boolean(), fc.boolean()], { verbose: true })(

package/src/operations/boolean/tests/sanitizers.spec.ts

@@ -0,0 +1,22 @@
+import { fc, test } from '@fast-check/jest';
+import { singleBooleanSanitizer } from '../sanitizers';
+
+describe('Boolean sanitizers', () => {
+  test.prop([fc.record({ boolean: fc.boolean() })], { verbose: true })(
+    'should return sanitized when boolean value exists',
+    (value) => {
+      const sanitizationResult = singleBooleanSanitizer(value);
+
+      expect(sanitizationResult.isSanitized).toBe(true);
+      expect(typeof sanitizationResult.sanitizedValue?.boolean).toBe('boolean');
+      expect(sanitizationResult.sanitizedValue?.boolean).toBe(value.boolean);
+    },
+  );
+
+  test.prop([fc.object()], { verbose: true })('should return undefined when no boolean value exists', (value) => {
+    const sanitizationResult = singleBooleanSanitizer(value);
+
+    expect(sanitizationResult.isSanitized).toBe(false);
+    expect(sanitizationResult.sanitizedValue).toBeUndefined();
+  });
+});

package/src/operations/components/sanitizers.resolver.ts

@@ -0,0 +1,16 @@
+import { ConditionValue, OperationEnum, Sanitizer, SanitizersMapper } from '../types';
+import { BooleanSanitizersMapper } from '../boolean';
+import { StringSanitizersMapper } from '../string/sanitizers';
+import { DateSanitizersMapper } from '../date/sanitizers';
+import { NumericSanitizersMapper } from '../numeric';
+
+const SanitizersMapper: SanitizersMapper<ConditionValue> = {
+  ...StringSanitizersMapper,
+  ...NumericSanitizersMapper,
+  ...DateSanitizersMapper,
+  ...BooleanSanitizersMapper,
+};
+
+export function useSanitizer(operation: OperationEnum): Sanitizer<ConditionValue> | undefined {
+  return SanitizersMapper[operation];
+}

package/src/operations/components/tests/sanitizers.resolver.spec.ts

@@ -0,0 +1,14 @@
+import { useSanitizer } from '../sanitizers.resolver';
+import { OperationEnum } from '../../types';
+
+describe('SanitizerResolver', () => {
+  it('should return undefined when operation is not supported', () => {
+    const sanitizer = useSanitizer('not supported' as any);
+    expect(sanitizer).toEqual(undefined);
+  });
+
+  it('should return sanitizer when operation is supported', () => {
+    const sanitizer = useSanitizer(OperationEnum.On);
+    expect(sanitizer).toEqual(expect.any(Function));
+  });
+});

package/src/operations/date/sanitizers.ts

@@ -0,0 +1,27 @@
+import { OperationEnum, Sanitizer, SanitizersMapper } from '../types';
+import { BetweenDateOperationPayload, DateOperationPayload, SingleDateOperationPayload } from './types';
+
+export const sanitizeSingleDate: Sanitizer<SingleDateOperationPayload> = (value) => {
+  const sanitizedValue = value.date ? { date: value.date as Date } : undefined;
+
+  return {
+    isSanitized: !!sanitizedValue,
+    sanitizedValue,
+  };
+};
+
+export const sanitizeDateRange: Sanitizer<BetweenDateOperationPayload> = (value) => {
+  const sanitizedValue = value.start && value.end ? { start: value.start as Date, end: value.end as Date } : undefined;
+
+  return {
+    isSanitized: !!sanitizedValue,
+    sanitizedValue,
+  };
+};
+
+export const DateSanitizersMapper: SanitizersMapper<DateOperationPayload> = {
+  [OperationEnum.On]: sanitizeSingleDate,
+  [OperationEnum.OnOrAfter]: sanitizeDateRange,
+  [OperationEnum.OnOrBefore]: sanitizeSingleDate,
+  [OperationEnum.BetweenDate]: sanitizeSingleDate,
+};

package/src/operations/date/{operations.spec.ts → tests/operations.spec.ts}

@@ -3,7 +3,7 @@ import {
   useDateOnOperation,
   useDateOnOrAfterOperation,
   useDateOnOrBeforeOperation,
-} from './index';
+} from '../index';
 import { fc, test } from '@fast-check/jest';
 
 describe('Date operations', () => {

package/src/operations/date/tests/sanitizers.spec.ts

@@ -0,0 +1,43 @@
+import { fc, test } from '@fast-check/jest';
+import { sanitizeDateRange, sanitizeSingleDate } from '../sanitizers';
+
+describe('Date sanitizers', () => {
+  test.prop([fc.record({ date: fc.date() })], { verbose: true })(
+    'should return sanitized when date value exists',
+    (value) => {
+      const sanitizationResult = sanitizeSingleDate(value);
+
+      expect(sanitizationResult.isSanitized).toBe(true);
+      expect(typeof sanitizationResult.sanitizedValue).toBe('object');
+      expect(sanitizationResult.sanitizedValue).toEqual({ date: value.date });
+    },
+  );
+
+  test.prop([fc.object()], { verbose: true })('should fail sanitization when date value does not exist', (value) => {
+    const sanitizationResult = sanitizeSingleDate(value);
+
+    expect(sanitizationResult.isSanitized).toBe(false);
+    expect(sanitizationResult.sanitizedValue).toBeUndefined();
+  });
+
+  test.prop([fc.record({ start: fc.date(), end: fc.date() })], { verbose: true })(
+    'should return sanitized when start and end values exist',
+    (value) => {
+      const sanitizationResult = sanitizeDateRange(value);
+
+      expect(sanitizationResult.isSanitized).toBe(true);
+      expect(typeof sanitizationResult.sanitizedValue).toBe('object');
+      expect(sanitizationResult.sanitizedValue).toEqual({ start: value.start, end: value.end });
+    },
+  );
+
+  test.prop([fc.object()], { verbose: true })(
+    'should fail sanitization when start and end values do not exist',
+    (value) => {
+      const sanitizationResult = sanitizeDateRange(value);
+
+      expect(sanitizationResult.isSanitized).toBe(false);
+      expect(sanitizationResult.sanitizedValue).toBeUndefined();
+    },
+  );
+});

package/src/operations/numeric/index.ts

@@ -10,6 +10,7 @@ import {
 import { BetweenNumericOperationPayload, SingleNumericOperationPayload } from './types';
 
 export * from './operations';
+export * from './sanitizers';
 export * from './types';
 
 export const NumericOperationsMapper: OperationsMapper = {

package/src/operations/numeric/sanitizers.ts

@@ -0,0 +1,34 @@
+import { OperationEnum, Sanitizer, SanitizersMapper } from '../types';
+import { BetweenNumericOperationPayload, NumericOperationPayload, SingleNumericOperationPayload } from './types';
+
+const isNumber = (value: unknown): value is number => typeof value === 'number';
+
+export const sanitizeSingleNumber: Sanitizer<SingleNumericOperationPayload> = (value) => {
+  const sanitizedValue = value.number !== undefined && isNumber(value.number) ? { number: value.number } : undefined;
+
+  return {
+    isSanitized: !!sanitizedValue,
+    sanitizedValue,
+  };
+};
+
+export const sanitizeNumericRange: Sanitizer<BetweenNumericOperationPayload> = (value) => {
+  const sanitizedValue =
+    value.start !== undefined && value.end !== undefined && isNumber(value.start) && isNumber(value.end)
+      ? { start: value.start, end: value.end }
+      : undefined;
+
+  return {
+    isSanitized: !!sanitizedValue,
+    sanitizedValue,
+  };
+};
+
+export const NumericSanitizersMapper: SanitizersMapper<NumericOperationPayload> = {
+  [OperationEnum.Equal]: sanitizeSingleNumber,
+  [OperationEnum.GreaterThan]: sanitizeNumericRange,
+  [OperationEnum.GreaterThanEqual]: sanitizeSingleNumber,
+  [OperationEnum.LesserThan]: sanitizeSingleNumber,
+  [OperationEnum.LesserThanEqual]: sanitizeNumericRange,
+  [OperationEnum.BetweenNumeric]: sanitizeNumericRange,
+};

package/src/operations/numeric/tests/sanitizers.spec.ts

@@ -0,0 +1,44 @@
+import { fc, test } from '@fast-check/jest';
+import { sanitizeNumericRange, sanitizeSingleNumber } from '../sanitizers';
+
+describe('Numeric sanitizers', () => {
+  test.prop([fc.record({ number: fc.integer() })], { verbose: true })('should return sanitized number', (value) => {
+    const sanitizationResult = sanitizeSingleNumber(value);
+
+    expect(sanitizationResult.isSanitized).toBe(true);
+    expect(typeof sanitizationResult.sanitizedValue?.number).toBe('number');
+    expect(sanitizationResult.sanitizedValue).toEqual({ number: value.number });
+  });
+
+  test.prop([fc.object()], { verbose: true })(
+    'should not return sanitization values when number does not exist in value',
+    (value) => {
+      const sanitizationResult = sanitizeSingleNumber(value);
+
+      expect(sanitizationResult.isSanitized).toBe(false);
+      expect(sanitizationResult.sanitizedValue).toBeUndefined();
+    },
+  );
+
+  test.prop([fc.record({ start: fc.integer(), end: fc.integer() })], { verbose: true })(
+    'should return sanitized range',
+    (value) => {
+      const sanitizationResult = sanitizeNumericRange(value);
+
+      expect(sanitizationResult.isSanitized).toBe(true);
+      expect(typeof sanitizationResult.sanitizedValue?.start).toBe('number');
+      expect(typeof sanitizationResult.sanitizedValue?.end).toBe('number');
+      expect(sanitizationResult.sanitizedValue).toEqual({ start: value.start, end: value.end });
+    },
+  );
+
+  test.prop([fc.object()], { verbose: true })(
+    'should not return sanitization values when start or end does not exist in value',
+    (value) => {
+      const sanitizationResult = sanitizeNumericRange(value);
+
+      expect(sanitizationResult.isSanitized).toBe(false);
+      expect(sanitizationResult.sanitizedValue).toBeUndefined();
+    },
+  );
+});

package/src/operations/string/sanitizers.ts

@@ -0,0 +1,33 @@
+import { OperationEnum, Sanitizer, SanitizersMapper } from '../types';
+import { ListStringOperationPayload, SingleStringOperationPayload, StringOperationPayload } from './types';
+
+const isString = (value: unknown): value is string => typeof value === 'string';
+
+export const sanitizeSingleString: Sanitizer<SingleStringOperationPayload> = (value) => {
+  const sanitizedValue = value.string !== undefined && isString(value.string) ? { string: value.string } : undefined;
+
+  return {
+    isSanitized: !!sanitizedValue,
+    sanitizedValue,
+  };
+};
+
+export const sanitizeListString: Sanitizer<ListStringOperationPayload> = (value) => {
+  const sanitizedValue =
+    value.list !== undefined && (<unknown[]>value.list).every((str) => isString(str))
+      ? { list: value.list as string[] }
+      : undefined;
+
+  return {
+    isSanitized: !!sanitizedValue,
+    sanitizedValue,
+  };
+};
+
+export const StringSanitizersMapper: SanitizersMapper<StringOperationPayload> = {
+  [OperationEnum.Matches]: sanitizeSingleString,
+  [OperationEnum.Contains]: sanitizeListString,
+  [OperationEnum.StartsWith]: sanitizeSingleString,
+  [OperationEnum.EndsWith]: sanitizeSingleString,
+  [OperationEnum.InList]: sanitizeListString,
+};

package/src/operations/string/tests/sanitizers.spec.ts

@@ -0,0 +1,45 @@
+import { fc, test } from '@fast-check/jest';
+import { sanitizeListString, sanitizeSingleString } from '../sanitizers';
+
+describe('String sanitizers', () => {
+  test.prop([fc.record({ list: fc.array(fc.string()) })], { verbose: true })(
+    'should return sanitized strings list',
+    (value) => {
+      const sanitizationResult = sanitizeListString(value);
+
+      expect(sanitizationResult.isSanitized).toBe(true);
+      expect(sanitizationResult.sanitizedValue?.list).toEqual(value.list);
+    },
+  );
+
+  test.prop([fc.object()], { verbose: true })(
+    'should not return sanitized strings list when list property does not exist',
+    (value) => {
+      const sanitizationResult = sanitizeListString(value);
+
+      expect(sanitizationResult.isSanitized).toBe(false);
+      expect(sanitizationResult.sanitizedValue).toBeUndefined();
+    },
+  );
+
+  test.prop([fc.record({ string: fc.string() })], { verbose: true })(
+    'should sanitized string string property exists',
+    (value) => {
+      const sanitizationResult = sanitizeSingleString(value);
+
+      expect(sanitizationResult.isSanitized).toBe(true);
+      expect(typeof sanitizationResult.sanitizedValue?.string).toEqual('string');
+      expect(sanitizationResult.sanitizedValue?.string).toEqual(value.string);
+    },
+  );
+
+  test.prop([fc.object()], { verbose: true })(
+    'should not return sanitized string when string property does not exist',
+    (value) => {
+      const sanitizationResult = sanitizeSingleString(value);
+
+      expect(sanitizationResult.isSanitized).toBe(false);
+      expect(sanitizationResult.sanitizedValue).toBeUndefined();
+    },
+  );
+});

package/src/operations/types/index.ts

@@ -8,6 +8,7 @@ export interface OperationResult {
   isValid: boolean;
 }
 
+export type RawConditionValue = Record<string, unknown>;
 export type ConditionValue =
   | StringOperationPayload
   | NumericOperationPayload
@@ -19,4 +20,11 @@ export type OperationHandler = (attribute: any) => OperationResult;
 export type OperationContextEnricher = (value: ConditionValue) => OperationHandler;
 export type OperationsMapper = { [key in OperationEnum]?: OperationContextEnricher };
 
+export interface SanitizationResult<T extends ConditionValue> {
+  isSanitized: boolean;
+  sanitizedValue: T | undefined;
+}
+export type Sanitizer<T extends ConditionValue> = (value: RawConditionValue) => SanitizationResult<T>;
+export type SanitizersMapper<T extends ConditionValue> = { [key in OperationEnum]?: Sanitizer<T> };
+
 export * from './operation.enum';

package/src/operations/numeric/operations.spec.ts

@@ -1,63 +0,0 @@
-import {
-    useBetweenNumericOperation,
-    useEqualsOperation,
-    useGreaterThanEqualOperation,
-    useGreaterThanOperation, useLesserThanEqualOperation,
-    useLesserThanOperation,
-} from './index';
-import { fc, test } from '@fast-check/jest';
-
-describe('Numeric operations', () => {
-  test.prop([fc.integer(), fc.integer()], { verbose: true })(
-    'should return true if the numbers equal',
-    (number, attribute) => {
-      const result = useEqualsOperation({ number })(attribute);
-      return (number === attribute) === result.isValid;
-    },
-  );
-
-  test.prop([fc.integer(), fc.integer()], { verbose: true })(
-    'should return correct validity value when attribute is greater than the given number',
-    (number, attribute) => {
-      const result = useGreaterThanOperation({ number })(attribute);
-
-      return attribute > number === result.isValid;
-    },
-  );
-
-  test.prop([fc.integer(), fc.integer()], { verbose: true })(
-    'should return correct validity value when attribute is greater or equals to given number',
-    (number, attribute) => {
-      const result = useGreaterThanEqualOperation({ number })(attribute);
-
-      return attribute >= number === result.isValid;
-    },
-  );
-
-  test.prop([fc.integer(), fc.integer()], { verbose: true })(
-    'should return correct validity value when attribute is lesser than then given number',
-    (number, attribute) => {
-      const result = useLesserThanOperation({ number })(attribute);
-
-      return attribute < number === result.isValid;
-    },
-  );
-
-  test.prop([fc.integer(), fc.integer()], { verbose: true })(
-    'should return correct validity value when attribute is lesser or equals to given number',
-    (number, attribute) => {
-      const result = useLesserThanEqualOperation({ number })(attribute);
-
-      return attribute <= number === result.isValid;
-    },
-  );
-
-  test.prop([fc.integer(), fc.integer(), fc.integer()], { verbose: true })(
-    'should return correct validity value when attribute is between the given numbers',
-    (start, end, attribute) => {
-      const result = useBetweenNumericOperation({ start, end })(attribute);
-
-      return (attribute >= start && attribute <= end) === result.isValid;
-    },
-  );
-});

package/src/operations/string/operations.spec.ts

@@ -1,38 +0,0 @@
-import { useContainsOperation, useEndsWithOperation, useInListOperation, useStartsWithOperation } from './index';
-import { fc, test } from '@fast-check/jest';
-
-describe('String operations', () => {
-  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
-    'should return correct validity if one of the strings starts with the given prefix',
-    (list, prefix) => {
-      const result = useStartsWithOperation({ list })(prefix);
-      return list.some((value) => prefix.startsWith(value)) === result.isValid;
-    },
-  );
-
-  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
-    'should return correct validity if one of the strings ends with the given suffix',
-    (list, suffix) => {
-      const result = useEndsWithOperation({ list })(suffix);
-      return list.some((value) => suffix.endsWith(value)) === result.isValid;
-    },
-  );
-
-  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
-    'should return correct validity if one of the strings contains with given attribute',
-    (list, included) => {
-      const result = useContainsOperation({ list })(included);
-
-      return list.some((value) => included.includes(value)) === result.isValid;
-    },
-  );
-
-  test.prop([fc.array(fc.string()), fc.string()], { verbose: true })(
-    'should return correct validity if one of the strings is in the given list',
-    (list, string) => {
-      const result = useInListOperation({ list })(string);
-
-      return list.includes(string) === result.isValid;
-    },
-  );
-});