@beseif-solutions/prow-core 0.0.16

package/dist/minified-utils/locales.d.ts

@@ -0,0 +1,27 @@
+import I18n from 'i18n';
+import { Credentials, SessionCredentials, StaticCredentials } from '../entities/credentials';
+import { Action, ConnectableEvent, Trigger } from '../entities/events';
+import { Field } from './fields';
+import { Provider } from '../entities/provider';
+type LocalizedField = {
+    label: string;
+    help: string;
+};
+type LocalizedProperties = {
+    name: string;
+    description: string;
+};
+type TOptions = {
+    fallback?: boolean;
+};
+export declare const i18n: (directory: string, options?: {
+    locale?: string;
+}) => {
+    t: (code: string, opts?: TOptions) => string;
+    i18n: I18n.I18n;
+};
+export declare const localizeFields: (t: ReturnType<typeof i18n>[`t`], element: Action | Trigger | StaticCredentials | SessionCredentials) => Field<LocalizedField>[];
+export declare const localizeProperties: (t: ReturnType<typeof i18n>[`t`], element: Action | Trigger | Credentials | Provider) => LocalizedProperties;
+export declare const localizeInputs: (t: ReturnType<typeof i18n>[`t`], element: Action) => (ConnectableEvent & LocalizedProperties)[];
+export declare const localizeOutputs: (t: ReturnType<typeof i18n>[`t`], element: Action | Trigger) => (ConnectableEvent & LocalizedProperties)[];
+export {};

package/dist/minified-utils/locales.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localizeOutputs = exports.localizeInputs = exports.localizeProperties = exports.localizeFields = exports.i18n = void 0;
+const i18n_1 = __importDefault(require("i18n"));
+const lodash_1 = __importDefault(require("lodash"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const DEFAULT_LOCALE = `en`;
+const i18n = (directory, options = {}) => {
+    try {
+        if (!(0, utils_1.validateDirectory)(directory)) {
+            throw new Error(`Invalid directory: ${directory}`);
+        }
+        const availableLocales = fs_1.default.readdirSync(directory).map((file) => path_1.default.basename(file, path_1.default.extname(file)));
+        const requestedLocale = options.locale || DEFAULT_LOCALE;
+        const activeLocale = availableLocales.includes(requestedLocale) ? requestedLocale : DEFAULT_LOCALE;
+        const i18nInstance = new i18n_1.default.I18n({
+            locales: availableLocales,
+            directory: directory,
+            defaultLocale: DEFAULT_LOCALE,
+            objectNotation: true,
+            autoReload: true,
+            missingKeyFn: () => ``,
+        });
+        i18nInstance.setLocale(activeLocale);
+        return {
+            t: (code, opts = {}) => {
+                let response = i18nInstance.__(code);
+                if (!response && opts.fallback) {
+                    response = i18nInstance.__({ phrase: code, locale: DEFAULT_LOCALE });
+                }
+                return response;
+            }, i18n: i18nInstance,
+        };
+    }
+    catch (e) {
+        throw e;
+    }
+};
+exports.i18n = i18n;
+const localizeField = (t, element, field, parent = ``) => {
+    const key = lodash_1.default.compact([parent, field.key]).join(`.`);
+    field.label = t(`${element}.fields.${key}.label`, { fallback: true });
+    field.help = t(`${element}.fields.${key}.help`);
+    if (field.type === `dict` && field.items) {
+        field.items = field.items.map((f) => localizeField(t, element, f, `${key}.items`));
+    }
+    else if (`format` in field && field.format === `select` && lodash_1.default.isArray(field.choices)) {
+        field.choices = field.choices.map((fc) => ({
+            ...fc,
+            label: t(`${element}.fields.${key}.choices.${fc.key}.label`, { fallback: true }),
+            help: t(`${element}.fields.${key}.choices.${fc.key}.help`),
+        }));
+    }
+    return field;
+};
+const localizeFields = (t, element) => {
+    const response = [];
+    if (element[`fields`] && element[`fields`].length > 0) {
+        response.push(...element[`fields`].map((f) => localizeField(t, element.id, f)));
+    }
+    return response;
+};
+exports.localizeFields = localizeFields;
+const localizeProperties = (t, element) => ({
+    name: t(`${element.id}.name`, { fallback: true }),
+    description: t(`${element.id}.description`),
+});
+exports.localizeProperties = localizeProperties;
+const localizeConnectable = (t, element, type) => {
+    const response = [];
+    if (element[type] && element[type].length > 0) {
+        response.push(...element[type].map((c) => ({
+            ...c,
+            name: t(`${element.id}.${type}.${c.key}.name`, { fallback: true }),
+            description: t(`${element.id}.${type}.${c.key}.description`),
+        })));
+    }
+    return response;
+};
+const localizeInputs = (t, element) => localizeConnectable(t, element, `inputs`);
+exports.localizeInputs = localizeInputs;
+const localizeOutputs = (t, element) => localizeConnectable(t, element, `outputs`);
+exports.localizeOutputs = localizeOutputs;

package/dist/minified-utils/proxy.d.ts

@@ -0,0 +1,9 @@
+import { AsyncReturnType } from "./types";
+export type ProxyLogs<F extends (...args: any[]) => any> = {
+    before?: (name: string, args: Parameters<F>) => (void | Promise<void>);
+    after?: (name: string, response: AsyncReturnType<F>) => (void | Promise<void>);
+    error?: (name: string, error: Error) => (void | Promise<void>);
+};
+export declare const logProxy: <F extends (...args: any[]) => any>(name: string, f: F, logs?: ProxyLogs<F>) => F;
+export declare const functionProxy: <F extends (...args: any[]) => (any | Promise<any>)>(f: F, name?: string) => F;
+export declare const accessProxy: <T extends object>(obj: T, custom?: Partial<{ [K in keyof T]: T[K]; }>) => T;

package/dist/minified-utils/proxy.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accessProxy = exports.functionProxy = exports.logProxy = void 0;
+const logProxy = (name, f, logs = {}) => new Proxy(f, {
+    apply: async (target, self, args) => {
+        try {
+            if (logs.before) {
+                await logs.before(name, args);
+            }
+            const response = await target(...args);
+            if (logs.after) {
+                await logs.after(name, response);
+            }
+            return response;
+        }
+        catch (e) {
+            if (logs.error) {
+                await logs.error(name, e);
+            }
+            throw e;
+        }
+    },
+});
+exports.logProxy = logProxy;
+const functionProxy = (f, name) => new Proxy(f, {
+    apply: async (target, self, args) => {
+        try {
+            console.log(`Call to ${name || target}`);
+            const response = await target(...args);
+            return response;
+        }
+        catch (e) {
+            throw e;
+        }
+    },
+});
+exports.functionProxy = functionProxy;
+const accessProxy = (obj, custom) => new Proxy(obj, {
+    get: (target, prop) => {
+        const value = target[prop];
+        if (custom && custom[prop]) {
+            return custom[prop];
+        }
+        else if (typeof value === `function`) {
+            return (0, exports.functionProxy)(value, prop);
+        }
+        else if (typeof value === `object`) {
+            return (0, exports.accessProxy)(value);
+        }
+        else {
+            return value;
+        }
+    },
+});
+exports.accessProxy = accessProxy;

package/dist/minified-utils/types.d.ts

@@ -0,0 +1,11 @@
+export type RequireMinOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>>;
+}[Keys];
+export type RequireOne<T extends Record<string, any>, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
+}[Keys];
+export type OneOf<T extends Record<string, any>> = Partial<RequireOne<T>>;
+export type DeepPartial<T extends Record<string, any>> = {
+    [P in keyof T]?: T[P] extends Record<string, any> ? DeepPartial<T[P]> : T[P];
+};
+export type AsyncReturnType<T extends (...args: any[]) => any> = T extends (...args: any[]) => Promise<infer U> ? U : T extends (...args: any[]) => infer U ? U : any;

package/dist/minified-utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/minified-utils/utils.d.ts

@@ -0,0 +1 @@
+export declare const validateDirectory: (directory: string) => boolean;

package/dist/minified-utils/utils.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateDirectory = void 0;
+const fs_1 = __importDefault(require("fs"));
+const validateDirectory = (directory) => {
+    try {
+        if (!fs_1.default.existsSync(directory)) {
+            console.error(`Directory does not exist: ${directory}`);
+            return false;
+        }
+        const files = fs_1.default.readdirSync(directory);
+        if (!files.some((file) => file.endsWith(`.json`))) {
+            console.error(`No valid localization files found in directory: ${directory}`);
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(`Error validating directory: ${error.message}`);
+        return false;
+    }
+};
+exports.validateDirectory = validateDirectory;

package/dist/minified-utils/where.d.ts

@@ -0,0 +1,40 @@
+import { DeepPartial, RequireMinOne } from "./types";
+type Basic = string | number | boolean;
+type Is<T extends Basic> = {
+    is: T;
+};
+type Like<T extends Basic> = T extends string ? {
+    like: T;
+} : undefined;
+type ILike<T extends Basic> = T extends string ? {
+    ilike: T;
+} : undefined;
+type In<T extends Basic> = {
+    in: T[];
+};
+type Range<T extends Basic> = RequireMinOne<{
+    lt: T;
+    eq: T;
+    gt: T;
+    gte: T;
+    lte: T;
+}> & {
+    date?: boolean;
+};
+type Contains<T extends (Basic | Record<string, any>)[]> = {
+    contains: T[number] | T;
+};
+type Complex<T extends (Basic | (Basic | Record<string, any>)[])> = T extends Basic ? Is<T> | Like<T> | ILike<T> | In<T> | Range<T> : T extends (Basic | Record<string, any>)[] ? T extends Record<string, any>[] ? Contains<DeepPartial<T[number]>[]> : Contains<T> : never;
+type Condition<T> = (T extends Basic ? T : T extends Complex<infer F> ? (Complex<F> & {
+    inverse?: boolean;
+    nullable?: boolean;
+    relational?: string;
+}) : never);
+export type Where<T extends Record<string, any> = Record<string, any>> = Partial<{
+    [K in keyof T]: T[K] extends Basic ? Condition<T[K] | Complex<T[K]>> | Condition<T[K] | Complex<T[K]>>[] : (T[K] extends Record<string, any> ? Where<T[K]> : (T[K] extends any[] ? Condition<Complex<T[K]>> : never));
+}>;
+type Flags = {
+    i?: boolean;
+};
+export declare const where: (json: Record<string, any>, conditions: Where[], flags?: Flags) => boolean;
+export {};

package/dist/minified-utils/where.js

@@ -0,0 +1,265 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.where = void 0;
+const moment_timezone_1 = __importDefault(require("moment-timezone"));
+const lodash_1 = __importDefault(require("lodash"));
+const joi_1 = __importDefault(require("joi"));
+const conditionSchema = () => joi_1.default.object({
+    inverse: joi_1.default.bool(),
+    nullable: joi_1.default.bool(),
+});
+const relationalSchema = () => conditionSchema()
+    .concat(joi_1.default.object({
+    relational: joi_1.default.string().required(),
+    is: joi_1.default.string().allow(null),
+    in: joi_1.default.array().items(joi_1.default.string().allow(null)),
+    lt: joi_1.default.string().allow(null),
+    eq: joi_1.default.string().allow(null),
+    gt: joi_1.default.string().allow(null),
+    gte: joi_1.default.string().allow(null),
+    lte: joi_1.default.string().allow(null),
+}));
+const numberSchema = (params) => conditionSchema()
+    .concat(joi_1.default.object({
+    is: joi_1.default.number().strict(params.strict).allow(null),
+    in: joi_1.default.array().items(joi_1.default.number().strict(params.strict).allow(null)),
+    lt: joi_1.default.number().strict(params.strict).allow(null),
+    eq: joi_1.default.number().strict(params.strict).allow(null),
+    gt: joi_1.default.number().strict(params.strict).allow(null),
+    gte: joi_1.default.number().strict(params.strict).allow(null),
+    lte: joi_1.default.number().strict(params.strict).allow(null),
+})).or(`is`, `in`, `lt`, `eq`, `gt`, `gte`, `lte`);
+const stringSchema = (params) => conditionSchema()
+    .concat(joi_1.default.object({
+    is: joi_1.default.string().strict(params.strict).allow(null),
+    like: joi_1.default.string().strict(params.strict).allow(null),
+    ilike: joi_1.default.string().strict(params.strict).allow(null),
+    in: joi_1.default.array().items(joi_1.default.string().strict(params.strict).allow(null)),
+})).or(`is`, `ilike`, `like`, `in`);
+const boolSchema = (params) => conditionSchema()
+    .concat(joi_1.default.object({
+    is: joi_1.default.bool().strict(params.strict).allow(null),
+})).or(`is`);
+const dateSchema = (params) => conditionSchema()
+    .concat(joi_1.default.object({
+    lt: joi_1.default.date().strict(params.strict).allow(null),
+    eq: joi_1.default.date().strict(params.strict).allow(null),
+    gt: joi_1.default.date().strict(params.strict).allow(null),
+    gte: joi_1.default.date().strict(params.strict).allow(null),
+    lte: joi_1.default.date().strict(params.strict).allow(null),
+    date: true,
+})).or(`lt`, `eq`, `gt`, `gte`, `lte`);
+const arraySchema = () => conditionSchema()
+    .concat(joi_1.default.object({
+    contains: joi_1.default.alternatives(basicSchema(), joi_1.default.array().items(joi_1.default.any()), joi_1.default.object()
+        .pattern(joi_1.default.string(), joi_1.default.alternatives(basicSchema(), joi_1.default.array().items(joi_1.default.any()), joi_1.default.link(`#object`)))
+        .id(`object`)),
+}));
+const basicSchema = () => joi_1.default.alternatives(joi_1.default.string().strict(false), joi_1.default.number().strict(false), joi_1.default.bool().strict(false));
+const complexSchema = () => joi_1.default.alternatives(numberSchema({ strict: false }), stringSchema({ strict: false }), boolSchema({ strict: false }), dateSchema({ strict: false }), arraySchema(), relationalSchema());
+const orSchema = () => joi_1.default.array().items(joi_1.default.alternatives(basicSchema(), complexSchema()));
+const whereSchema = () => joi_1.default.object()
+    .pattern(joi_1.default.string(), joi_1.default.alternatives(basicSchema(), complexSchema(), orSchema(), joi_1.default.link(`#where`)))
+    .id(`where`);
+const clearObject = (obj, path = ``) => {
+    lodash_1.default.map(obj || {}, (v, k) => {
+        if (lodash_1.default.isUndefined(v)) {
+            lodash_1.default.unset(obj, `${path}${k}`);
+        }
+        if (lodash_1.default.isObject(v)) {
+            clearObject(v, `${k}.`);
+        }
+    });
+};
+const validate = (schema, data, options) => {
+    try {
+        if (!lodash_1.default.isFunction(schema[`validate`])) {
+            throw new Error(`Invalid schema`);
+        }
+        if (lodash_1.default.isObject(data)) {
+            clearObject(data);
+        }
+        const result = schema.validate(data, options);
+        if (result.error) {
+            throw result.error;
+        }
+        return data;
+    }
+    catch (err) {
+        throw new Error(lodash_1.default.get(err, `details.0.message`) || err.message || err);
+    }
+};
+const isBasic = (condition) => {
+    try {
+        basicSchema().validate(condition);
+        validate(basicSchema(), condition);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const isComplex = (condition) => {
+    try {
+        validate(complexSchema(), condition);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const isOr = (condition) => {
+    try {
+        validate(orSchema(), condition);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const isWhere = (condition) => {
+    try {
+        validate(whereSchema(), condition);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+const processRange = (condition, value, comparator, date) => {
+    let v1;
+    let v2;
+    let compare;
+    if (date) {
+        v1 = (0, moment_timezone_1.default)(value);
+        v2 = (0, moment_timezone_1.default)(condition);
+        switch (comparator) {
+            case `<`:
+                compare = (d1, d2) => d1.isBefore(d2);
+                break;
+            case `=`:
+                compare = (d1, d2) => !d1.isAfter(d2) && !d1.isBefore(d2);
+                break;
+            case `>`:
+                compare = (d1, d2) => d1.isAfter(d2);
+                break;
+            case `>=`:
+                compare = (d1, d2) => d1.isAfter(d2) || (!d1.isAfter(d2) && !d1.isBefore(d2));
+                break;
+            case `<=`:
+                compare = (d1, d2) => d1.isBefore(d2) || (!d1.isAfter(d2) && !d1.isBefore(d2));
+                break;
+        }
+    }
+    else {
+        v1 = value;
+        v2 = condition;
+        switch (comparator) {
+            case `<`:
+                compare = (d1, d2) => d1 < d2;
+                break;
+            case `=`:
+                compare = (d1, d2) => d1 === d2;
+                break;
+            case `>`:
+                compare = (d1, d2) => d1 > d2;
+                break;
+            case `>=`:
+                compare = (d1, d2) => d1 >= d2;
+                break;
+            case `<=`:
+                compare = (d1, d2) => d1 <= d2;
+                break;
+        }
+    }
+    return compare(v1, v2);
+};
+const processBasic = (value, condition, flags) => (typeof value === `string` && typeof condition === `string` && flags?.i) ?
+    value.toLowerCase() === condition.toLowerCase()
+    : value === condition;
+const processComplex = (value, condition, flags) => {
+    const results = [];
+    const withNullable = (bool, val) => (bool || condition.nullable && lodash_1.default.isNull(val));
+    const withInverse = (bool) => bool !== condition.inverse;
+    if (`is` in condition) {
+        const is = (typeof value === `string` && typeof condition.is === `string` && flags?.i) ?
+            value.toLowerCase() === condition.is.toLowerCase()
+            : value === condition.is;
+        results.push(withInverse(withNullable(is, value)));
+    }
+    if (`like` in condition) {
+        const regexp = new RegExp(`^${condition.like.replace(/%/g, `.*`).replace(/_/g, `.`)}$`);
+        const like = regexp.test(value);
+        results.push(withInverse(withNullable(like, value)));
+    }
+    if (`ilike` in condition) {
+        const regexp = new RegExp(`^${condition.ilike.replace(/%/g, `.*`).replace(/_/g, `.`)}$`, `i`);
+        const ilike = regexp.test(value);
+        results.push(withInverse(withNullable(ilike, value)));
+    }
+    if (`in` in condition) {
+        const isIn = (condition.in && condition.in.length > 0) ?
+            lodash_1.default.includes(condition.in, value) :
+            lodash_1.default.isNull(value);
+        results.push(withInverse(withNullable(isIn, value)));
+    }
+    if (`lt` in condition) {
+        const lt = processRange(condition.lt, value, `<`, condition.date || false);
+        results.push(withInverse(withNullable(lt, value)));
+    }
+    if (`eq` in condition) {
+        const eq = processRange(condition.eq, value, `=`, condition.date || false);
+        results.push(withInverse(withNullable(eq, value)));
+    }
+    if (`gt` in condition) {
+        const gt = processRange(condition.gt, value, `>`, condition.date || false);
+        results.push(withInverse(withNullable(gt, value)));
+    }
+    if (`gte` in condition) {
+        const gte = processRange(condition.gte, value, `>=`, condition.date || false);
+        results.push(withInverse(withNullable(gte, value)));
+    }
+    if (`lte` in condition) {
+        const lte = processRange(condition.lte, value, `<=`, condition.date || false);
+        results.push(withInverse(withNullable(lte, value)));
+    }
+    return !results.some((r) => !r);
+};
+const processWhere = (json, conditions, flags) => {
+    let matches = false;
+    for (const w of conditions) {
+        let matchesWhere = true;
+        for (const key of lodash_1.default.keys(w)) {
+            const value = lodash_1.default.get(json, key, null);
+            const cond = w[key];
+            if (isOr(cond)) {
+                matchesWhere && (matchesWhere = lodash_1.default.some(cond, (c) => processWhere({ [key]: value }, [{ [key]: c }], flags)));
+            }
+            else if (isBasic(cond)) {
+                matchesWhere && (matchesWhere = processBasic(value, cond, flags));
+            }
+            else if (isComplex(cond)) {
+                matchesWhere && (matchesWhere = processComplex(value, cond, flags));
+            }
+            else if (isWhere(cond)) {
+                matchesWhere && (matchesWhere = processWhere(value, [cond], flags));
+            }
+            else {
+                continue;
+            }
+            if (!matchesWhere) {
+                break;
+            }
+        }
+        matches || (matches = matchesWhere);
+        if (matches) {
+            break;
+        }
+    }
+    return matches;
+};
+const where = (json, conditions, flags) => processWhere(json, conditions, flags);
+exports.where = where;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@beseif-solutions/prow-core",
+  "version": "0.0.16",
+  "description": "Zapdos core functionalities and classes",
+  "main": "dist/index.js",
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "npm run clean && tsc",
+    "release": "npm-run-all clean build",
+    "build_watch": "tsc --watch",
+    "run": "nodemon './dist/index.js' --watch './dist/**/*.js'",
+    "develop": "npm-run-all clean build --parallel build_watch run",
+    "start": "node dist/index.js",
+    "lint": "npx eslint -c .eslintrc.js --ext .ts src --fix"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@types/express": "^4.17.21",
+    "axios": "^1.7.7",
+    "dotenv": "^16.4.5",
+    "handlebars": "^4.7.8",
+    "i18n": "^0.15.1",
+    "joi": "^17.13.3",
+    "lodash": "^4.17.21",
+    "moment-timezone": "^0.5.46",
+    "ts-node": "^8.10.2"
+  },
+  "devDependencies": {
+    "@types/i18n": "^0.13.12",
+    "@types/lodash": "^4.14.168",
+    "@types/node": "^22.8.4",
+    "@typescript-eslint/eslint-plugin": "^5.38.0",
+    "@typescript-eslint/parser": "^5.38.0",
+    "eslint": "^8.24.0",
+    "eslint-plugin-jsdoc": "^39.3.6",
+    "eslint-plugin-prefer-arrow": "^1.2.3",
+    "nodemon": "^3.1.9",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^6.0.1",
+    "typescript": "5.6.3"
+  }
+}

package/src/core.ts

@@ -0,0 +1,56 @@
+import axios, { AxiosError, AxiosResponse } from "axios";
+import _ from "lodash";
+import moment from "moment-timezone";
+import { accessProxy, logProxy, ProxyLogs } from "./minified-utils/proxy";
+import { Env } from "./minified-utils/env";
+import { i18n } from "./minified-utils/locales";
+import path from "path";
+import Joi from "joi";
+
+export type Core = {
+  axios: typeof axios,
+  moment: typeof moment,
+  lodash: typeof _,
+  env: Env,
+  t: ReturnType<typeof i18n>[`t`],
+  joi: typeof Joi,
+};
+
+const axiosLogs = (method: string, debug = false): ProxyLogs<
+  typeof axios[`get`]
+  | typeof axios[`post`]
+  | typeof axios[`put`]
+  | typeof axios[`patch`]
+  | typeof axios[`delete`]> => ({
+    before: (name, [url]) => {
+      if (debug) { console.log(`> [${method}]`, url); }
+    },
+    after: (name, response: AxiosResponse) => {
+      if (debug) { console.log(`< [${method}]`, response.config.url, response.status); }
+    },
+    error: (name, error: AxiosError) => {
+      if (debug) { console.log(`< [${method}]`, error.config.url, error.status); }
+    },
+  });
+
+type CoreOptions = {
+  path: string,
+  debug?: boolean,
+  locale?: string,
+};
+
+/* eslint-disable @typescript-eslint/unbound-method */
+export const core = (options: CoreOptions): Core => ({
+  axios: accessProxy(axios, {
+    get: logProxy(`axios.get`, axios.get, axiosLogs(`GET`, options.debug)),
+    post: logProxy(`axios.post`, axios.post, axiosLogs(`POST`, options.debug)),
+    put: logProxy(`axios.put`, axios.put, axiosLogs(`PUT`, options.debug)),
+    patch: logProxy(`axios.patch`, axios.patch, axiosLogs(`PATCH`, options.debug)),
+    delete: logProxy(`axios.delete`, axios.delete, axiosLogs(`DELETE`, options.debug)),
+  }),
+  moment: moment,
+  lodash: _,
+  env: new Env(options.path),
+  t: i18n(path.join(options.path, `/locales`), { locale: options.locale }).t,
+  joi: Joi,
+});

package/src/entities/category.ts

@@ -0,0 +1,9 @@
+import axios from "axios";
+
+export const getCategories = async (): Promise<string[]> => {
+  try {
+    const { data } = await axios.get(`https://dev-beseif.s3.eu-west-1.amazonaws.com/prow/categories.txt`);
+    if (!data || typeof data !== `string`) { throw new Error(`Could not obtain category list`); }
+    return data.split(`\n`).map((d) => d.trim());
+  } catch (e) { throw e; }
+};