@beseif-solutions/prow-core 0.0.28 → 0.0.30

package/dist/core.d.ts

@@ -1,9 +1,8 @@
 import axios from "axios";
+import Joi from "joi";
 import _ from "lodash";
 import moment from "moment-timezone";
-import { Properties } from "./minified-utils/properties";
-import { i18n } from "./minified-utils/locales";
-import Joi from "joi";
+import { FromCatalog, FromDirectory, T } from "./minified-utils/locales";
 type SourceFunctions = {
     register: <T>(source: string, data: T) => Promise<{
         id: string;
@@ -18,17 +17,15 @@ export type Core = {
     axios: typeof axios;
     moment: typeof moment;
     lodash: typeof _;
-    env: Properties;
-    t: ReturnType<typeof i18n>[`t`];
+    env: Record<string, any>;
     joi: typeof Joi;
     sources?: SourceFunctions;
+    t: T;
 };
 type CoreOptions = {
-    root: string;
-    env?: Properties;
-    debug?: boolean;
-    locale?: string;
+    env?: Record<string, any>;
     sources?: SourceFunctions;
+    localization: FromDirectory | FromCatalog;
 };
 export declare const core: (options: CoreOptions) => Core;
 export {};

package/dist/core.js

@@ -5,13 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.core = void 0;
 const axios_1 = __importDefault(require("axios"));
+const joi_1 = __importDefault(require("joi"));
 const lodash_1 = __importDefault(require("lodash"));
 const moment_timezone_1 = __importDefault(require("moment-timezone"));
-const proxy_1 = require("./minified-utils/proxy");
-const properties_1 = require("./minified-utils/properties");
 const locales_1 = require("./minified-utils/locales");
-const path_1 = __importDefault(require("path"));
-const joi_1 = __importDefault(require("joi"));
 const FALLBACK_SOURCES = {
     register: async () => {
         throw new Error(`Sources not available: valid implementation not provided`);
@@ -23,36 +20,13 @@ const FALLBACK_SOURCES = {
         throw new Error(`Sources not available: valid implementation not provided`);
     },
 };
-const axiosLogs = (method, debug = false) => ({
-    before: (name, [url]) => {
-        if (debug) {
-            console.log(`> [${method}]`, url);
-        }
-    },
-    after: (name, response) => {
-        if (debug) {
-            console.log(`< [${method}]`, response.config.url, response.status);
-        }
-    },
-    error: (name, error) => {
-        if (debug) {
-            console.log(`< [${method}]`, error.config.url, error.status);
-        }
-    },
-});
 const core = (options) => ({
-    axios: (0, proxy_1.accessProxy)(axios_1.default, {
-        get: (0, proxy_1.logProxy)(`axios.get`, axios_1.default.get, axiosLogs(`GET`, options.debug)),
-        post: (0, proxy_1.logProxy)(`axios.post`, axios_1.default.post, axiosLogs(`POST`, options.debug)),
-        put: (0, proxy_1.logProxy)(`axios.put`, axios_1.default.put, axiosLogs(`PUT`, options.debug)),
-        patch: (0, proxy_1.logProxy)(`axios.patch`, axios_1.default.patch, axiosLogs(`PATCH`, options.debug)),
-        delete: (0, proxy_1.logProxy)(`axios.delete`, axios_1.default.delete, axiosLogs(`DELETE`, options.debug)),
-    }),
+    axios: axios_1.default,
     moment: moment_timezone_1.default,
     lodash: lodash_1.default,
-    env: options.env || new properties_1.Properties(options.root, `.env`),
-    t: (0, locales_1.i18n)(path_1.default.join(options.root, `/locales`), { locale: options.locale }).t,
+    env: options.env || {},
     joi: joi_1.default,
     sources: options.sources || FALLBACK_SOURCES,
+    t: (0, locales_1.i18n)(options.localization).t,
 });
 exports.core = core;

package/dist/index.d.ts

@@ -6,5 +6,6 @@ export { Action, actionOutputSchema, actionSchema, Event, eventSchema, Immediate
 export { Provider, providerSchema } from './entities/provider';
 export { Source } from './entities/source';
 export { extract, Field, fieldSchema, fieldsSchema, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
-export { i18n, localizeFields, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';
+export { i18n, localizeFields, localizeInputs, localizeOutputs, localizeProperties, LocalizedField, LocalizedProperties } from './minified-utils/locales';
 export { Properties } from './minified-utils/properties';
+export { Protocol } from './minified-utils/protocol';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Properties = exports.localizeProperties = exports.localizeOutputs = exports.localizeInputs = exports.localizeFields = exports.i18n = exports.validate = exports.fieldsSchema = exports.fieldSchema = exports.extract = exports.providerSchema = exports.triggerSchema = exports.triggerOutputSchema = exports.scheduledTriggerSchema = exports.immediateTriggerSchema = exports.eventSchema = exports.actionSchema = exports.actionOutputSchema = exports.staticCredentialsSchema = exports.sessionCredentialsSchema = exports.oauthCredentialsSchema = exports.credentialsSchema = exports.idSchema = exports.getCategories = exports.core = void 0;
+exports.Protocol = exports.Properties = exports.localizeProperties = exports.localizeOutputs = exports.localizeInputs = exports.localizeFields = exports.i18n = exports.validate = exports.fieldsSchema = exports.fieldSchema = exports.extract = exports.providerSchema = exports.triggerSchema = exports.triggerOutputSchema = exports.scheduledTriggerSchema = exports.immediateTriggerSchema = exports.eventSchema = exports.actionSchema = exports.actionOutputSchema = exports.staticCredentialsSchema = exports.sessionCredentialsSchema = exports.oauthCredentialsSchema = exports.credentialsSchema = exports.idSchema = exports.getCategories = exports.core = void 0;
 var core_1 = require("./core");
 Object.defineProperty(exports, "core", { enumerable: true, get: function () { return core_1.core; } });
 var category_1 = require("./entities/category");
@@ -35,3 +35,5 @@ Object.defineProperty(exports, "localizeOutputs", { enumerable: true, get: funct
 Object.defineProperty(exports, "localizeProperties", { enumerable: true, get: function () { return locales_1.localizeProperties; } });
 var properties_1 = require("./minified-utils/properties");
 Object.defineProperty(exports, "Properties", { enumerable: true, get: function () { return properties_1.Properties; } });
+var protocol_1 = require("./minified-utils/protocol");
+Object.defineProperty(exports, "Protocol", { enumerable: true, get: function () { return protocol_1.Protocol; } });

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

@@ -3,25 +3,37 @@ import { Credentials, SessionCredentials, StaticCredentials } from '../entities/
 import { Action, ConnectableEvent, Trigger } from '../entities/events';
 import { Field } from './fields';
 import { Provider } from '../entities/provider';
-type LocalizedField = {
+import { Source } from '../entities/source';
+export type LocalizedField = {
     label: string;
     help: string;
 };
-type LocalizedProperties = {
+export type LocalizedProperties = {
     name: string;
     description: string;
 };
 type TOptions = {
     fallback?: boolean;
 };
-export declare const i18n: (directory: string, options?: {
+export declare const validateDirectory: (directory: string) => boolean;
+type Common = {
     locale?: string;
-}) => {
-    t: (code: string, opts?: TOptions) => string;
+};
+export type FromCatalog = Common & {
+    catalog: Record<string, any>;
+};
+export type FromDirectory = Common & {
+    directory: string;
+    locale?: string;
+    write?: boolean;
+};
+export type T = (code: string, opts?: TOptions) => string;
+export declare const i18n: (options: FromCatalog | FromDirectory) => {
+    t: T;
     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 localizeFields: (t: ReturnType<typeof i18n>[`t`], element: Action | Trigger | StaticCredentials | SessionCredentials | Source) => Field<LocalizedField>[];
+export declare const localizeProperties: (t: ReturnType<typeof i18n>[`t`], element: Action | Trigger | Credentials | Provider | Source) => 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

@@ -3,29 +3,69 @@ 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;
+exports.localizeOutputs = exports.localizeInputs = exports.localizeProperties = exports.localizeFields = exports.i18n = exports.validateDirectory = 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 = {}) => {
+const validateDirectory = (directory) => {
     try {
-        if (!(0, utils_1.validateDirectory)(directory)) {
-            throw new Error(`Invalid directory: ${directory}`);
+        if (!fs_1.default.existsSync(directory)) {
+            console.error(`Directory does not exist: ${directory}`);
+            return false;
         }
-        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,
+        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;
+const i18n = (options) => {
+    try {
+        const common = {
             defaultLocale: DEFAULT_LOCALE,
             objectNotation: true,
             autoReload: false,
             missingKeyFn: () => ``,
-        });
+        };
+        const requestedLocale = options.locale || DEFAULT_LOCALE;
+        let i18nInstance;
+        let activeLocale;
+        if (`directory` in options) {
+            if (!(0, exports.validateDirectory)(options.directory)) {
+                throw new Error(`Invalid directory: ${options.directory}`);
+            }
+            const availableLocales = fs_1.default.readdirSync(options.directory).map((file) => path_1.default.basename(file, path_1.default.extname(file)));
+            activeLocale = availableLocales.includes(requestedLocale) ? requestedLocale : DEFAULT_LOCALE;
+            i18nInstance = new i18n_1.default.I18n({
+                ...common,
+                locales: availableLocales,
+                directory: options.directory,
+                updateFiles: options.write,
+                syncFiles: true,
+            });
+        }
+        else if (`catalog` in options) {
+            activeLocale = requestedLocale;
+            i18nInstance = new i18n_1.default.I18n({
+                ...common,
+                locales: [requestedLocale],
+                staticCatalog: {
+                    [requestedLocale]: options.catalog,
+                },
+            });
+        }
+        else {
+            throw new Error(`Invalid options provided for i18n function`);
+        }
         i18nInstance.setLocale(activeLocale);
         return {
             t: (code, opts = {}) => {
@@ -34,7 +74,8 @@ const i18n = (directory, options = {}) => {
                     response = i18nInstance.__({ phrase: code, locale: DEFAULT_LOCALE });
                 }
                 return response;
-            }, i18n: i18nInstance,
+            },
+            i18n: i18nInstance,
         };
     }
     catch (e) {

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

@@ -1,6 +1,7 @@
+import { DotenvParseOutput } from "dotenv";
 export declare class Properties {
     private readonly filepath;
-    private readonly properties;
+    readonly properties: DotenvParseOutput;
     private readonly getFile;
     constructor(root: string, filename: string);
     readonly read: (name: string, unknown?: boolean) => Promise<string>;

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

@@ -0,0 +1,42 @@
+import { Provider } from "../entities/provider";
+export declare class Protocol {
+    private readonly provider;
+    constructor(provider: Provider);
+    evaluate: (req: Protocol.Command) => Promise<any>;
+}
+export declare namespace Protocol {
+    type Model = `action` | `trigger` | `credentials`;
+    type Invoke = {
+        command: `invoke`;
+        model: Protocol.Model;
+        id: string;
+        params: {
+            function: string;
+            configuration: Record<string, any>;
+        };
+        context: {
+            environment: Record<string, any>;
+            localization: {
+                locale: string;
+                catalog: Record<string, any>;
+            };
+        };
+    };
+    type CredentialList = {
+        command: `list:credentials`;
+    };
+    type ActionList = {
+        command: `list:actions`;
+    };
+    type TriggerList = {
+        command: `list:triggers`;
+    };
+    type SourceList = {
+        command: `list:sources`;
+    };
+    type LocaleList = {
+        command: `list:locales`;
+        locale: string;
+    };
+    type Command = Invoke | CredentialList | ActionList | TriggerList | SourceList | LocaleList;
+}

package/dist/minified-utils/protocol.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Protocol = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const provider_1 = require("../entities/provider");
+const locales_1 = require("./locales");
+const core_1 = require("../core");
+const joi_1 = __importDefault(require("joi"));
+const invokeSchema = joi_1.default.object({
+    command: joi_1.default.string().valid(`invoke`).required(),
+    model: joi_1.default.string().valid(`action`, `trigger`, `credentials`).required(),
+    id: joi_1.default.string().required(),
+    params: joi_1.default.object({
+        function: joi_1.default.string().required(),
+        configuration: joi_1.default.object().required(),
+    }).required(),
+    context: joi_1.default.object({
+        environment: joi_1.default.object().required(),
+        localization: joi_1.default.object({
+            locale: joi_1.default.string().required(),
+            catalog: joi_1.default.object().required(),
+        }).required(),
+    }).required(),
+}).required();
+const credentialListSchema = joi_1.default.object({
+    command: joi_1.default.string().valid(`list:credentials`).required(),
+}).required();
+const actionListSchema = joi_1.default.object({
+    command: joi_1.default.string().valid(`list:actions`).required(),
+}).required();
+const triggerListSchema = joi_1.default.object({
+    command: joi_1.default.string().valid(`list:triggers`).required(),
+}).required();
+const sourceListSchema = joi_1.default.object({
+    command: joi_1.default.string().valid(`list:sources`).required(),
+}).required();
+const localeListSchema = joi_1.default.object({
+    command: joi_1.default.string().valid(`list:locales`).required(),
+    locale: joi_1.default.string().required(),
+}).required();
+const commandSchema = joi_1.default.alternatives(invokeSchema, credentialListSchema, actionListSchema, triggerListSchema, sourceListSchema, localeListSchema);
+class Protocol {
+    constructor(provider) {
+        this.evaluate = async (req) => {
+            try {
+                const validation = commandSchema.validate(req);
+                if (validation.error) {
+                    throw new Error(`Invalid request: ${validation.error.message}`);
+                }
+                let response;
+                switch (req.command) {
+                    case `list:actions`:
+                        response = Object.values(this.provider.actions || {});
+                        break;
+                    case `list:triggers`:
+                        response = Object.values(this.provider.triggers || {});
+                        break;
+                    case `list:credentials`:
+                        response = Object.values(this.provider.credentials || {});
+                        break;
+                    case `list:sources`:
+                        response = Object.values(this.provider.sources || {});
+                        break;
+                    case `list:locales`:
+                        const i18nInstance = (0, locales_1.i18n)({ directory: `node_modules/prow-hubspot-repository/locales` });
+                        response = i18nInstance.i18n.getLocales().map((l) => {
+                            i18nInstance.i18n.setLocale(l);
+                            return {
+                                code: l,
+                                catalog: i18nInstance.i18n.getCatalog(),
+                            };
+                        });
+                        break;
+                    case `invoke`:
+                        const mEvent = lodash_1.default.get(this.provider, `${req.model}s.${req.id}`);
+                        if (!mEvent) {
+                            return {
+                                status: 404,
+                                body: JSON.stringify({ error: `Could not find ${req.model} with ID ${req.id}` }),
+                            };
+                        }
+                        const f = lodash_1.default.get(mEvent, req.params.function);
+                        if (!f || typeof f !== `function`) {
+                            throw new Error(`Invalid function ${req.params.function}`);
+                        }
+                        const invokeInstance = (0, core_1.core)({
+                            env: req.context.environment,
+                            localization: req.context.localization,
+                        });
+                        response = await f(invokeInstance, req.params.configuration);
+                        break;
+                    default:
+                        throw new Error(`Invalid command`);
+                }
+                return response;
+            }
+            catch (e) {
+                throw e;
+            }
+        };
+        const providerValidation = (0, provider_1.providerSchema)().validate(provider);
+        if (providerValidation.error) {
+            throw new Error(`Invalid provider for protocol`);
+        }
+        this.provider = provider;
+    }
+}
+exports.Protocol = Protocol;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beseif-solutions/prow-core",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Prow core functionalities and classes",
   "main": "dist/index.js",
   "scripts": {
@@ -17,7 +17,6 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@types/express": "^4.17.21",
     "axios": "^1.7.7",
     "dotenv": "^16.4.5",
     "handlebars": "^4.7.8",

package/src/core.ts

@@ -1,11 +1,8 @@
-import axios, { AxiosError, AxiosResponse } from "axios";
+import axios from "axios";
+import Joi from "joi";
 import _ from "lodash";
 import moment from "moment-timezone";
-import { accessProxy, logProxy, ProxyLogs } from "./minified-utils/proxy";
-import { Properties } from "./minified-utils/properties";
-import { i18n } from "./minified-utils/locales";
-import path from "path";
-import Joi from "joi";
+import { FromCatalog, FromDirectory, i18n, T } from "./minified-utils/locales";
 
 type SourceFunctions = {
   register: <T>(source: string, data: T) => Promise<{ id: string }>,
@@ -25,55 +22,29 @@ const FALLBACK_SOURCES: SourceFunctions = {
   },
 };
 
-
 export type Core = {
   axios: typeof axios,
   moment: typeof moment,
   lodash: typeof _,
-  env: Properties,
-  t: ReturnType<typeof i18n>[`t`],
+  env: Record<string, any>,
   joi: typeof Joi,
   sources?: SourceFunctions,
+  t: T,
 };
 
-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 = {
-  root: string,
-  env?: Properties,
-  debug?: boolean,
-  locale?: string,
+  env?: Record<string, any>,
   sources?: SourceFunctions,
+  localization: FromDirectory | FromCatalog,
 };
 
 /* 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)),
-  }),
+  axios: axios,
   moment: moment,
   lodash: _,
-  env: options.env || new Properties(options.root, `.env`),
-  t: i18n(path.join(options.root, `/locales`), { locale: options.locale }).t,
+  env: options.env || {},
   joi: Joi,
   sources: options.sources || FALLBACK_SOURCES,
+  t: i18n(options.localization).t,
 });

package/src/index.ts

@@ -6,5 +6,6 @@ export { Action, actionOutputSchema, actionSchema, Event, eventSchema, Immediate
 export { Provider, providerSchema } from './entities/provider';
 export { Source } from './entities/source';
 export { extract, Field, fieldSchema, fieldsSchema, SelectFieldChoice, validate, ValidationResult } from './minified-utils/fields';
-export { i18n, localizeFields, localizeInputs, localizeOutputs, localizeProperties } from './minified-utils/locales';
+export { i18n, localizeFields, localizeInputs, localizeOutputs, localizeProperties, LocalizedField, LocalizedProperties } from './minified-utils/locales';
 export { Properties } from './minified-utils/properties';
+export { Protocol } from './minified-utils/protocol';

package/src/minified-utils/locales.ts

@@ -6,14 +6,14 @@ import { Credentials, SessionCredentials, StaticCredentials } from '../entities/
 import { Action, ConnectableEvent, Trigger } from '../entities/events';
 import { Field, SelectFieldChoice } from './fields';
 import { Provider } from '../entities/provider';
-import { validateDirectory } from './utils';
+import { Source } from '../entities/source';
 
-type LocalizedField = {
+export type LocalizedField = {
   label: string,
   help: string,
 };
 
-type LocalizedProperties = {
+export type LocalizedProperties = {
   name: string,
   description: string,
 };
@@ -22,25 +22,84 @@ type TOptions = { fallback?: boolean };
 
 const DEFAULT_LOCALE = `en`;
 
-export const i18n = (directory: string, options: { locale?: string } = {}) => {
+export const validateDirectory = (directory: string): boolean => {
   try {
-    if (!validateDirectory(directory)) {
-      throw new Error(`Invalid directory: ${directory}`);
+    if (!fs.existsSync(directory)) {
+      console.error(`Directory does not exist: ${directory}`);
+      return false;
     }
+    const files = fs.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;
+  }
+};
 
-    const availableLocales = fs.readdirSync(directory).map((file) => path.basename(file, path.extname(file)));
-    const requestedLocale = options.locale || DEFAULT_LOCALE;
+type Common = {
+  locale?: string,
+};
+
+export type FromCatalog = Common & {
+  catalog: Record<string, any>,
+};
+
+export type FromDirectory = Common & {
+  directory: string,
+  locale?: string,
+  write?: boolean,
+};
+
+export type T = (code: string, opts?: TOptions) => string;
 
-    const activeLocale = availableLocales.includes(requestedLocale) ? requestedLocale : DEFAULT_LOCALE;
+export const i18n = (options: FromCatalog | FromDirectory): { t: T, i18n: I18n.I18n } => {
+  try {
 
-    const i18nInstance: I18n.I18n = new I18n.I18n({
-      locales: availableLocales,
-      directory: directory,
+    const common: I18n.ConfigurationOptions = {
       defaultLocale: DEFAULT_LOCALE,
       objectNotation: true,
       autoReload: false,
       missingKeyFn: () => ``,
-    });
+    };
+
+    const requestedLocale = options.locale || DEFAULT_LOCALE;
+
+    let i18nInstance: I18n.I18n;
+    let activeLocale: string;
+    if (`directory` in options) {
+      // validate directory
+      if (!validateDirectory(options.directory)) { throw new Error(`Invalid directory: ${options.directory}`); }
+
+      // get active locale
+      const availableLocales = fs.readdirSync(options.directory).map((file) => path.basename(file, path.extname(file)));
+      activeLocale = availableLocales.includes(requestedLocale) ? requestedLocale : DEFAULT_LOCALE;
+
+      // create i18n instance
+      i18nInstance = new I18n.I18n({
+        ...common,
+        locales: availableLocales,
+        directory: options.directory,
+        updateFiles: options.write,
+        syncFiles: true,
+      });
+    } else if (`catalog` in options) {
+      // get active locale
+      activeLocale = requestedLocale;
+
+      // create i18n instance
+      i18nInstance = new I18n.I18n({
+        ...common,
+        locales: [requestedLocale],
+        staticCatalog: {
+          [requestedLocale]: options.catalog,
+        },
+      });
+    } else { throw new Error(`Invalid options provided for i18n function`); }
+
     i18nInstance.setLocale(activeLocale);
 
     return {
@@ -50,7 +109,8 @@ export const i18n = (directory: string, options: { locale?: string } = {}) => {
           response = i18nInstance.__({ phrase: code, locale: DEFAULT_LOCALE });
         }
         return response;
-      }, i18n: i18nInstance,
+      },
+      i18n: i18nInstance,
     };
   } catch (e) { throw e; }
 };
@@ -80,7 +140,7 @@ const localizeField = (
 
 export const localizeFields = (
   t: ReturnType<typeof i18n>[`t`],
-  element: Action | Trigger | StaticCredentials | SessionCredentials,
+  element: Action | Trigger | StaticCredentials | SessionCredentials | Source,
 ): Field<LocalizedField>[] => {
   const response: Field<LocalizedField>[] = [];
   if (element[`fields`] && element[`fields`].length > 0) {
@@ -91,7 +151,7 @@ export const localizeFields = (
 
 export const localizeProperties = (
   t: ReturnType<typeof i18n>[`t`],
-  element: Action | Trigger | Credentials | Provider,
+  element: Action | Trigger | Credentials | Provider | Source,
 ): LocalizedProperties => ({
   name: t(`${element.id}.name`, { fallback: true }),
   description: t(`${element.id}.description`),

package/src/minified-utils/properties.ts

@@ -6,7 +6,7 @@ import path from "path";
 export class Properties {
 
   private readonly filepath: string;
-  private readonly properties: DotenvParseOutput;
+  public readonly properties: DotenvParseOutput;
 
   private readonly getFile = (flag: `w+` | `r`): DotenvParseOutput => {
     try {

package/src/minified-utils/protocol.ts

@@ -0,0 +1,164 @@
+import _ from "lodash";
+import { Provider, providerSchema } from "../entities/provider";
+import { i18n } from "./locales";
+import { core } from "../core";
+import Joi from "joi";
+
+const invokeSchema = Joi.object({
+  command: Joi.string().valid(`invoke`).required(),
+  model: Joi.string().valid(`action`, `trigger`, `credentials`).required(),
+  id: Joi.string().required(),
+  params: Joi.object({
+    function: Joi.string().required(),
+    configuration: Joi.object().required(),
+  }).required(),
+  context: Joi.object({
+    environment: Joi.object().required(),
+    localization: Joi.object({
+      locale: Joi.string().required(),
+      catalog: Joi.object().required(),
+    }).required(),
+  }).required(),
+}).required();
+
+const credentialListSchema = Joi.object({
+  command: Joi.string().valid(`list:credentials`).required(),
+}).required();
+
+const actionListSchema = Joi.object({
+  command: Joi.string().valid(`list:actions`).required(),
+}).required();
+
+const triggerListSchema = Joi.object({
+  command: Joi.string().valid(`list:triggers`).required(),
+}).required();
+
+const sourceListSchema = Joi.object({
+  command: Joi.string().valid(`list:sources`).required(),
+}).required();
+
+const localeListSchema = Joi.object({
+  command: Joi.string().valid(`list:locales`).required(),
+  locale: Joi.string().required(),
+}).required();
+
+const commandSchema = Joi.alternatives(
+  invokeSchema,
+  credentialListSchema,
+  actionListSchema,
+  triggerListSchema,
+  sourceListSchema,
+  localeListSchema,
+);
+
+export class Protocol {
+
+  private readonly provider: Provider;
+
+  constructor(provider: Provider) {
+    const providerValidation = providerSchema().validate(provider);
+    if (providerValidation.error) { throw new Error(`Invalid provider for protocol`); }
+    this.provider = provider;
+  }
+
+  public evaluate = async (req: Protocol.Command): Promise<any> => {
+    try {
+      const validation = commandSchema.validate(req);
+      if (validation.error) { throw new Error(`Invalid request: ${validation.error.message}`); }
+
+      let response: any;
+      switch (req.command) {
+        case `list:actions`:
+          response = Object.values(this.provider.actions || {});
+          break;
+        case `list:triggers`:
+          response = Object.values(this.provider.triggers || {});
+          break;
+        case `list:credentials`:
+          response = Object.values(this.provider.credentials || {});
+          break;
+        case `list:sources`:
+          response = Object.values(this.provider.sources || {});
+          break;
+        case `list:locales`:
+          const i18nInstance = i18n({ directory: `node_modules/prow-hubspot-repository/locales` });
+          response = i18nInstance.i18n.getLocales().map((l) => {
+            i18nInstance.i18n.setLocale(l);
+            return {
+              code: l,
+              catalog: i18nInstance.i18n.getCatalog(),
+            };
+          });
+          break;
+        case `invoke`:
+          const mEvent = _.get(this.provider, `${req.model}s.${req.id}`);
+          if (!mEvent) {
+            return {
+              status: 404,
+              body: JSON.stringify({ error: `Could not find ${req.model} with ID ${req.id}` }),
+            };
+          }
+
+          const f = _.get(mEvent, req.params.function);
+          if (!f || typeof f !== `function`) { throw new Error(`Invalid function ${req.params.function}`); }
+
+          const invokeInstance = core({
+            env: req.context.environment,
+            localization: req.context.localization,
+          });
+
+          response = await f(invokeInstance, req.params.configuration);
+          break;
+        default:
+          throw new Error(`Invalid command`);
+      }
+
+      return response;
+    } catch (e) { throw e; }
+  };
+}
+
+export namespace Protocol {
+
+  export type Model = `action` | `trigger` | `credentials`;
+
+  export type Invoke = {
+    command: `invoke`,
+    model: Protocol.Model,
+    id: string,
+    params: {
+      function: string,
+      configuration: Record<string, any>,
+    },
+    context: {
+      environment: Record<string, any>,
+      localization: {
+        locale: string,
+        catalog: Record<string, any>,
+      },
+    },
+  };
+
+  export type CredentialList = {
+    command: `list:credentials`,
+  };
+
+  export type ActionList = {
+    command: `list:actions`,
+  };
+
+  export type TriggerList = {
+    command: `list:triggers`,
+  };
+
+  export type SourceList = {
+    command: `list:sources`,
+  };
+
+  export type LocaleList = {
+    command: `list:locales`,
+    locale: string,
+  };
+
+  export type Command = Invoke | CredentialList | ActionList | TriggerList | SourceList | LocaleList;
+}

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

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

package/dist/minified-utils/utils.js

@@ -1,26 +0,0 @@
-"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/src/minified-utils/utils.ts

@@ -1,18 +0,0 @@
-import fs from 'fs';
-export const validateDirectory = (directory: string): boolean => {
-  try {
-    if (!fs.existsSync(directory)) {
-      console.error(`Directory does not exist: ${directory}`);
-      return false;
-    }
-    const files = fs.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;
-  }
-};