@mytmpvpn/mytmpvpn-common 6.0.0 → 6.0.2

package/dist/.eslintrc.d.ts

@@ -0,0 +1,24 @@
+export declare namespace env {
+    const browser: boolean;
+    const es2021: boolean;
+}
+declare const _extends: string[];
+export { _extends as extends };
+export declare const parser: string;
+export declare const plugins: string[];
+export declare const root: boolean;
+export declare const overrides: {
+    env: {
+        node: boolean;
+    };
+    files: string[];
+    parserOptions: {
+        sourceType: string;
+    };
+}[];
+export declare namespace parserOptions {
+    const ecmaVersion: string;
+    const project: string;
+    const sourceType: string;
+}
+export declare const rules: {};

package/dist/.eslintrc.js

@@ -0,0 +1,30 @@
+"use strict";
+module.exports = {
+    env: {
+        browser: true,
+        es2021: true
+    },
+    extends: ['standard-with-typescript', 'eslint:recommended', 'plugin:@typescript-eslint/recommended'],
+    parser: '@typescript-eslint/parser',
+    plugins: ['@typescript-eslint'],
+    root: true,
+    overrides: [
+        {
+            env: {
+                node: true
+            },
+            files: [
+                '.eslintrc.{js,cjs}'
+            ],
+            parserOptions: {
+                sourceType: 'script'
+            }
+        }
+    ],
+    parserOptions: {
+        ecmaVersion: 'latest',
+        project: './tsconfig.json',
+        sourceType: 'module'
+    },
+    rules: {}
+};

package/dist/jest.config.d.ts

@@ -0,0 +1,6 @@
+export const testEnvironment: string;
+export const roots: string[];
+export const testMatch: string[];
+export const transform: {
+    '^.+\\.tsx?$': string;
+};

package/dist/jest.config.js

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = {
+    testEnvironment: 'node',
+    roots: ['<rootDir>/test'],
+    testMatch: ['**/*.test.ts'],
+    transform: {
+        '^.+\\.tsx?$': 'ts-jest'
+    }
+};

package/dist/src/errors.d.ts

@@ -0,0 +1,24 @@
+export declare class MyTmpVpnError extends Error {
+    constructor(msg: string);
+}
+export declare class InvalidUserConfigError extends MyTmpVpnError {
+    constructor(msg: string);
+}
+export declare class InvalidVpnConfigError extends MyTmpVpnError {
+    constructor(msg: string);
+}
+export declare class MinPeanutsError extends InvalidVpnConfigError {
+    constructor(min: number, given: number, balance: number);
+}
+export declare class MaxPeanutsError extends InvalidVpnConfigError {
+    constructor(max: number, given: number, balance: number);
+}
+export declare class NotEnoughPeanutsError extends InvalidVpnConfigError {
+    constructor(given: number, balance: number);
+}
+export declare class MinDeleteAfterError extends InvalidVpnConfigError {
+    constructor(min: number, given: number);
+}
+export declare class MaxDeleteAfterError extends InvalidVpnConfigError {
+    constructor(max: number, given: number);
+}

package/dist/src/errors.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxDeleteAfterError = exports.MinDeleteAfterError = exports.NotEnoughPeanutsError = exports.MaxPeanutsError = exports.MinPeanutsError = exports.InvalidVpnConfigError = exports.InvalidUserConfigError = exports.MyTmpVpnError = void 0;
+const peanuts_1 = require("./models/peanuts");
+class MyTmpVpnError extends Error {
+    constructor(msg) {
+        super(msg); // 'Error' breaks prototype chain here
+        // See: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+    }
+}
+exports.MyTmpVpnError = MyTmpVpnError;
+class InvalidUserConfigError extends MyTmpVpnError {
+    constructor(msg) {
+        super(msg);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, InvalidUserConfigError.prototype);
+    }
+}
+exports.InvalidUserConfigError = InvalidUserConfigError;
+class InvalidVpnConfigError extends MyTmpVpnError {
+    constructor(msg) {
+        super(msg);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, InvalidVpnConfigError.prototype);
+    }
+}
+exports.InvalidVpnConfigError = InvalidVpnConfigError;
+class MinPeanutsError extends InvalidVpnConfigError {
+    constructor(min, given, balance) {
+        super(`Minimum number of peanuts should be ${min}, you specified: ${(0, peanuts_1.peanutsToClient)(given)} and you have ${(0, peanuts_1.peanutsToClient)(balance)}.`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MinPeanutsError.prototype);
+    }
+}
+exports.MinPeanutsError = MinPeanutsError;
+class MaxPeanutsError extends InvalidVpnConfigError {
+    constructor(max, given, balance) {
+        super(`Maximum number of peanuts should be ${max}, you specified: ${(0, peanuts_1.peanutsToClient)(given)} and you have ${(0, peanuts_1.peanutsToClient)(balance)}.`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MaxPeanutsError.prototype);
+    }
+}
+exports.MaxPeanutsError = MaxPeanutsError;
+class NotEnoughPeanutsError extends InvalidVpnConfigError {
+    constructor(given, balance) {
+        super(`Not enough peanuts, you specified: ${(0, peanuts_1.peanutsToClient)(given)} and you have ${(0, peanuts_1.peanutsToClient)(balance)}.`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, NotEnoughPeanutsError.prototype);
+    }
+}
+exports.NotEnoughPeanutsError = NotEnoughPeanutsError;
+class MinDeleteAfterError extends InvalidVpnConfigError {
+    constructor(min, given) {
+        super(`deleteAfter must be greater than ${min}, you specified: ${given}.`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MinDeleteAfterError.prototype);
+    }
+}
+exports.MinDeleteAfterError = MinDeleteAfterError;
+class MaxDeleteAfterError extends InvalidVpnConfigError {
+    constructor(max, given) {
+        super(`deleteAfter must be lesser than ${max}, you specified: ${given}.`);
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, MaxDeleteAfterError.prototype);
+    }
+}
+exports.MaxDeleteAfterError = MaxDeleteAfterError;

package/dist/src/index.d.ts

@@ -0,0 +1,3 @@
+export * as utils from './utils';
+export * as models from './models';
+export * as errors from './errors';

package/dist/src/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = exports.models = exports.utils = void 0;
+exports.utils = require("./utils");
+exports.models = require("./models");
+exports.errors = require("./errors");

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

@@ -0,0 +1,2 @@
+export * as vpn from './vpn';
+export * as uservpn from './uservpn';

package/dist/src/models/index.js

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

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

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+export interface PeanutsPack {
+    name: string;
+    url: URL;
+    peanuts: number;
+    price: number;
+    description: string[];
+}
+export declare function peanutsToClient(peanuts: number): number;

package/dist/src/models/peanuts.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.peanutsToClient = void 0;
+function peanutsToClient(peanuts) {
+    return Number.parseFloat(peanuts.toFixed(2));
+}
+exports.peanutsToClient = peanutsToClient;

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

@@ -0,0 +1,23 @@
+import * as vpn from './vpn';
+export interface UserVpn {
+    userId: string;
+    version: number;
+    vpn: vpn.Vpn;
+}
+export interface newUserVpnParams {
+    userId: string;
+    region: string;
+    version?: number;
+    config: vpn.VpnConfig;
+    state: vpn.VpnState;
+}
+export interface getUserVpnFromParams {
+    userId: string;
+    vpnId: string;
+    version?: number;
+    config: vpn.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 jsonToUserVpn(jsonString: any): UserVpn;

package/dist/src/models/uservpn.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jsonToUserVpn = exports.getUserVpnFrom = exports.newUserVpn = void 0;
+const vpn = require("./vpn");
+const INITIAL_VERSION = 0;
+function newUserVpn({ userId, region, version = INITIAL_VERSION, ...rest }) {
+    return {
+        userId,
+        version,
+        vpn: vpn.newVpn(region, rest.config, rest.state)
+    };
+}
+exports.newUserVpn = newUserVpn;
+function getUserVpnFrom({ userId, vpnId, version = INITIAL_VERSION, ...rest }) {
+    return {
+        userId,
+        version,
+        vpn: vpn.getVpnFrom(vpnId, rest.state, rest.config)
+    };
+}
+exports.getUserVpnFrom = getUserVpnFrom;
+function jsonToUserVpn(jsonString) {
+    const parsed = JSON.parse(jsonString, (key, value) => {
+        if (key === 'createdAt') {
+            return new Date(value);
+        }
+        return value;
+    });
+    const result = {
+        userId: parsed.userId,
+        version: parsed.version,
+        vpn: parsed.vpn
+    };
+    return parsed;
+}
+exports.jsonToUserVpn = jsonToUserVpn;

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

@@ -0,0 +1,52 @@
+import { UserVpn } from "./uservpn";
+export declare enum VpnState {
+    Failed = "Failed",
+    Creating = "Creating",
+    Created = "Created",
+    Provisioning = "Provisioning",
+    Paused = "Paused",
+    Running = "Running",
+    Deprovisioning = "Deprovisioning",
+    Deleted = "Deleted"
+}
+export declare function toRank(state: VpnState): number;
+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;
+    peanuts: number;
+}
+export interface Vpn {
+    vpnId: string;
+    createdAt: Date;
+    region: string;
+    config: VpnConfig;
+    state: VpnState;
+}
+export declare function getVpnConfigTypes(): VpnType[];
+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 declare function vpnToClient(vpn: Vpn): Vpn;
+export declare function metricsToClient(metrics: VpnMetrics | undefined): VpnMetrics;

package/dist/src/models/vpn.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+const errors_1 = require("../errors");
+const peanuts_1 = require("./peanuts");
+var VpnState;
+(function (VpnState) {
+    VpnState["Failed"] = "Failed";
+    VpnState["Creating"] = "Creating";
+    VpnState["Created"] = "Created";
+    VpnState["Provisioning"] = "Provisioning";
+    VpnState["Paused"] = "Paused";
+    VpnState["Running"] = "Running";
+    VpnState["Deprovisioning"] = "Deprovisioning";
+    VpnState["Deleted"] = "Deleted";
+})(VpnState = exports.VpnState || (exports.VpnState = {}));
+const vpnStateRank = Object.values(VpnState);
+function toRank(state) {
+    return vpnStateRank.indexOf(state);
+}
+exports.toRank = toRank;
+function fromRank(rank) {
+    return vpnStateRank[rank];
+}
+exports.fromRank = fromRank;
+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 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) {
+    let result = peanuts;
+    if (peanuts <= 0) {
+        result = Math.min(currentBalance, vpnConfigLimits.maxPeanutsFieldMaxValue);
+    }
+    if (result > currentBalance) {
+        throw new errors_1.NotEnoughPeanutsError(result, currentBalance);
+    }
+    if (result < vpnConfigLimits.maxPeanutsFieldMinValue) {
+        throw new errors_1.MinPeanutsError(vpnConfigLimits.maxPeanutsFieldMinValue, result, currentBalance);
+    }
+    if (result > vpnConfigLimits.maxPeanutsFieldMaxValue) {
+        throw new errors_1.MaxPeanutsError(vpnConfigLimits.maxPeanutsFieldMaxValue, result, currentBalance);
+    }
+    return result;
+}
+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;
+}
+// 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) {
+    // We return true only when the vpn is in a state that is below Running, and not Failed.
+    // The idea is that those ones are either already running or will soon, so they have to be 
+    // part of the quota. Others (Failed, and Deprovisioning, Deleted) are gone, so they should not count.
+    return (uservpn.vpn.state !== VpnState.Failed) && (toRank(uservpn.vpn.state) <= toRank(VpnState.Running));
+}
+exports.vpnAgainstQuotaPredicate = vpnAgainstQuotaPredicate;
+function validateVpnNbAgainstQuota(vpnNb, quota) {
+    if (vpnNb >= quota) {
+        throw new errors_1.InvalidUserConfigError(`User already has ${quota} active vpns. Quota reached.`);
+    }
+    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}`);
+    }
+    console.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);
+}
+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}\'`);
+    }
+    const createdAt = new Date();
+    const vpnId = `${dateToId(createdAt)}@${region}`;
+    // Assert we will be able to deserialize later on...
+    validateVpnId(vpnId);
+    return {
+        vpnId,
+        createdAt,
+        region,
+        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}`);
+    }
+    /* 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,
+        config,
+        state
+    };
+}
+exports.getVpnFrom = getVpnFrom;
+// Using a date from an id is convenient for debugging.
+// We can't use Date.toISOString() because some characters are forbidden
+// E.g: SFn refuse the ':'
+// So we need convertor back and forth
+function dateToId(date) {
+    // YYYY-MM-DDTHH:mm:ss.uuuZ -> YYYYMMDDHHmmssuuu
+    return date.toISOString().replace(/[^\d]/g, '');
+}
+function idToDate(id) {
+    // YYYYMMDDHHmmssuuu -> YYYY-MM-DDTHH:mm:ss.uuuZ
+    const year = id.substring(0, 4);
+    const month = id.substring(4, 6);
+    const day = id.substring(6, 8);
+    const hour = id.substring(8, 10);
+    const minute = id.substring(10, 12);
+    const second = id.substring(12, 14);
+    const millis = id.substring(14);
+    return new Date(`${year}-${month}-${day}T${hour}:${minute}:${second}.${millis}Z`);
+}
+// 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);
+    console.log(`Transforming ${vpnId} to ${result}`);
+    return result;
+}
+exports.vpnIdToWgFileName = vpnIdToWgFileName;
+function vpnToClient(vpn) {
+    return {
+        vpnId: vpn.vpnId,
+        state: vpn.state,
+        region: vpn.region,
+        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 metricsToClient(metrics) {
+    return (metrics != null)
+        ? {
+            duration: metrics.duration,
+            bytes: metrics.bytes,
+            peanuts: (0, peanuts_1.peanutsToClient)(metrics.peanuts)
+        }
+        : {
+            duration: Number.NaN,
+            bytes: Number.NaN,
+            peanuts: Number.NaN,
+        };
+}
+exports.metricsToClient = metricsToClient;

package/dist/src/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getFromEnvOrThrow(env: string): string;
+export declare function choose(choices: any[]): any;
+export declare function sleep(millis: number): Promise<void>;

package/dist/src/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = exports.choose = exports.getFromEnvOrThrow = void 0;
+const log = require("loglevel");
+function getFromEnvOrThrow(env) {
+    const result = process.env[env];
+    if (result === null || result === undefined || result.trim() === '') {
+        throw new Error(`${env} unset in environment!`);
+    }
+    log.debug(`Using ${env} = ${result}`);
+    return result;
+}
+exports.getFromEnvOrThrow = getFromEnvOrThrow;
+/* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+function choose(choices) {
+    const index = Math.floor(Math.random() * choices.length);
+    return choices[index];
+}
+exports.choose = choose;
+async function sleep(millis) {
+    await new Promise(resolve => setTimeout(resolve, millis));
+}
+exports.sleep = sleep;

package/dist/test/models.test.d.ts

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

package/dist/test/models.test.js

@@ -0,0 +1,310 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uservpn_1 = require("../src/models/uservpn");
+const errors_1 = require("../src/errors");
+const vpn_1 = require("../src/models/vpn");
+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);
+        expect((0, vpn_1.toRank)(vpn_1.VpnState.Created) <= (0, vpn_1.toRank)(vpn_1.VpnState.Provisioning)).toBe(true);
+        expect((0, vpn_1.toRank)(vpn_1.VpnState.Provisioning) <= (0, vpn_1.toRank)(vpn_1.VpnState.Running)).toBe(true);
+        expect((0, vpn_1.toRank)(vpn_1.VpnState.Paused) <= (0, vpn_1.toRank)(vpn_1.VpnState.Running)).toBe(true);
+        expect((0, vpn_1.toRank)(vpn_1.VpnState.Running) <= (0, vpn_1.toRank)(vpn_1.VpnState.Deprovisioning)).toBe(true);
+        expect((0, vpn_1.toRank)(vpn_1.VpnState.Deprovisioning) <= (0, vpn_1.toRank)(vpn_1.VpnState.Deleted)).toBe(true);
+    });
+    it('should check that state == fromRank(toRank(state))', async () => {
+        Object.values(vpn_1.VpnState).forEach(state => {
+            expect(state === (0, vpn_1.fromRank)((0, vpn_1.toRank)(state))).toBe(true);
+        });
+    });
+});
+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 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 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);
+        expect(vpn.createdAt).toBeDefined();
+        expect(vpn.region).toEqual('az-test-7');
+        expect(vpn.state).toEqual(vpn_1.VpnState.Created);
+        expect(vpn.config).toEqual({ maxPeanuts: -1, type: vpn_1.VpnType.WireGuard });
+        expect(vpn.vpnId).toBeDefined();
+    });
+    it('Should create vpn with optional fields set', async () => {
+        const vpn = (0, vpn_1.newVpn)('az-test-7', {
+            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.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', {
+            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.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');
+        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 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');
+        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 json vpn with all fields set', async () => {
+        const originalVpn = (0, uservpn_1.newUserVpn)({
+            userId: 'myId',
+            region: 'az-test-7',
+            version: 1,
+            config: {
+                maxPeanuts: -1,
+                type: vpn_1.VpnType.WireGuard,
+                deleteAfter: 37
+            },
+            state: vpn_1.VpnState.Created,
+        });
+        const jsonString = JSON.stringify(originalVpn);
+        const userVpn = (0, uservpn_1.jsonToUserVpn)(jsonString);
+        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: \'\'"));
+    });
+    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\'"));
+    });
+    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\'"));
+    });
+});
+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\'"));
+    });
+});
+describe('Testing vpn config', () => {
+    it('Should set maxPeanuts to the validPeanutsConfig maximum when set to negative', async () => {
+        const validatedConfig = (0, vpn_1.checkValidConfig)('userId', 2, {
+            maxPeanutsFieldMinValue: 0,
+            maxPeanutsFieldMaxValue: 1,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: -1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        });
+        expect(validatedConfig).toEqual({
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        });
+    });
+    it('Should set maxPeanuts to the validPeanutsConfig maximum when null', async () => {
+        const validatedConfig = (0, vpn_1.checkValidConfig)('userId', 2, {
+            maxPeanutsFieldMinValue: 0,
+            maxPeanutsFieldMaxValue: 1,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: null,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        });
+        expect(validatedConfig).toEqual({
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        });
+    });
+    it('Should set maxPeanuts to the validPeanutsConfig maximum when undefined', async () => {
+        const validatedConfig = (0, vpn_1.checkValidConfig)('userId', 2, {
+            maxPeanutsFieldMinValue: 0,
+            maxPeanutsFieldMaxValue: 1,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: undefined,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        });
+        expect(validatedConfig).toEqual({
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        });
+    });
+    it('Should shout when maxPeanuts is Infinity', async () => {
+        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+            maxPeanutsFieldMinValue: 2,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: Number.POSITIVE_INFINITY,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        })).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, {
+            maxPeanutsFieldMinValue: 2,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: Number.NEGATIVE_INFINITY,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        })).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, {
+            maxPeanutsFieldMinValue: 2,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: 'Not a number',
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        })).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, {
+            maxPeanutsFieldMinValue: 2,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        })).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, {
+            maxPeanutsFieldMinValue: 2,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 1,
+            deleteAfterFieldMaxValue: 3,
+        }, {
+            maxPeanuts: 5,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        })).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, {
+            maxPeanutsFieldMinValue: 1,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 3,
+            deleteAfterFieldMaxValue: 5,
+        }, {
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 1
+        })).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, {
+            maxPeanutsFieldMinValue: 1,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 3,
+            deleteAfterFieldMaxValue: 5,
+        }, {
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 7
+        })).toThrow(new errors_1.MaxDeleteAfterError(5, 7));
+    });
+    it('Should shout when deleteAfter is positive infinity', async () => {
+        expect(() => (0, vpn_1.checkValidConfig)('userId', 2, {
+            maxPeanutsFieldMinValue: 1,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 3,
+            deleteAfterFieldMaxValue: 5,
+        }, {
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: Number.POSITIVE_INFINITY
+        })).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, {
+            maxPeanutsFieldMinValue: 1,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 3,
+            deleteAfterFieldMaxValue: 5,
+        }, {
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: Number.NEGATIVE_INFINITY
+        })).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, {
+            maxPeanutsFieldMinValue: 1,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 3,
+            deleteAfterFieldMaxValue: 5,
+        }, {
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 'Not a number'
+        })).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, {
+            maxPeanutsFieldMinValue: 1,
+            maxPeanutsFieldMaxValue: 3,
+            deleteAfterFieldMinValue: 3,
+            deleteAfterFieldMaxValue: 5,
+        }, {
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+        })).toEqual({
+            maxPeanuts: 1,
+            type: vpn_1.VpnType.WireGuard,
+            deleteAfter: 5
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytmpvpn/mytmpvpn-common",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "description": "Common library for all MyTmpVpn related projects",
   "types": "dist/index.d.ts",
   "files": [
@@ -23,7 +23,10 @@
     "test": "jest",
     "link-deps": "echo \"No dependencies, noop; that's fine\"",
     "clean": "rm -rf dist/",
-    "upgrade": "ncu --target semver --upgrade"
+    "upgrade": "ncu --target semver --upgrade",
+    "prepublishOnly": "npm ci && npm run build && npm run test",
+    "version": "git add -A",
+    "postversion": "git push && git push --tags && npm publish"
   },
   "keywords": [],
   "author": "pierre.vigneras@gmail.com",