@mytmpvpn/mytmpvpn-common 9.0.0 → 10.0.2

package/dist/jest.config.d.ts

@@ -4,3 +4,7 @@ export const testMatch: string[];
 export const transform: {
     '^.+\\.tsx?$': string;
 };
+export const collectCoverage: boolean;
+export const coverageDirectory: string;
+export const collectCoverageFrom: string[];
+export const coverageReporters: string[];

package/dist/jest.config.js

@@ -5,5 +5,12 @@ module.exports = {
     testMatch: ['**/*.test.ts'],
     transform: {
         '^.+\\.tsx?$': 'ts-jest'
-    }
+    },
+    collectCoverage: true,
+    coverageDirectory: 'coverage',
+    collectCoverageFrom: [
+        'src/**/*.ts',
+        '!src/**/*.d.ts'
+    ],
+    coverageReporters: ['text', 'lcov', 'html'],
 };

package/dist/src/models/index.d.ts

@@ -1,3 +1,5 @@
 export * as vpn from './vpn';
 export * as uservpn from './uservpn';
 export * as referral from './referral';
+export * as peanuts from './peanuts';
+export * as location from './location';

package/dist/src/models/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.referral = exports.uservpn = exports.vpn = void 0;
+exports.location = exports.peanuts = exports.referral = exports.uservpn = exports.vpn = void 0;
 exports.vpn = require("./vpn");
 exports.uservpn = require("./uservpn");
 exports.referral = require("./referral");
+exports.peanuts = require("./peanuts");
+exports.location = require("./location");

package/dist/src/models/location.d.ts

@@ -0,0 +1,40 @@
+export declare enum InfrastructureProvider {
+    Aws = "Aws",
+    GoogleCloud = "GoogleCloud",
+    Azure = "Azure"
+}
+/**
+ * Instance types define the bandwidth capabilities of VPN instances
+ */
+export declare enum InstanceType {
+    Ultra = "Ultra",
+    Fast = "Fast",
+    Eco = "Eco"
+}
+export interface PricingRate {
+    peanutsPerMinuteMax: number;
+    peanutsPerMinuteMin: number;
+}
+export type PricingRates = Partial<Record<InstanceType, PricingRate>>;
+export interface InfraDetails {
+    ipv6Supported: boolean;
+}
+export interface ProviderInfo {
+    infraDetails: InfraDetails;
+    pricingRates: PricingRates;
+}
+export type ProvidersInfo = Partial<Record<InfrastructureProvider, ProviderInfo>>;
+export interface Location {
+    geonamesId: number;
+    city: string;
+    country: string;
+    countryCode: string;
+    coordinates: {
+        latitude: number;
+        longitude: number;
+    };
+}
+export interface LocationWithProvidersInfo extends Location {
+    providersInfo: ProvidersInfo;
+}
+export type ListLocationsResponse = LocationWithProvidersInfo[];

package/dist/src/models/location.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceType = exports.InfrastructureProvider = void 0;
+var InfrastructureProvider;
+(function (InfrastructureProvider) {
+    InfrastructureProvider["Aws"] = "Aws";
+    InfrastructureProvider["GoogleCloud"] = "GoogleCloud";
+    InfrastructureProvider["Azure"] = "Azure";
+})(InfrastructureProvider = exports.InfrastructureProvider || (exports.InfrastructureProvider = {}));
+/**
+ * Instance types define the bandwidth capabilities of VPN instances
+ */
+var InstanceType;
+(function (InstanceType) {
+    InstanceType["Ultra"] = "Ultra";
+    InstanceType["Fast"] = "Fast";
+    InstanceType["Eco"] = "Eco";
+})(InstanceType = exports.InstanceType || (exports.InstanceType = {}));

package/dist/src/models/uservpn.d.ts

@@ -1,23 +1,30 @@
 import * as vpn from './vpn';
+import { VpnConfig } from './vpnConfig';
+export declare enum UserVpnVersion {
+    INITIAL = 0,
+    LOCATIONS = 1
+}
 export interface UserVpn {
     userId: string;
-    version: number;
+    version: UserVpnVersion;
     vpn: vpn.Vpn;
 }
-export interface newUserVpnParams {
+export interface NewUserVpnParams {
     userId: string;
-    region: string;
-    version?: number;
-    config: vpn.VpnConfig;
+    geonamesId: number;
+    version?: UserVpnVersion;
+    config: VpnConfig;
     state: vpn.VpnState;
 }
-export interface getUserVpnFromParams {
+export interface GetUserVpnFromParams {
     userId: string;
     vpnId: string;
-    version?: number;
-    config: vpn.VpnConfig;
+    createdAt?: Date;
+    geonamesId: number;
+    version?: UserVpnVersion;
+    config: VpnConfig;
     state: vpn.VpnState;
 }
-export declare function newUserVpn({ userId, region, version, ...rest }: newUserVpnParams): UserVpn;
-export declare function getUserVpnFrom({ userId, vpnId, version, ...rest }: getUserVpnFromParams): UserVpn;
+export declare function newUserVpn({ userId, geonamesId, version, ...rest }: NewUserVpnParams): UserVpn;
+export declare function getUserVpnFrom({ userId, vpnId, geonamesId, createdAt, version, ...rest }: GetUserVpnFromParams): UserVpn;
 export declare function jsonToUserVpn(jsonString: any): UserVpn;

package/dist/src/models/uservpn.js

@@ -1,21 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonToUserVpn = exports.getUserVpnFrom = exports.newUserVpn = void 0;
+exports.jsonToUserVpn = exports.getUserVpnFrom = exports.newUserVpn = exports.UserVpnVersion = void 0;
 const vpn = require("./vpn");
-const INITIAL_VERSION = 0;
-function newUserVpn({ userId, region, version = INITIAL_VERSION, ...rest }) {
+var UserVpnVersion;
+(function (UserVpnVersion) {
+    UserVpnVersion[UserVpnVersion["INITIAL"] = 0] = "INITIAL";
+    UserVpnVersion[UserVpnVersion["LOCATIONS"] = 1] = "LOCATIONS"; // This version introduces locations (geonames)
+})(UserVpnVersion = exports.UserVpnVersion || (exports.UserVpnVersion = {}));
+function newUserVpn({ userId, geonamesId, version = UserVpnVersion.LOCATIONS, ...rest }) {
     return {
         userId,
         version,
-        vpn: vpn.newVpn(region, rest.config, rest.state)
+        vpn: vpn.newVpn(geonamesId, rest.config, rest.state)
     };
 }
 exports.newUserVpn = newUserVpn;
-function getUserVpnFrom({ userId, vpnId, version = INITIAL_VERSION, ...rest }) {
+function getUserVpnFrom({ userId, vpnId, geonamesId, createdAt, version = UserVpnVersion.LOCATIONS, ...rest }) {
     return {
         userId,
         version,
-        vpn: vpn.getVpnFrom(vpnId, rest.state, rest.config)
+        vpn: vpn.getVpnFrom(vpnId, createdAt, geonamesId, rest.state, rest.config)
     };
 }
 exports.getUserVpnFrom = getUserVpnFrom;

package/dist/src/models/vpn.d.ts

@@ -1,4 +1,6 @@
-import { UserVpn } from "./uservpn";
+import { UserVpn, UserVpnVersion } from "./uservpn";
+import { VpnConfig } from "./vpnConfig";
+import { Location } from './location';
 export declare enum VpnState {
     Failed = "Failed",
     Creating = "Creating",
@@ -14,21 +16,6 @@ export declare function fromRank(rank: number): VpnState;
 export declare enum VpnType {
     WireGuard = "wireguard"
 }
-export interface VpnConfigLimits {
-    deleteAfterFieldMinValue: number;
-    deleteAfterFieldMaxValue: number;
-    maxPeanutsFieldMinValue: number;
-    maxPeanutsFieldMaxValue: number;
-}
-export interface ValidDeleteAfterConfig {
-    min: number;
-    max: number;
-}
-export interface VpnConfig {
-    type: VpnType;
-    maxPeanuts: number;
-    deleteAfter?: number;
-}
 export interface VpnMetrics {
     duration: number;
     bytes: number;
@@ -37,11 +24,10 @@ export interface VpnMetrics {
 export interface Vpn {
     vpnId: string;
     createdAt: Date;
-    region: string;
+    geonamesId: number;
     config: VpnConfig;
     state: VpnState;
 }
-export type GetVpnConfigLimitsResponse = VpnConfigLimits;
 export type ListVpnsResponse = Vpn[];
 export interface DeleteVpnResponse {
     vpn: {
@@ -59,33 +45,43 @@ export interface GetVpnResponse {
     vpn: Vpn;
     metrics: VpnMetrics;
 }
-export interface RegionInfo {
-    name: string;
-    city: string;
-    country: string;
-    cctld: string;
+export declare enum ListVpnsSortByCriteria {
+    CreatedAt = "createdAt",
+    State = "state",
+    GeonamesId = "geonamesId",
+    VpnId = "vpnId",
+    City = "city",
+    Country = "country"
+}
+export declare enum ListVpnsSortOrder {
+    Asc = "asc",
+    Desc = "desc"
 }
-export type GetVpnConfigResponse = string;
-export type ListRegionsResponse = string[];
-export type ListRegionsDetailedResponse = RegionInfo[];
 export type ListVpnsPagingParams = {
-    pageSize: Number;
-    nextPageToken: string | undefined;
+    pageSize: number;
+    nextPageToken?: string;
+    filterCity?: string;
+    filterCountry?: string;
+    sortBy?: ListVpnsSortByCriteria;
+    sortOrder?: ListVpnsSortOrder;
 };
 export type ListVpnsPaginatedResponse = {
-    totalVpns: number;
-    totalPages: number;
     vpns: Vpn[];
     nextPageToken: string | undefined;
 };
-export declare function getVpnConfigTypes(): VpnType[];
+export declare function validateVpnId(vpnId: string): UserVpnVersion;
 export declare function vpnAgainstQuotaPredicate(uservpn: UserVpn): boolean;
 export declare function validateVpnNbAgainstQuota(vpnNb: number, quota: number): number;
-export declare function checkValidConfig(userId: string, currentBalance: number, vpnConfigLimits: VpnConfigLimits, vpnConfig: any): VpnConfig;
-export declare function newVpn(region: string, config: VpnConfig, state: VpnState): Vpn;
-export declare function getVpnFrom(vpnId: string, state: VpnState, config: VpnConfig): Vpn;
-export declare function vpnIdToWgFileName(vpnId: string): string;
+export type GetLocationByGeonamesId = (geonamesId: number) => Location | undefined;
+export declare function filterVpns(vpns: Vpn[], getLocationByGeonamesId: GetLocationByGeonamesId, filterCity?: string, filterCountry?: string): Vpn[];
+export declare function sortVpns(vpns: Vpn[], getCityByGeonamesId: GetLocationByGeonamesId, sortBy?: ListVpnsSortByCriteria, sortOrder?: ListVpnsSortOrder): Vpn[];
+export declare function newVpn(geonamesId: number, config: VpnConfig, state: VpnState): Vpn;
+export declare function getVpnFrom(vpnId: string, createdAt: Date | undefined, geonamesId: number, state: VpnState, config: VpnConfig): Vpn;
+export declare function dateToId(date: Date): string;
+export declare function idToDate(id: string): Date;
+export declare function vpnIdToWgFileName(vpn: Vpn): string;
 export declare function vpnToClient(vpn: Vpn): Vpn;
+export declare function vpnFromServer(vpn: any): Vpn;
 export declare function metricsToClient(metrics: VpnMetrics | undefined): VpnMetrics;
 /**
  * Extract the creation date from a VPN ID

package/dist/src/models/vpn.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCreationDateFromVpnId = exports.metricsToClient = exports.vpnToClient = exports.vpnIdToWgFileName = exports.getVpnFrom = exports.newVpn = exports.checkValidConfig = exports.validateVpnNbAgainstQuota = exports.vpnAgainstQuotaPredicate = exports.getVpnConfigTypes = exports.VpnType = exports.fromRank = exports.toRank = exports.VpnState = void 0;
+exports.getCreationDateFromVpnId = exports.metricsToClient = exports.vpnFromServer = exports.vpnToClient = exports.vpnIdToWgFileName = exports.idToDate = exports.dateToId = exports.getVpnFrom = exports.newVpn = exports.sortVpns = exports.filterVpns = exports.validateVpnNbAgainstQuota = exports.vpnAgainstQuotaPredicate = exports.validateVpnId = exports.ListVpnsSortOrder = exports.ListVpnsSortByCriteria = exports.VpnType = exports.fromRank = exports.toRank = exports.VpnState = void 0;
+const uuid_1 = require("uuid");
 const errors_1 = require("../errors");
 const peanuts_1 = require("./peanuts");
-const loglevel_1 = require("loglevel");
+const uservpn_1 = require("./uservpn");
+const LEGACY_VPN_ID_FORMAT_REGEX = /\d{4}[01]\d[0-3]\d[0-2]\d[0-5]\d[0-5]\d\d{3}@[a-z]{2}-[a-z]+-\d/;
 var VpnState;
 (function (VpnState) {
     VpnState["Failed"] = "Failed";
@@ -28,52 +30,29 @@ var VpnType;
 (function (VpnType) {
     VpnType["WireGuard"] = "wireguard";
 })(VpnType = exports.VpnType || (exports.VpnType = {}));
-function getVpnConfigTypes() {
-    return Object.values(VpnType).filter((item) => {
-        return isNaN(Number(item));
-    });
-}
-exports.getVpnConfigTypes = getVpnConfigTypes;
+var ListVpnsSortByCriteria;
+(function (ListVpnsSortByCriteria) {
+    ListVpnsSortByCriteria["CreatedAt"] = "createdAt";
+    ListVpnsSortByCriteria["State"] = "state";
+    ListVpnsSortByCriteria["GeonamesId"] = "geonamesId";
+    ListVpnsSortByCriteria["VpnId"] = "vpnId";
+    ListVpnsSortByCriteria["City"] = "city";
+    ListVpnsSortByCriteria["Country"] = "country";
+})(ListVpnsSortByCriteria = exports.ListVpnsSortByCriteria || (exports.ListVpnsSortByCriteria = {}));
+var ListVpnsSortOrder;
+(function (ListVpnsSortOrder) {
+    ListVpnsSortOrder["Asc"] = "asc";
+    ListVpnsSortOrder["Desc"] = "desc";
+})(ListVpnsSortOrder = exports.ListVpnsSortOrder || (exports.ListVpnsSortOrder = {}));
 function validateVpnId(vpnId) {
-    // e.g: YYYYMMDDHHmmssmss@az-test-7
-    if (!/\d{4}[01]\d[0-3]\d[0-2]\d[0-5]\d[0-5]\d\d{3}@[a-z]{2}-[a-z]+-\d/.test(vpnId)) {
-        throw new errors_1.MyTmpVpnError(`Incorrect vpnId: \'${vpnId}\'`);
-    }
-    return vpnId;
-}
-function validateMaxPeanuts(peanuts, currentBalance, vpnConfigLimits) {
-    // No matter what, if currentBalance is negative, we fail
-    if (currentBalance <= 0) {
-        throw new errors_1.NegativeBalanceError(currentBalance);
-    }
-    if (peanuts <= 0) {
-        // result = Math.min(currentBalance, vpnConfigLimits.maxPeanutsFieldMaxValue)
-        // This is always safe as it means run as long as there are enough peanuts
-        return -1;
-    }
-    if (peanuts > currentBalance) {
-        throw new errors_1.NotEnoughPeanutsError(peanuts, currentBalance);
-    }
-    if (peanuts < vpnConfigLimits.maxPeanutsFieldMinValue) {
-        throw new errors_1.MinPeanutsError(vpnConfigLimits.maxPeanutsFieldMinValue, peanuts, currentBalance);
-    }
-    if (peanuts > vpnConfigLimits.maxPeanutsFieldMaxValue) {
-        throw new errors_1.MaxPeanutsError(vpnConfigLimits.maxPeanutsFieldMaxValue, peanuts, currentBalance);
-    }
-    return peanuts;
-}
-function validateDeleteAfter(deleteAfter, vpnConfigLimits) {
-    if (deleteAfter === undefined) {
-        return vpnConfigLimits.deleteAfterFieldMaxValue;
-    }
-    if (deleteAfter < vpnConfigLimits.deleteAfterFieldMinValue) {
-        throw new errors_1.MinDeleteAfterError(vpnConfigLimits.deleteAfterFieldMinValue, deleteAfter);
-    }
-    if (deleteAfter > vpnConfigLimits.deleteAfterFieldMaxValue) {
-        throw new errors_1.MaxDeleteAfterError(vpnConfigLimits.deleteAfterFieldMaxValue, deleteAfter);
-    }
-    return deleteAfter;
+    // Parse the string as a uuid
+    if ((0, uuid_1.validate)(vpnId))
+        return uservpn_1.UserVpnVersion.LOCATIONS;
+    if (LEGACY_VPN_ID_FORMAT_REGEX.test(vpnId))
+        return uservpn_1.UserVpnVersion.INITIAL;
+    throw new errors_1.MyTmpVpnError(`Invalid vpnId format: \'${vpnId}\'`);
 }
+exports.validateVpnId = validateVpnId;
 // Return whether the given vpn should be taken into account when computing
 // whether a given user has reached its quota or not
 function vpnAgainstQuotaPredicate(uservpn) {
@@ -90,79 +69,113 @@ function validateVpnNbAgainstQuota(vpnNb, quota) {
     return vpnNb;
 }
 exports.validateVpnNbAgainstQuota = validateVpnNbAgainstQuota;
-// vpnConfig is of type any here because it could come from user input such as json
-function checkValidConfig(userId, currentBalance, vpnConfigLimits, vpnConfig) {
-    const maxPeanuts = checkValidMaxPeanuts(userId, currentBalance, vpnConfig.maxPeanuts, vpnConfigLimits);
-    const type = checkValidVpnType(vpnConfig.type);
-    const deleteAfter = checkValidDeleteAfter(vpnConfig.deleteAfter, vpnConfigLimits);
-    const result = {
-        maxPeanuts,
-        type,
-        deleteAfter
-    };
-    return result;
-}
-exports.checkValidConfig = checkValidConfig;
-function checkValidMaxPeanuts(userId, currentBalance, maxPeanuts, vpnConfigLimits) {
-    const peanuts = maxPeanuts ? Number.parseFloat(maxPeanuts) : -1;
-    if (Number.isNaN(peanuts) || !Number.isFinite(peanuts)) {
-        throw new errors_1.InvalidVpnConfigError(`Config maxPeanuts is invalid: ${maxPeanuts}`);
-    }
-    loglevel_1.default.debug(`Validating peanuts for ${userId}, peanuts: ${peanuts}, currentBalance: ${currentBalance}`);
-    return validateMaxPeanuts(peanuts, currentBalance, vpnConfigLimits);
-}
-function checkValidVpnType(jsonType) {
-    if (!jsonType) {
-        throw new errors_1.InvalidVpnConfigError(`Config type is null or undefined: ${jsonType}`);
-    }
-    const type = jsonType;
-    if (!type || !Object.values(VpnType).includes(type)) {
-        throw new errors_1.InvalidVpnConfigError(`Config type is invalid: ${jsonType}`);
-    }
-    return type;
+function filterVpns(vpns, getLocationByGeonamesId, filterCity, filterCountry) {
+    let filtered = vpns;
+    return filtered.filter(vpn => {
+        const cityLocation = getLocationByGeonamesId(vpn.geonamesId);
+        if (!cityLocation)
+            return false;
+        // If no filters are applied, include all VPNs
+        if (!filterCity && !filterCountry)
+            return true;
+        const cityMatch = filterCity && cityLocation.city.toLowerCase().includes(filterCity);
+        const countryMatch = filterCountry && cityLocation.country.toLowerCase().includes(filterCountry);
+        // FilterCity  | FilterCountry
+        // undefined   | undefined    -> true (handled above)
+        // match       | undefined    -> cityMatch
+        // unmatch     | undefined    -> false
+        // undefined   | match        -> countryMatch
+        // undefined   | unmatch      -> false
+        // match       | match        -> cityMatch && countryMatch
+        // match       | unmatch      -> cityMatch && false
+        // unmatch     | match        -> false && countryMatch
+        // unmatch     | unmatch      -> false && false
+        const bothMatch = cityMatch && countryMatch;
+        // Either both city and country match the filter
+        // or one of them is undefined and the other matches
+        return bothMatch || (!filterCountry && cityMatch) || (!filterCity && countryMatch);
+    });
 }
-function checkValidDeleteAfter(jsonDeleteAfter, vpnConfigLimits) {
-    if (jsonDeleteAfter === undefined) {
-        return validateDeleteAfter(undefined, vpnConfigLimits);
-    }
-    const deleteAfter = Number.parseInt(jsonDeleteAfter);
-    if (Number.isNaN(deleteAfter)) {
-        throw new errors_1.InvalidVpnConfigError(`Config deleteAfter is invalid: ${jsonDeleteAfter}`);
+exports.filterVpns = filterVpns;
+function sortVpns(vpns, getCityByGeonamesId, sortBy = ListVpnsSortByCriteria.CreatedAt, sortOrder = ListVpnsSortOrder.Desc) {
+    if (!sortBy) {
+        return vpns;
     }
-    return validateDeleteAfter(deleteAfter, vpnConfigLimits);
+    const sorted = [...vpns].sort((a, b) => {
+        let compareResult = 0;
+        const aCityLocation = getCityByGeonamesId(a.geonamesId);
+        const bCityLocation = getCityByGeonamesId(b.geonamesId);
+        switch (sortBy) {
+            case ListVpnsSortByCriteria.City:
+                compareResult = aCityLocation.city.localeCompare(bCityLocation.city);
+                break;
+            case ListVpnsSortByCriteria.Country:
+                compareResult = aCityLocation.country.localeCompare(bCityLocation.country);
+                break;
+            case ListVpnsSortByCriteria.GeonamesId:
+                compareResult = a.geonamesId - b.geonamesId;
+                break;
+            case ListVpnsSortByCriteria.State:
+                compareResult = toRank(a.state) - toRank(b.state);
+                break;
+            case ListVpnsSortByCriteria.CreatedAt:
+            default:
+                compareResult = a.createdAt.getTime() - b.createdAt.getTime();
+                break;
+        }
+        return sortOrder === ListVpnsSortOrder.Desc ? -compareResult : compareResult;
+    });
+    return sorted;
 }
-function newVpn(region, config, state) {
-    // e.g: ap-northeast-3
-    if (!/[a-z]{2}-[a-z]+-[1-9]+/.test(region)) {
-        throw new errors_1.MyTmpVpnError(`Incorrect region: \'${region}\'`);
+exports.sortVpns = sortVpns;
+function newVpn(geonamesId, config, state) {
+    if (!Number.isInteger(geonamesId) || geonamesId <= 0) {
+        throw new errors_1.MyTmpVpnError(`Incorrect geonamesId: \'${geonamesId}\'`);
     }
     const createdAt = new Date();
-    const vpnId = `${dateToId(createdAt)}@${region}`;
+    const vpnId = (0, uuid_1.v4)();
     // Assert we will be able to deserialize later on...
     validateVpnId(vpnId);
     return {
         vpnId,
         createdAt,
-        region,
+        geonamesId,
         config,
         state
     };
 }
 exports.newVpn = newVpn;
-function getVpnFrom(vpnId, state, config) {
-    validateVpnId(vpnId);
-    const tokens = vpnId.split('@');
-    if (tokens.length !== 2) {
-        throw new errors_1.MyTmpVpnError(`Incorrect vpnId: ${vpnId}`);
+function getVpnFrom(vpnId, createdAt, geonamesId, state, config) {
+    const version = validateVpnId(vpnId);
+    let finalCreatedAt;
+    switch (version) {
+        case uservpn_1.UserVpnVersion.INITIAL:
+            // Legacy vpnId format, the createdAt is given from the vpnId itself
+            if (createdAt !== undefined) {
+                throw new errors_1.MyTmpVpnError(`Invalid parameter: createdAt must be undefined when vpnId version is INITIAL: vpnId=${vpnId}; createdAt=${createdAt}`);
+            }
+            const tokens = vpnId.split('@');
+            if (tokens.length !== 2) {
+                throw new errors_1.MyTmpVpnError(`Incorrect vpnId: ${vpnId}`);
+            }
+            /* eslint-disable @typescript-eslint/no-non-null-assertion */
+            finalCreatedAt = idToDate(tokens[0]);
+            /* eslint-enable @typescript-eslint/no-non-null-assertion */
+            break;
+        case uservpn_1.UserVpnVersion.LOCATIONS:
+            // New vpnId format
+            if (createdAt === undefined) {
+                throw new errors_1.MyTmpVpnError(`Invalid parameter: createdAt can't be undefined: vpnId=${vpnId}`);
+            }
+            finalCreatedAt = createdAt;
+            break;
+        default:
+            throw new errors_1.MyTmpVpnError(`Incorrect version: \'${version}\'`);
     }
-    /* eslint-disable @typescript-eslint/no-non-null-assertion */
-    const createdAt = idToDate(tokens[0]);
-    const region = tokens[1];
-    /* eslint-enable @typescript-eslint/no-non-null-assertion */
     return {
         vpnId,
-        createdAt,
-        region,
+        createdAt: finalCreatedAt,
+        geonamesId,
         config,
         state
     };
@@ -176,6 +189,7 @@ function dateToId(date) {
     // YYYY-MM-DDTHH:mm:ss.uuuZ -> YYYYMMDDHHmmssuuu
     return date.toISOString().replace(/[^\d]/g, '');
 }
+exports.dateToId = dateToId;
 function idToDate(id) {
     // YYYYMMDDHHmmssuuu -> YYYY-MM-DDTHH:mm:ss.uuuZ
     const year = id.substring(0, 4);
@@ -187,60 +201,25 @@ function idToDate(id) {
     const millis = id.substring(14);
     return new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}.${millis}Z`);
 }
+exports.idToDate = idToDate;
 // The WireGuard Mobile Application has requirements for the wireguard configuration file:
 // 1. must have extension '.conf'
 // 2. file name must match the following regexp: "[a-zA-Z0-9_=+.-]{1,15}")
 // https://git.zx2c4.com/wireguard-android/tree/tunnel/src/main/java/com/wireguard/android/backend/Tunnel.java#n19
-// This function is to transform from vpnIn to Wireguard mobile application requirements
-function vpnIdToWgFileName(vpnId) {
-    validateVpnId(vpnId);
-    // The vpnId is made of YYYYMMDDHHmmssmss@region
-    // Let's keep it simple: vpn is mostly temporary, so keeping 
-    // the year is useless. 
-    // Also the milliseconds are useless.
-    // Finally, the region itself is of the following format: ap-northeast-3
-    // We can compressing with something like:
-    // MMDDHHmmssapne3.conf
-    const ddhhmmss = vpnId.substring(4, 14);
-    const seps = vpnId.substring(18).split(/-/);
-    const ccld = seps[0];
-    let location;
-    switch (seps[1]) {
-        case 'north':
-            location = 'n';
-            break;
-        case 'northeast':
-            location = 'ne';
-            break;
-        case 'east':
-            location = 'e';
-            break;
-        case 'southeast':
-            location = 'se';
-            break;
-        case 'south':
-            location = 's';
-            break;
-        case 'southwest':
-            location = 'sw';
-            break;
-        case 'west':
-            location = 'w';
-            break;
-        case 'northwest':
-            location = 'nw';
-            break;
-        case 'central':
-            location = 'c';
-            break;
-        default:
-            '';
-            break;
-    }
-    const number = seps[2];
-    // Let's make sure the end file is of 15 char max
-    const result = `${ddhhmmss}${ccld}${location}${number}`.substring(0, 15);
-    loglevel_1.default.info(`Transforming ${vpnId} to ${result}`);
+// This function is to transform from vpnId to Wireguard mobile application requirements
+function vpnIdToWgFileName(vpn) {
+    const version = validateVpnId(vpn.vpnId);
+    // We will create a file name from the createdAt field and the location so for the end-user
+    // it will be easier to distinguish. Also the vpnId is to big anyway.
+    // Note that using the createdAt field makes it simpler across versions as
+    // all versions must have this field. 
+    // Let's keep it simple: vpn is mostly temporary, so keeping
+    // the year is useless. Also the milliseconds are useless.
+    // Return an id from the vpn.createdAt Date object with the following format
+    // MMDDHHmmss.conf
+    const result = vpn.createdAt.toISOString() // This will create YYYY-MM-DDThh:mm:ss....
+        .replace(/[^\d]/g, '') // Remove meanless characters: YYYYMMDDhhmmss
+        .substring(4, 14); // Use only MMDDhhmmss
     return result;
 }
 exports.vpnIdToWgFileName = vpnIdToWgFileName;
@@ -248,20 +227,27 @@ function vpnToClient(vpn) {
     return {
         vpnId: vpn.vpnId,
         state: vpn.state,
-        region: vpn.region,
+        geonamesId: vpn.geonamesId,
         createdAt: vpn.createdAt,
         config: {
             type: vpn.config.type,
             deleteAfter: vpn.config.deleteAfter,
             maxPeanuts: (0, peanuts_1.peanutsToClient)(vpn.config.maxPeanuts),
-            // terminationReason: userVpn.vpn.config.terminationReason,
-            // terminationMessage: userVpn.vpn.config.terminationMessage,
-            // terminationCode: userVpn.vpn.config.terminationCode,
-            // terminationType: userVpn.vpn.config.terminationType,
         }
     };
 }
 exports.vpnToClient = vpnToClient;
+function vpnFromServer(vpn) {
+    // Transform from JSON to Plain object, especially Date object are not de-serialized automatically
+    return {
+        vpnId: vpn.vpnId,
+        createdAt: new Date(vpn.createdAt),
+        geonamesId: vpn.geonamesId,
+        config: vpn.config,
+        state: vpn.state,
+    };
+}
+exports.vpnFromServer = vpnFromServer;
 function metricsToClient(metrics) {
     return (metrics != null)
         ? {

package/dist/src/models/vpnConfig.d.ts

@@ -0,0 +1,22 @@
+export declare enum VpnType {
+    WireGuard = "wireguard"
+}
+export interface VpnConfigLimits {
+    deleteAfterFieldMinValue: number;
+    deleteAfterFieldMaxValue: number;
+    maxPeanutsFieldMinValue: number;
+    maxPeanutsFieldMaxValue: number;
+}
+export interface ValidDeleteAfterConfig {
+    min: number;
+    max: number;
+}
+export interface VpnConfig {
+    type: VpnType;
+    maxPeanuts: number;
+    deleteAfter?: number;
+}
+export type GetVpnConfigLimitsResponse = VpnConfigLimits;
+export type GetVpnConfigResponse = string;
+export declare function getVpnConfigTypes(): VpnType[];
+export declare function checkValidConfig(userId: string, currentBalance: number, vpnConfigLimits: VpnConfigLimits, vpnConfig: any): VpnConfig;

package/dist/src/models/vpnConfig.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkValidConfig = exports.getVpnConfigTypes = exports.VpnType = void 0;
+const errors_1 = require("../errors");
+const loglevel_1 = require("loglevel");
+var VpnType;
+(function (VpnType) {
+    VpnType["WireGuard"] = "wireguard";
+})(VpnType = exports.VpnType || (exports.VpnType = {}));
+function getVpnConfigTypes() {
+    return Object.values(VpnType).filter((item) => {
+        return isNaN(Number(item));
+    });
+}
+exports.getVpnConfigTypes = getVpnConfigTypes;
+function validateMaxPeanuts(peanuts, currentBalance, vpnConfigLimits) {
+    // No matter what, if currentBalance is negative, we fail
+    if (currentBalance <= 0) {
+        throw new errors_1.NegativeBalanceError(currentBalance);
+    }
+    if (peanuts <= 0) {
+        // result = Math.min(currentBalance, vpnConfigLimits.maxPeanutsFieldMaxValue)
+        // This is always safe as it means run as long as there are enough peanuts
+        return -1;
+    }
+    if (peanuts > currentBalance) {
+        throw new errors_1.NotEnoughPeanutsError(peanuts, currentBalance);
+    }
+    if (peanuts < vpnConfigLimits.maxPeanutsFieldMinValue) {
+        throw new errors_1.MinPeanutsError(vpnConfigLimits.maxPeanutsFieldMinValue, peanuts, currentBalance);
+    }
+    if (peanuts > vpnConfigLimits.maxPeanutsFieldMaxValue) {
+        throw new errors_1.MaxPeanutsError(vpnConfigLimits.maxPeanutsFieldMaxValue, peanuts, currentBalance);
+    }
+    return peanuts;
+}
+function validateDeleteAfter(deleteAfter, vpnConfigLimits) {
+    if (deleteAfter === undefined) {
+        return vpnConfigLimits.deleteAfterFieldMaxValue;
+    }
+    if (deleteAfter < vpnConfigLimits.deleteAfterFieldMinValue) {
+        throw new errors_1.MinDeleteAfterError(vpnConfigLimits.deleteAfterFieldMinValue, deleteAfter);
+    }
+    if (deleteAfter > vpnConfigLimits.deleteAfterFieldMaxValue) {
+        throw new errors_1.MaxDeleteAfterError(vpnConfigLimits.deleteAfterFieldMaxValue, deleteAfter);
+    }
+    return deleteAfter;
+}
+// vpnConfig is of type any here because it could come from user input such as json
+function checkValidConfig(userId, currentBalance, vpnConfigLimits, vpnConfig) {
+    const maxPeanuts = checkValidMaxPeanuts(userId, currentBalance, vpnConfig.maxPeanuts, vpnConfigLimits);
+    const type = checkValidVpnType(vpnConfig.type);
+    const deleteAfter = checkValidDeleteAfter(vpnConfig.deleteAfter, vpnConfigLimits);
+    const result = {
+        maxPeanuts,
+        type,
+        deleteAfter
+    };
+    return result;
+}
+exports.checkValidConfig = checkValidConfig;
+function checkValidMaxPeanuts(userId, currentBalance, maxPeanuts, vpnConfigLimits) {
+    const peanuts = maxPeanuts ? Number.parseFloat(maxPeanuts) : -1;
+    if (Number.isNaN(peanuts) || !Number.isFinite(peanuts)) {
+        throw new errors_1.InvalidVpnConfigError(`Config maxPeanuts is invalid: ${maxPeanuts}`);
+    }
+    loglevel_1.default.debug(`Validating peanuts for ${userId}, peanuts: ${peanuts}, currentBalance: ${currentBalance}`);
+    return validateMaxPeanuts(peanuts, currentBalance, vpnConfigLimits);
+}
+function checkValidVpnType(jsonType) {
+    if (!jsonType) {
+        throw new errors_1.InvalidVpnConfigError(`Config type is null or undefined: ${jsonType}`);
+    }
+    const type = jsonType;
+    if (!type || !Object.values(VpnType).includes(type)) {
+        throw new errors_1.InvalidVpnConfigError(`Config type is invalid: ${jsonType}`);
+    }
+    return type;
+}
+function checkValidDeleteAfter(jsonDeleteAfter, vpnConfigLimits) {
+    if (jsonDeleteAfter === undefined) {
+        return validateDeleteAfter(undefined, vpnConfigLimits);
+    }
+    const deleteAfter = Number.parseInt(jsonDeleteAfter);
+    if (Number.isNaN(deleteAfter)) {
+        throw new errors_1.InvalidVpnConfigError(`Config deleteAfter is invalid: ${jsonDeleteAfter}`);
+    }
+    return validateDeleteAfter(deleteAfter, vpnConfigLimits);
+}

package/dist/test/models.test.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
 const uservpn_1 = require("../src/models/uservpn");
 const errors_1 = require("../src/errors");
 const vpn_1 = require("../src/models/vpn");
+const vpnConfig_1 = require("../src/models/vpnConfig");
 describe('Testing VpnState', () => {
     it('should check that all VpnState are ordered properly', async () => {
         expect((0, vpn_1.toRank)(vpn_1.VpnState.Creating) <= (0, vpn_1.toRank)(vpn_1.VpnState.Created)).toBe(true);
@@ -19,69 +21,77 @@ describe('Testing VpnState', () => {
     });
 });
 describe('Testing Vpn constructors', () => {
-    it('Should shout when regions is empty', async () => {
-        expect(() => (0, vpn_1.newVpn)('', { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }, vpn_1.VpnState.Created))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect region: \'\'"));
+    it('Should shout when geonamesId is zero', async () => {
+        expect(() => (0, vpn_1.newVpn)(0, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }, vpn_1.VpnState.Created))
+            .toThrow(new errors_1.MyTmpVpnError("Incorrect geonamesId: \'0\'"));
     });
-    it('Should shout when regions is bad format', async () => {
-        expect(() => (0, vpn_1.newVpn)('foo', { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }, vpn_1.VpnState.Created))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect region: \'foo\'"));
+    it('Should shout when geonamesId is negative', async () => {
+        expect(() => (0, vpn_1.newVpn)(-1, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }, vpn_1.VpnState.Created))
+            .toThrow(new errors_1.MyTmpVpnError("Incorrect geonamesId: \'-1\'"));
     });
     it('Should create vpn with all mandatory fields set', async () => {
-        const vpn = (0, vpn_1.newVpn)('az-test-7', { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }, vpn_1.VpnState.Created);
+        const vpn = (0, vpn_1.newVpn)(4140963, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }, vpn_1.VpnState.Created);
         expect(vpn.createdAt).toBeDefined();
-        expect(vpn.region).toEqual('az-test-7');
+        expect(vpn.geonamesId).toEqual(4140963);
         expect(vpn.state).toEqual(vpn_1.VpnState.Created);
         expect(vpn.config).toEqual({ maxPeanuts: -1, type: vpn_1.VpnType.WireGuard });
         expect(vpn.vpnId).toBeDefined();
+        expect((0, vpn_1.validateVpnId)(vpn.vpnId)).toEqual(uservpn_1.UserVpnVersion.LOCATIONS);
     });
     it('Should create vpn with optional fields set', async () => {
-        const vpn = (0, vpn_1.newVpn)('az-test-7', {
+        const vpn = (0, vpn_1.newVpn)(4140963, {
             maxPeanuts: -1,
             type: vpn_1.VpnType.WireGuard,
             deleteAfter: 37,
         }, vpn_1.VpnState.Created);
         expect(vpn.createdAt).toBeDefined();
-        expect(vpn.region).toEqual('az-test-7');
+        expect(vpn.geonamesId).toEqual(4140963);
         expect(vpn.state).toEqual(vpn_1.VpnState.Created);
         expect(vpn.config).toEqual({ maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: 37 });
         expect(vpn.vpnId).toBeDefined();
     });
     it('Should create vpn with deleteAfter set to NaN', async () => {
         const deleteAfter = Number.NaN;
-        const vpn = (0, vpn_1.newVpn)('az-test-7', {
+        const vpn = (0, vpn_1.newVpn)(4140963, {
             maxPeanuts: -1,
             type: vpn_1.VpnType.WireGuard,
             deleteAfter: deleteAfter
         }, vpn_1.VpnState.Created);
         expect(vpn.createdAt).toBeDefined();
-        expect(vpn.region).toEqual('az-test-7');
+        expect(vpn.geonamesId).toEqual(4140963);
         expect(vpn.state).toEqual(vpn_1.VpnState.Created);
         expect(vpn.config).toEqual({ maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: deleteAfter });
         expect(vpn.vpnId).toBeDefined();
     });
-    it('Should deserialize a vpn with all mandatory fields set', async () => {
-        const vpn = (0, vpn_1.getVpnFrom)('20030902012345678@az-test-7', vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: 37 });
-        expect(vpn.createdAt).toEqual(new Date('2003-09-02T01:23:45.678Z'));
-        expect(vpn.region).toEqual('az-test-7');
+    it('Should deserialize a vpn with new format (geonamesId)', async () => {
+        const vpnId = (0, uuid_1.v4)();
+        const createdAt = new Date();
+        const vpn = (0, vpn_1.getVpnFrom)(vpnId, createdAt, 4140963, vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: 37 });
+        expect(vpn.createdAt).toEqual(createdAt);
+        expect(vpn.geonamesId).toEqual(4140963);
         expect(vpn.state).toEqual(vpn_1.VpnState.Created);
         expect(vpn.config).toEqual({ maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: 37 });
-        expect(vpn.vpnId).toBeDefined();
+        expect((0, vpn_1.validateVpnId)(vpn.vpnId)).toEqual(uservpn_1.UserVpnVersion.LOCATIONS);
+        expect(vpn.vpnId).toEqual(vpnId);
     });
     it('Should deserialize a vpn with deleteAfter set to NaN', async () => {
         const deleteAfter = Number.NaN;
-        const vpn = (0, vpn_1.getVpnFrom)('20030902012345678@az-test-7', vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: deleteAfter });
-        expect(vpn.createdAt).toEqual(new Date('2003-09-02T01:23:45.678Z'));
-        expect(vpn.region).toEqual('az-test-7');
+        const vpnId = (0, uuid_1.v4)();
+        const createdAt = new Date();
+        const vpn = (0, vpn_1.getVpnFrom)(vpnId, createdAt, 4140963, vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: deleteAfter });
+        expect(vpn.createdAt).toEqual(createdAt);
+        expect(vpn.geonamesId).toEqual(4140963);
         expect(vpn.state).toEqual(vpn_1.VpnState.Created);
         expect(vpn.config).toEqual({ maxPeanuts: -1, type: vpn_1.VpnType.WireGuard, deleteAfter: deleteAfter });
         expect(vpn.vpnId).toBeDefined();
+        expect((0, vpn_1.validateVpnId)(vpn.vpnId)).toEqual(uservpn_1.UserVpnVersion.LOCATIONS);
+        expect(vpn.vpnId).toEqual(vpnId);
     });
     it('Should deserialize a json vpn with all fields set', async () => {
         const originalVpn = (0, uservpn_1.newUserVpn)({
             userId: 'myId',
-            region: 'az-test-7',
-            version: 1,
+            geonamesId: 4140963,
+            version: uservpn_1.UserVpnVersion.LOCATIONS,
             config: {
                 maxPeanuts: -1,
                 type: vpn_1.VpnType.WireGuard,
@@ -94,35 +104,33 @@ describe('Testing Vpn constructors', () => {
         expect(userVpn).toEqual(originalVpn);
     });
     it('Should shout when vpnId is empty', async () => {
-        expect(() => (0, vpn_1.getVpnFrom)('', vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect vpnId: \'\'"));
+        expect(() => (0, vpn_1.getVpnFrom)('', new Date(), 4140963, vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }))
+            .toThrow(new errors_1.MyTmpVpnError("Invalid vpnId format: \'\'"));
     });
     it('Should shout when vpnId has bad format', async () => {
-        expect(() => (0, vpn_1.getVpnFrom)('foo', vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect vpnId: \'foo\'"));
+        expect(() => (0, vpn_1.getVpnFrom)('foo', new Date(), 4140963, vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }))
+            .toThrow(new errors_1.MyTmpVpnError("Invalid vpnId format: \'foo\'"));
     });
-    it('Should shout when vpnId does not hold a region in good format', async () => {
-        expect(() => (0, vpn_1.getVpnFrom)('20030902012345678@test', vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard }))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect vpnId: \'20030902012345678@test\'"));
+    it('Should accept legacy vpnId format with AWS region', async () => {
+        const vpn = (0, vpn_1.getVpnFrom)('20030902012345678@us-east-1', undefined, 4140963, vpn_1.VpnState.Created, { maxPeanuts: -1, type: vpn_1.VpnType.WireGuard });
+        expect(vpn.vpnId).toEqual('20030902012345678@us-east-1');
+        expect(vpn.geonamesId).toEqual(4140963);
     });
 });
 describe('Testing vpnId to Wireguard file name functions ', () => {
-    it('Should shout when vpnId is empty', async () => {
-        expect(() => (0, vpn_1.vpnIdToWgFileName)(''))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect vpnId: \'\'"));
-    });
-    it('Should shout when vpnId is bad format', async () => {
-        expect(() => (0, vpn_1.vpnIdToWgFileName)('foo'))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect vpnId: \'foo\'"));
-    });
-    it('Should shout when region has bad format', async () => {
-        expect(() => (0, vpn_1.vpnIdToWgFileName)('20030902012345678@test'))
-            .toThrow(new errors_1.MyTmpVpnError("Incorrect vpnId: \'20030902012345678@test\'"));
+    it('Should handle new format with GeoNames ID', async () => {
+        const vpn = (0, vpn_1.newVpn)(4140963, {
+            maxPeanuts: -1,
+            type: vpn_1.VpnType.WireGuard,
+        }, vpn_1.VpnState.Created);
+        const fileName = (0, vpn_1.vpnIdToWgFileName)(vpn);
+        expect(fileName).toBeDefined();
+        expect(fileName.length).toBeLessThanOrEqual(15);
     });
 });
 describe('Testing vpn config', () => {
     it('Should keep maxPeanuts to -1 when specified', async () => {
-        const validatedConfig = (0, vpn_1.checkValidConfig)('userId', 2, {
+        const validatedConfig = (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 0,
             maxPeanutsFieldMaxValue: 1,
             deleteAfterFieldMinValue: 1,
@@ -139,7 +147,7 @@ describe('Testing vpn config', () => {
         });
     });
     it('Should set maxPeanuts to -1 when null', async () => {
-        const validatedConfig = (0, vpn_1.checkValidConfig)('userId', 2, {
+        const validatedConfig = (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 0,
             maxPeanutsFieldMaxValue: 1,
             deleteAfterFieldMinValue: 1,
@@ -156,7 +164,7 @@ describe('Testing vpn config', () => {
         });
     });
     it('Should set maxPeanuts to -1 when undefined', async () => {
-        const validatedConfig = (0, vpn_1.checkValidConfig)('userId', 2, {
+        const validatedConfig = (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 0,
             maxPeanutsFieldMaxValue: 1,
             deleteAfterFieldMinValue: 1,
@@ -173,7 +181,7 @@ describe('Testing vpn config', () => {
         });
     });
     it('Should shout when currentBalance is negative', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', -1, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', -1, {
             maxPeanutsFieldMinValue: 2,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 1,
@@ -185,7 +193,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.NegativeBalanceError(-1));
     });
     it('Should shout when currentBalance is zero', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 0, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 0, {
             maxPeanutsFieldMinValue: 2,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 1,
@@ -197,7 +205,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.NegativeBalanceError(0));
     });
     it('Should shout when maxPeanuts is Infinity', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 2,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 1,
@@ -209,7 +217,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.InvalidVpnConfigError('Config maxPeanuts is invalid: Infinity'));
     });
     it('Should shout when maxPeanuts is -Infinity', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 2,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 1,
@@ -221,7 +229,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.InvalidVpnConfigError('Config maxPeanuts is invalid: -Infinity'));
     });
     it('Should shout when maxPeanuts is not a number', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 2,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 1,
@@ -233,7 +241,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.InvalidVpnConfigError('Config maxPeanuts is invalid: Not a number'));
     });
     it('Should shout when maxPeanuts is below the validPeanutsConfig minimum', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 2,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 1,
@@ -245,7 +253,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.MinPeanutsError(2, 1, 2));
     });
     it('Should shout when maxPeanuts is above the validPeanutsConfig maximum', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 10, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 10, {
             maxPeanutsFieldMinValue: 2,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 1,
@@ -257,7 +265,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.MaxPeanutsError(3, 5, 10));
     });
     it('Should shout when deleteAfter is below the validPeanutsConfig minimum', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 1,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 3,
@@ -269,7 +277,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.MinDeleteAfterError(3, 1));
     });
     it('Should shout when deleteAfter is greater the validPeanutsConfig maximum', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 1,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 3,
@@ -281,7 +289,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.MaxDeleteAfterError(5, 7));
     });
     it('Should shout when deleteAfter is positive infinity', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 1,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 3,
@@ -293,7 +301,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.InvalidVpnConfigError('Config deleteAfter is invalid: Infinity'));
     });
     it('Should shout when deleteAfter is negative infinity', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 1,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 3,
@@ -305,7 +313,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.InvalidVpnConfigError('Config deleteAfter is invalid: -Infinity'));
     });
     it('Should shout when deleteAfter is not a number', async () => {
-        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+        expect(() => (0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 1,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 3,
@@ -317,7 +325,7 @@ describe('Testing vpn config', () => {
         })).toThrow(new errors_1.InvalidVpnConfigError('Config deleteAfter is invalid: Not a number'));
     });
     it('Should not shout when deleteAfter is undefined', async () => {
-        expect((0, vpn_1.checkValidConfig)('userId', 2, {
+        expect((0, vpnConfig_1.checkValidConfig)('userId', 2, {
             maxPeanutsFieldMinValue: 1,
             maxPeanutsFieldMaxValue: 3,
             deleteAfterFieldMinValue: 3,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytmpvpn/mytmpvpn-common",
-  "version": "9.0.0",
+  "version": "10.0.2",
   "description": "Common library for all MyTmpVpn related projects",
   "types": "dist/src/index.d.ts",
   "files": [
@@ -44,6 +44,7 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "loglevel": "^1.9.2"
+    "loglevel": "^1.9.2",
+    "uuid": "^11.1.0"
   }
 }

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../.eslintrc.js","../jest.config.js","../src/errors.ts","../src/index.ts","../src/utils.ts","../src/models/index.ts","../src/models/peanuts.ts","../src/models/referral.ts","../src/models/uservpn.ts","../src/models/vpn.ts","../test/models.test.ts"],"version":"5.9.3"}