@beseif-solutions/prow-core 0.0.28 → 0.0.29

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/minified-utils/locales.d.ts

@@ -14,10 +14,21 @@ type LocalizedProperties = {
 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>[];

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beseif-solutions/prow-core",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "description": "Prow core functionalities and classes",
   "main": "dist/index.js",
   "scripts": {

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/minified-utils/locales.ts

@@ -6,7 +6,6 @@ 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';
 
 type LocalizedField = {
   label: string,
@@ -22,25 +21,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 +108,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; }
 };

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/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;
-  }
-};