@escapenavigator/utils 1.10.106 → 1.10.108

package/dist/validate-by-dto.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateByDto = void 0;
+exports.validateByDto = validateByDto;
 const class_validator_1 = require("class-validator");
 function validateByDto(t) {
     const validate = (data) => {
-        const errors = (0, class_validator_1.validateSync)(typeof data === 'object' ? data : {});
+        const errors = (0, class_validator_1.validateSync)(data && typeof data === 'object' ? data : {});
         const getErrors = (err = []) => err.reduce((acc, { property, constraints, children }) => {
             if (children && typeof children === 'object' && children.length) {
                 return { ...acc, [property]: getErrors(children) };
@@ -19,4 +19,3 @@ function validateByDto(t) {
     };
     return validate;
 }
-exports.validateByDto = validateByDto;

package/dist/validate-promocode.d.ts

@@ -1,4 +1,5 @@
 import { PromocodeRO } from '@escapenavigator/types/dist/promocode/promocode.ro';
+import { PromocodeError } from './promocode-error-codes';
 type Cert = {
     questroomId?: never;
     players?: never;
@@ -15,6 +16,13 @@ type Order = {
     timeZone: string;
     type: 'order';
 };
+export type ValidatePromocodeResult = {
+    valid: true;
+    errors: [];
+} | {
+    valid: false;
+    errors: PromocodeError[];
+};
 export declare function validatePromocode({ promocode, players, questroomId, timeZone, orderDate, hasCertificates, otherPromocodes, slotDiscount, isInside, type, }: {
     promocode: PromocodeRO;
     isInside: boolean;
@@ -23,8 +31,5 @@ export declare function validatePromocode({ promocode, players, questroomId, tim
         canUseWithOtherPromocodes: boolean;
         code: string;
     }>;
-} & (Order | Cert)): {
-    valid: boolean;
-    errors: any[];
-};
+} & (Order | Cert)): ValidatePromocodeResult;
 export {};

package/dist/validate-promocode.js

@@ -1,87 +1,106 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePromocode = void 0;
-const date_fns_1 = require("date-fns");
-const date_fns_tz_1 = require("date-fns-tz");
+exports.validatePromocode = validatePromocode;
+const date_1 = require("./date");
+const promocode_error_codes_1 = require("./promocode-error-codes");
 function getWeekdayNumber(date) {
     const day = new Date(date).getDay();
     return (day === 0 ? 7 : day) - 1;
 }
 function validatePromocode({ promocode, players, questroomId, timeZone, orderDate, hasCertificates, otherPromocodes, slotDiscount, isInside, type, }) {
     const errors = [];
-    const orderDateInTimeZone = type === 'order' && (0, date_fns_tz_1.utcToZonedTime)(new Date(orderDate).toISOString(), timeZone);
-    const currentDate = type === 'order' && (0, date_fns_1.format)(orderDateInTimeZone, 'yyyy-MM-dd');
+    const orderDateInTimeZone = type === 'order' && (0, date_1.utcToZonedTime)(new Date(orderDate).toISOString(), timeZone);
+    const currentDate = type === 'order' && (0, date_1.formatDate)(orderDateInTimeZone, 'yyyy-MM-dd');
     const orderDayOfWeek = type === 'order' && getWeekdayNumber(orderDateInTimeZone);
-    const localOrderTime = type === 'order' && (0, date_fns_1.format)(orderDateInTimeZone, 'HH:mm');
-    const todayDate = (0, date_fns_1.format)((0, date_fns_tz_1.utcToZonedTime)(new Date(), timeZone), 'yyyy-MM-dd');
+    const localOrderTime = type === 'order' && (0, date_1.formatDate)(orderDateInTimeZone, 'HH:mm');
+    const todayDate = (0, date_1.formatDate)((0, date_1.utcToZonedTime)(new Date(), timeZone), 'yyyy-MM-dd');
     if (type === 'certificate' && !promocode.availableForCertificates) {
-        errors.push("The promocode can't be applied for certificates.");
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.NOT_AVAILABLE_FOR_CERTIFICATES });
     }
     if (otherPromocodes?.some((p) => p.code === promocode.code)) {
-        errors.push('Promocode already applied');
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.ALREADY_APPLIED });
     }
     if (type === 'order' && !promocode.availableForBookings) {
-        errors.push("The promocode can't be applied for certificates.");
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.NOT_AVAILABLE_FOR_BOOKINGS });
     }
     if (promocode.inside && !isInside) {
-        errors.push('The promocode can be applied by phone.');
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.INSIDE_ONLY });
     }
     if (promocode.multiple) {
         if (promocode.availableApplyings > 0 &&
             promocode.applyings >= promocode.availableApplyings) {
-            errors.push('The maximum number of promocode applications has been reached.');
+            errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.MAX_APPLYINGS_REACHED });
         }
     }
     else if (promocode.applyings > 0) {
-        errors.push('The promocode can only be used once.');
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.SINGLE_USE });
     }
     if (!promocode.canUseWithOtherPromocodes && (otherPromocodes.length || slotDiscount)) {
-        errors.push('The promocode cannot be used with other promocodes or discounts.');
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.NOT_COMBINABLE_WITH_OTHER_DISCOUNTS });
     }
     if (!promocode.canUseWithOtherCertificates && hasCertificates) {
-        errors.push('The promocode cannot be used with other certificates.');
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.NOT_COMBINABLE_WITH_CERTIFICATES });
     }
     if (promocode.validFrom && todayDate < promocode.validFrom) {
-        errors.push(`The promocode is valid from ${promocode.validFrom}.`);
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.NOT_VALID_YET,
+            payload: { validFrom: promocode.validFrom },
+        });
     }
     if (promocode.validTo && todayDate > promocode.validTo) {
-        errors.push(`The promocode has expired. It was valid until ${promocode.validTo}.`);
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.EXPIRED,
+            payload: { validTo: promocode.validTo },
+        });
     }
     if (type === 'order' && promocode.forOrdersFrom && currentDate < promocode.forOrdersFrom) {
-        errors.push(`The promocode is valid for games starting from ${promocode.forOrdersFrom}.`);
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.NOT_FOR_ORDER_DATE_FROM,
+            payload: { forOrdersFrom: promocode.forOrdersFrom },
+        });
     }
     if (type === 'order' && promocode.forOrdersTo && currentDate > promocode.forOrdersTo) {
-        errors.push(`The promocode is not valid for games after ${promocode.forOrdersTo}.`);
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.NOT_FOR_ORDER_DATE_TO,
+            payload: { forOrdersTo: promocode.forOrdersTo },
+        });
     }
-    if (!promocode.allQuestrooms && !promocode.questroomsIds?.includes(questroomId)) {
-        errors.push('The promocode is not valid for the selected escape room.');
+    if (type === 'order' &&
+        !promocode.allQuestrooms &&
+        !promocode.questroomsIds?.includes(questroomId)) {
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.QUESTROOM_NOT_ALLOWED });
     }
     if (type === 'order' && promocode.availableFrom && localOrderTime < promocode.availableFrom) {
-        errors.push(`The promocode is available from ${promocode.availableFrom}.`);
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.NOT_AVAILABLE_AT_THIS_TIME_FROM,
+            payload: { availableFrom: promocode.availableFrom },
+        });
     }
     if (type === 'order' && promocode.availableTo && localOrderTime > promocode.availableTo) {
-        errors.push(`The promocode is only available until ${promocode.availableTo}.`);
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.NOT_AVAILABLE_AT_THIS_TIME_TO,
+            payload: { availableTo: promocode.availableTo },
+        });
     }
     if (type === 'order' &&
         promocode.availableDays &&
         !promocode.availableDays.includes(orderDayOfWeek)) {
-        errors.push('The promocode is not valid for the selected day.');
+        errors.push({ code: promocode_error_codes_1.PromocodeErrorCode.NOT_AVAILABLE_THIS_DAY });
     }
-    if (promocode.minPlayers && players < promocode.minPlayers) {
-        errors.push(`The promocode is valid only for games with at least ${promocode.minPlayers} players.`);
+    if (type === 'order' && promocode.minPlayers && players < promocode.minPlayers) {
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.MIN_PLAYERS,
+            payload: { minPlayers: promocode.minPlayers },
+        });
     }
-    if (promocode.maxPlayers && players > promocode.maxPlayers) {
-        errors.push(`The promocode is valid only for games with no more than ${promocode.maxPlayers} players.`);
+    if (type === 'order' && promocode.maxPlayers && players > promocode.maxPlayers) {
+        errors.push({
+            code: promocode_error_codes_1.PromocodeErrorCode.MAX_PLAYERS,
+            payload: { maxPlayers: promocode.maxPlayers },
+        });
     }
     if (errors.length > 0) {
-        return {
-            valid: false,
-            errors,
-        };
-    }
-    return {
-        valid: true,
-        errors: [],
-    };
+        return { valid: false, errors };
+    }
+    return { valid: true, errors: [] };
 }
-exports.validatePromocode = validatePromocode;

package/dist/validate-promocode.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/validate-promocode.spec.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promocode_type_enum_1 = require("@escapenavigator/types/dist/promocode/emun/promocode-type.enum");
+const promocode_error_codes_1 = require("./promocode-error-codes");
+const validate_promocode_1 = require("./validate-promocode");
+const basePromocode = {
+    id: 1,
+    code: 'PROMO',
+    description: '',
+    type: promocode_type_enum_1.PromocodeTypeEnum.PERCENT_BASE_SUM,
+    discount: 1000,
+    multiple: true,
+    crossSale: false,
+    canUseWithOtherPromocodes: true,
+    canUseWithOtherCertificates: true,
+    inside: false,
+    availableApplyings: 0,
+    applyings: 0,
+    availableForBookings: true,
+    availableForCertificates: true,
+    validFrom: undefined,
+    validTo: undefined,
+    forOrdersFrom: undefined,
+    forOrdersTo: undefined,
+    allQuestrooms: true,
+    questroomsIds: [],
+    availableFrom: '00:00',
+    availableTo: '23:55',
+    availableDays: [0, 1, 2, 3, 4, 5, 6],
+    minPlayers: 0,
+    maxPlayers: 0,
+    clientDescription: undefined,
+    orderId: undefined,
+};
+const orderArgs = {
+    type: 'order',
+    questroomId: 1,
+    hasCertificates: false,
+    otherPromocodes: [],
+    orderDate: '2026-06-01T18:00:00.000Z',
+    timeZone: 'UTC',
+    slotDiscount: 0,
+    isInside: false,
+    players: 4,
+};
+describe('validatePromocode (order)', () => {
+    it('valid for plain promocode', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({ promocode: basePromocode, ...orderArgs });
+        expect(r.valid).toBe(true);
+        expect(r.errors).toEqual([]);
+    });
+    it('errors with code SINGLE_USE when used multiple=false and applyings>0', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({
+            promocode: { ...basePromocode, multiple: false, applyings: 1 },
+            ...orderArgs,
+        });
+        expect(r.valid).toBe(false);
+        expect(r.errors[0].code).toBe(promocode_error_codes_1.PromocodeErrorCode.SINGLE_USE);
+    });
+    it('errors EXPIRED with payload.validTo', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({
+            promocode: { ...basePromocode, validTo: '2020-01-01' },
+            ...orderArgs,
+        });
+        expect(r.valid).toBe(false);
+        const exp = r.errors.find((e) => e.code === promocode_error_codes_1.PromocodeErrorCode.EXPIRED);
+        expect(exp).toBeTruthy();
+        expect(exp.payload).toEqual({ validTo: '2020-01-01' });
+    });
+    it('errors NOT_AVAILABLE_FOR_BOOKINGS when scope excludes bookings', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({
+            promocode: { ...basePromocode, availableForBookings: false },
+            ...orderArgs,
+        });
+        expect(r.valid).toBe(false);
+        const codes = r.errors.map((e) => e.code);
+        expect(codes).toContain(promocode_error_codes_1.PromocodeErrorCode.NOT_AVAILABLE_FOR_BOOKINGS);
+    });
+    it('errors INSIDE_ONLY when inside=true and isInside=false', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({
+            promocode: { ...basePromocode, inside: true },
+            ...orderArgs,
+        });
+        expect(r.valid).toBe(false);
+        const codes = r.errors.map((e) => e.code);
+        expect(codes).toContain(promocode_error_codes_1.PromocodeErrorCode.INSIDE_ONLY);
+    });
+    it('errors NOT_COMBINABLE_WITH_OTHER_DISCOUNTS when slotDiscount and not combinable', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({
+            promocode: { ...basePromocode, canUseWithOtherPromocodes: false },
+            ...orderArgs,
+            slotDiscount: 1000,
+        });
+        expect(r.valid).toBe(false);
+        const codes = r.errors.map((e) => e.code);
+        expect(codes).toContain(promocode_error_codes_1.PromocodeErrorCode.NOT_COMBINABLE_WITH_OTHER_DISCOUNTS);
+    });
+    it('errors MIN_PLAYERS with payload', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({
+            promocode: { ...basePromocode, minPlayers: 5 },
+            ...orderArgs,
+            players: 3,
+        });
+        expect(r.valid).toBe(false);
+        const e = r.errors.find((x) => x.code === promocode_error_codes_1.PromocodeErrorCode.MIN_PLAYERS);
+        expect(e?.payload).toEqual({ minPlayers: 5 });
+    });
+});
+describe('validatePromocode (certificate)', () => {
+    const certArgs = {
+        type: 'certificate',
+        otherPromocodes: [],
+        timeZone: 'UTC',
+        slotDiscount: 0,
+        isInside: false,
+    };
+    it('valid for default certificate-eligible promocode', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({ promocode: basePromocode, ...certArgs });
+        expect(r.valid).toBe(true);
+    });
+    it('errors NOT_AVAILABLE_FOR_CERTIFICATES when scope excludes', () => {
+        const r = (0, validate_promocode_1.validatePromocode)({
+            promocode: { ...basePromocode, availableForCertificates: false },
+            ...certArgs,
+        });
+        expect(r.valid).toBe(false);
+        expect(r.errors[0].code).toBe(promocode_error_codes_1.PromocodeErrorCode.NOT_AVAILABLE_FOR_CERTIFICATES);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@escapenavigator/utils",
-  "version": "1.10.106",
+  "version": "1.10.108",
   "publishConfig": {
     "access": "public"
   },
@@ -14,38 +14,17 @@
     "test": "jest"
   },
   "dependencies": {
-    "@escapenavigator/types": "^1.10.102",
+    "@escapenavigator/types": "^1.10.104",
     "axios": "^0.21.4",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.13.2",
-    "date-fns": "^2.22.1",
-    "date-fns-tz": "^2.0.0",
     "i18next": "^21.6.4"
   },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^13.0.0",
-    "@rollup/plugin-replace": "^2.4.2",
-    "@rollup/plugin-typescript": "^8.2.1",
     "@types/jest": "^29.5.10",
-    "@wessberg/rollup-plugin-ts": "^1.3.14",
-    "alphakit-presets-lint": "^1.0.0",
-    "babel-jest": "^26.6.3",
     "jest": "^29.7.0",
-    "rollup-plugin-auto-external": "^2.0.0",
-    "rollup-plugin-babel": "^4.4.0",
-    "rollup-plugin-commonjs": "^10.1.0",
-    "rollup-plugin-multi-input": "1.3.1",
-    "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-peer-deps-external": "^2.2.4",
-    "rollup-plugin-terser": "^7.0.2",
     "ts-jest": "^29.1.1",
-    "ts-loader": "^6.2.1",
-    "typescript": "^4.5.4"
+    "typescript": "^5.6"
   },
-  "perDependencies": {
-    "axios": "^0.21.1",
-    "utility-types": "^3.10.0",
-    "uuid": "^8.3.2"
-  },
-  "gitHead": "2b24c3c15eb1add8eba28d8f90ca97f5fac884ab"
+  "gitHead": "d7810efb079eb481e21a23cb94e39be6c55f62d5"
 }