@adtrackify/at-service-common 5.0.0 → 5.0.3

package/dist/cjs/__tests__/utils/custom-measure-formula-utils.spec.js

@@ -1,147 +1,147 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const custom_measure_formula_utils_js_1 = require("../../utils/custom-measure-formula-utils.js");
-describe('custom measure formula utils', () => {
-    describe('tokenizeFormula', () => {
-        it('should tokenize measures, numbers, operators and parens', () => {
-            const tokens = (0, custom_measure_formula_utils_js_1.tokenizeFormula)('(orders.net_revenue - channel.spend) / channel.spend * 100');
-            expect(tokens.map((t) => t.type)).toEqual([
-                'lparen',
-                'measure',
-                'operator',
-                'measure',
-                'rparen',
-                'operator',
-                'measure',
-                'operator',
-                'number',
-            ]);
-            expect(tokens[1].value).toBe('orders.net_revenue');
-            expect(tokens[8].value).toBe('100');
-        });
-        it('should tokenize decimal numbers and dotted measures ending in digits', () => {
-            const tokens = (0, custom_measure_formula_utils_js_1.tokenizeFormula)('orders.cm3 * 0.3');
-            expect(tokens.map((t) => t.value)).toEqual(['orders.cm3', '*', '0.3']);
-        });
-        it('should reject invalid characters', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('orders.revenue & 2')).toThrow(/Invalid character/);
-        });
-        it('should reject non-dotted identifiers', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('revenue + 1')).toThrow(/Invalid measure reference/);
-        });
-        it('should tokenize mixed-case data.* field operands', () => {
-            const tokens = (0, custom_measure_formula_utils_js_1.tokenizeFormula)('data.leadValue * 0.4');
-            expect(tokens.map((t) => t.value)).toEqual(['data.leadValue', '*', '0.4']);
-        });
-        it('should reject a bare ULID (no dot) as an operand', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('01ARZ3NDEKTSV4RRFFQ69G5FAV + 1')).toThrow(/Invalid/);
-        });
-        it('should reject malformed numbers', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('1.2.3 + orders.count')).toThrow(/Invalid number/);
-        });
-        it('should reject an empty formula', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('   ')).toThrow(/empty/);
-        });
-    });
-    describe('parseFormula', () => {
-        it('should honour operator precedence', () => {
-            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('orders.a + orders.b * orders.c');
-            expect(ast).toEqual({
-                type: 'binary',
-                operator: '+',
-                left: { type: 'measure', measure: 'orders.a' },
-                right: {
-                    type: 'binary',
-                    operator: '*',
-                    left: { type: 'measure', measure: 'orders.b' },
-                    right: { type: 'measure', measure: 'orders.c' },
-                },
-            });
-        });
-        it('should honour parentheses and unary minus', () => {
-            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('-(orders.a - orders.b)');
-            expect(ast).toEqual({
-                type: 'unary',
-                operator: '-',
-                operand: {
-                    type: 'binary',
-                    operator: '-',
-                    left: { type: 'measure', measure: 'orders.a' },
-                    right: { type: 'measure', measure: 'orders.b' },
-                },
-            });
-        });
-        it('should reject unbalanced parentheses', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.parseFormula)('(orders.a + orders.b')).toThrow(/Unbalanced parentheses/);
-        });
-        it('should reject trailing operators', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.parseFormula)('orders.a +')).toThrow(/Unexpected end of formula/);
-        });
-        it('should reject dangling tokens', () => {
-            expect(() => (0, custom_measure_formula_utils_js_1.parseFormula)('orders.a orders.b')).toThrow(/Unexpected token/);
-        });
-    });
-    describe('collectFormulaMeasures', () => {
-        it('should return unique measures in order', () => {
-            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('(orders.net_revenue - channel.spend) / channel.spend');
-            expect((0, custom_measure_formula_utils_js_1.collectFormulaMeasures)(ast)).toEqual(['orders.net_revenue', 'channel.spend']);
-        });
-    });
-    describe('evaluateFormulaAst', () => {
-        const values = new Map([
-            ['orders.net_revenue', 1000],
-            ['channel.spend', 250],
-            ['orders.count', 0],
-        ]);
-        it('should evaluate a ratio with percentage scaling', () => {
-            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('(orders.net_revenue - channel.spend) / channel.spend * 100');
-            expect((0, custom_measure_formula_utils_js_1.evaluateFormulaAst)(ast, values)).toBe(300);
-        });
-        it('should return 0 on division by zero (matches SQL nullif semantics)', () => {
-            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('orders.net_revenue / orders.count');
-            expect((0, custom_measure_formula_utils_js_1.evaluateFormulaAst)(ast, values)).toBe(0);
-        });
-        it('should treat a missing operand as 0 (matches SQL COALESCE semantics)', () => {
-            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('orders.net_revenue - orders.unknown');
-            expect((0, custom_measure_formula_utils_js_1.evaluateFormulaAst)(ast, values)).toBe(1000);
-        });
-    });
-    describe('validateFormula', () => {
-        const knownOperands = new Set(['orders.net_revenue', 'channel.spend', 'orders.count']);
-        it('should accept a valid formula', () => {
-            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('(orders.net_revenue - channel.spend) / channel.spend * 100', { knownOperands });
-            expect(result.valid).toBe(true);
-            expect(result.errors).toEqual([]);
-            expect(result.ast).toBeDefined();
-        });
-        it('should reject an unknown operand', () => {
-            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('orders.net_revenue / orders.mystery', { knownOperands });
-            expect(result.valid).toBe(false);
-            expect(result.errors[0]).toMatch(/Unknown or unsupported measure/);
-        });
-        it('should reject a pure-constant formula', () => {
-            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('1 + 2', { knownOperands });
-            expect(result.valid).toBe(false);
-            expect(result.errors[0]).toMatch(/at least one measure/);
-        });
-        it('should surface syntax errors', () => {
-            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('(orders.count + ', { knownOperands });
-            expect(result.valid).toBe(false);
-            expect(result.errors.length).toBe(1);
-        });
-        it('should run syntactic-only when no operand predicate is supplied', () => {
-            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('orders.net_revenue / channel.spend');
-            expect(result.valid).toBe(true);
-        });
-        it('should reject a constant zero denominator', () => {
-            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / 0', { knownOperands }).errors).toContain('Division by zero is not allowed');
-            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / (5 - 5)', { knownOperands }).valid).toBe(false);
-            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / (2 * 0)', { knownOperands }).valid).toBe(false);
-        });
-        it('should allow a measure or non-zero constant denominator', () => {
-            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.net_revenue / channel.spend', { knownOperands }).valid).toBe(true);
-            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / 5', { knownOperands }).valid).toBe(true);
-        });
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const custom_measure_formula_utils_js_1 = require("../../utils/custom-measure-formula-utils.js");
+describe('custom measure formula utils', () => {
+    describe('tokenizeFormula', () => {
+        it('should tokenize measures, numbers, operators and parens', () => {
+            const tokens = (0, custom_measure_formula_utils_js_1.tokenizeFormula)('(orders.net_revenue - channel.spend) / channel.spend * 100');
+            expect(tokens.map((t) => t.type)).toEqual([
+                'lparen',
+                'measure',
+                'operator',
+                'measure',
+                'rparen',
+                'operator',
+                'measure',
+                'operator',
+                'number',
+            ]);
+            expect(tokens[1].value).toBe('orders.net_revenue');
+            expect(tokens[8].value).toBe('100');
+        });
+        it('should tokenize decimal numbers and dotted measures ending in digits', () => {
+            const tokens = (0, custom_measure_formula_utils_js_1.tokenizeFormula)('orders.cm3 * 0.3');
+            expect(tokens.map((t) => t.value)).toEqual(['orders.cm3', '*', '0.3']);
+        });
+        it('should reject invalid characters', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('orders.revenue & 2')).toThrow(/Invalid character/);
+        });
+        it('should reject non-dotted identifiers', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('revenue + 1')).toThrow(/Invalid measure reference/);
+        });
+        it('should tokenize mixed-case data.* field operands', () => {
+            const tokens = (0, custom_measure_formula_utils_js_1.tokenizeFormula)('data.leadValue * 0.4');
+            expect(tokens.map((t) => t.value)).toEqual(['data.leadValue', '*', '0.4']);
+        });
+        it('should reject a bare ULID (no dot) as an operand', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('01ARZ3NDEKTSV4RRFFQ69G5FAV + 1')).toThrow(/Invalid/);
+        });
+        it('should reject malformed numbers', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('1.2.3 + orders.count')).toThrow(/Invalid number/);
+        });
+        it('should reject an empty formula', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.tokenizeFormula)('   ')).toThrow(/empty/);
+        });
+    });
+    describe('parseFormula', () => {
+        it('should honour operator precedence', () => {
+            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('orders.a + orders.b * orders.c');
+            expect(ast).toEqual({
+                type: 'binary',
+                operator: '+',
+                left: { type: 'measure', measure: 'orders.a' },
+                right: {
+                    type: 'binary',
+                    operator: '*',
+                    left: { type: 'measure', measure: 'orders.b' },
+                    right: { type: 'measure', measure: 'orders.c' },
+                },
+            });
+        });
+        it('should honour parentheses and unary minus', () => {
+            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('-(orders.a - orders.b)');
+            expect(ast).toEqual({
+                type: 'unary',
+                operator: '-',
+                operand: {
+                    type: 'binary',
+                    operator: '-',
+                    left: { type: 'measure', measure: 'orders.a' },
+                    right: { type: 'measure', measure: 'orders.b' },
+                },
+            });
+        });
+        it('should reject unbalanced parentheses', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.parseFormula)('(orders.a + orders.b')).toThrow(/Unbalanced parentheses/);
+        });
+        it('should reject trailing operators', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.parseFormula)('orders.a +')).toThrow(/Unexpected end of formula/);
+        });
+        it('should reject dangling tokens', () => {
+            expect(() => (0, custom_measure_formula_utils_js_1.parseFormula)('orders.a orders.b')).toThrow(/Unexpected token/);
+        });
+    });
+    describe('collectFormulaMeasures', () => {
+        it('should return unique measures in order', () => {
+            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('(orders.net_revenue - channel.spend) / channel.spend');
+            expect((0, custom_measure_formula_utils_js_1.collectFormulaMeasures)(ast)).toEqual(['orders.net_revenue', 'channel.spend']);
+        });
+    });
+    describe('evaluateFormulaAst', () => {
+        const values = new Map([
+            ['orders.net_revenue', 1000],
+            ['channel.spend', 250],
+            ['orders.count', 0],
+        ]);
+        it('should evaluate a ratio with percentage scaling', () => {
+            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('(orders.net_revenue - channel.spend) / channel.spend * 100');
+            expect((0, custom_measure_formula_utils_js_1.evaluateFormulaAst)(ast, values)).toBe(300);
+        });
+        it('should return 0 on division by zero (matches SQL nullif semantics)', () => {
+            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('orders.net_revenue / orders.count');
+            expect((0, custom_measure_formula_utils_js_1.evaluateFormulaAst)(ast, values)).toBe(0);
+        });
+        it('should treat a missing operand as 0 (matches SQL COALESCE semantics)', () => {
+            const ast = (0, custom_measure_formula_utils_js_1.parseFormula)('orders.net_revenue - orders.unknown');
+            expect((0, custom_measure_formula_utils_js_1.evaluateFormulaAst)(ast, values)).toBe(1000);
+        });
+    });
+    describe('validateFormula', () => {
+        const knownOperands = new Set(['orders.net_revenue', 'channel.spend', 'orders.count']);
+        it('should accept a valid formula', () => {
+            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('(orders.net_revenue - channel.spend) / channel.spend * 100', { knownOperands });
+            expect(result.valid).toBe(true);
+            expect(result.errors).toEqual([]);
+            expect(result.ast).toBeDefined();
+        });
+        it('should reject an unknown operand', () => {
+            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('orders.net_revenue / orders.mystery', { knownOperands });
+            expect(result.valid).toBe(false);
+            expect(result.errors[0]).toMatch(/Unknown or unsupported measure/);
+        });
+        it('should reject a pure-constant formula', () => {
+            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('1 + 2', { knownOperands });
+            expect(result.valid).toBe(false);
+            expect(result.errors[0]).toMatch(/at least one measure/);
+        });
+        it('should surface syntax errors', () => {
+            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('(orders.count + ', { knownOperands });
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBe(1);
+        });
+        it('should run syntactic-only when no operand predicate is supplied', () => {
+            const result = (0, custom_measure_formula_utils_js_1.validateFormula)('orders.net_revenue / channel.spend');
+            expect(result.valid).toBe(true);
+        });
+        it('should reject a constant zero denominator', () => {
+            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / 0', { knownOperands }).errors).toContain('Division by zero is not allowed');
+            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / (5 - 5)', { knownOperands }).valid).toBe(false);
+            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / (2 * 0)', { knownOperands }).valid).toBe(false);
+        });
+        it('should allow a measure or non-zero constant denominator', () => {
+            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.net_revenue / channel.spend', { knownOperands }).valid).toBe(true);
+            expect((0, custom_measure_formula_utils_js_1.validateFormula)('orders.count / 5', { knownOperands }).valid).toBe(true);
+        });
+    });
+});
 //# sourceMappingURL=custom-measure-formula-utils.spec.js.map

package/dist/cjs/clients/generic/cognito-client.d.ts

@@ -1,23 +1,23 @@
-import { AdminSetUserPasswordCommandOutput, CognitoIdentityProvider } from '@aws-sdk/client-cognito-identity-provider';
-export declare function dictToAwsAttributes(input: any): {
-    Name: string;
-    Value: any;
-}[];
-export declare class CognitoClient {
-    cognitoClient: CognitoIdentityProvider;
-    USER_POOL_ID: string;
-    USER_POOL_NO_SECRET_CLIENT_ID: string;
-    constructor(userPoolId: string, userPoolNoSecretClientId: string);
-    signupUser: (data: any) => Promise<import("@aws-sdk/client-cognito-identity-provider").SignUpCommandOutput>;
-    forgotPassword: (email: string) => Promise<import("@aws-sdk/client-cognito-identity-provider").ForgotPasswordCommandOutput>;
-    adminSetUserPassword: (email: string, password: string) => Promise<AdminSetUserPasswordCommandOutput>;
-    adminEmailVerify: (email: string) => Promise<void>;
-    forceValidateEmail: (email: string) => Promise<void>;
-    adminConfirmUser: (data: any) => Promise<import("@aws-sdk/client-cognito-identity-provider").AdminConfirmSignUpCommandOutput>;
-    confirmUser: (data: any) => Promise<import("@aws-sdk/client-cognito-identity-provider").ConfirmSignUpCommandOutput>;
-    resendCode: (email: string) => Promise<void>;
-    adminDeleteUser: (userId: string) => Promise<boolean>;
-    getUserByEmail: (email: string) => Promise<any>;
-    getUser: (id: string) => Promise<any>;
-    listAllUsers: (params?: {}) => Promise<any[]>;
-}
+import { AdminSetUserPasswordCommandOutput, CognitoIdentityProvider } from '@aws-sdk/client-cognito-identity-provider';
+export declare function dictToAwsAttributes(input: any): {
+    Name: string;
+    Value: any;
+}[];
+export declare class CognitoClient {
+    cognitoClient: CognitoIdentityProvider;
+    USER_POOL_ID: string;
+    USER_POOL_NO_SECRET_CLIENT_ID: string;
+    constructor(userPoolId: string, userPoolNoSecretClientId: string);
+    signupUser: (data: any) => Promise<import("@aws-sdk/client-cognito-identity-provider").SignUpCommandOutput>;
+    forgotPassword: (email: string) => Promise<import("@aws-sdk/client-cognito-identity-provider").ForgotPasswordCommandOutput>;
+    adminSetUserPassword: (email: string, password: string) => Promise<AdminSetUserPasswordCommandOutput>;
+    adminEmailVerify: (email: string) => Promise<void>;
+    forceValidateEmail: (email: string) => Promise<void>;
+    adminConfirmUser: (data: any) => Promise<import("@aws-sdk/client-cognito-identity-provider").AdminConfirmSignUpCommandOutput>;
+    confirmUser: (data: any) => Promise<import("@aws-sdk/client-cognito-identity-provider").ConfirmSignUpCommandOutput>;
+    resendCode: (email: string) => Promise<void>;
+    adminDeleteUser: (userId: string) => Promise<boolean>;
+    getUserByEmail: (email: string) => Promise<any>;
+    getUser: (id: string) => Promise<any>;
+    listAllUsers: (params?: {}) => Promise<any[]>;
+}