Initial push

packages/components/src/Interface.ts

@@ -0,0 +1,83 @@
+/**
+ * Types
+ */
+
+export type NodeParamsType =
+    | 'asyncOptions'
+    | 'options'
+    | 'string'
+    | 'number'
+    | 'boolean'
+    | 'password'
+    | 'json'
+    | 'code'
+    | 'date'
+    | 'file'
+    | 'folder'
+
+export type CommonType = string | number | boolean | undefined | null
+
+/**
+ * Others
+ */
+
+export interface ICommonObject {
+    [key: string]: any | CommonType | ICommonObject | CommonType[] | ICommonObject[]
+}
+
+export interface IAttachment {
+    content: string
+    contentType: string
+    size?: number
+    filename?: string
+}
+
+export interface INodeOptionsValue {
+    label: string
+    name: string
+    description?: string
+}
+
+export interface INodeParams {
+    label: string
+    name: string
+    type: NodeParamsType | string
+    default?: CommonType | ICommonObject | ICommonObject[]
+    description?: string
+    options?: Array<INodeOptionsValue>
+    optional?: boolean | INodeDisplay
+    rows?: number
+    list?: boolean
+    placeholder?: string
+}
+
+export interface INodeExecutionData {
+    [key: string]: CommonType | CommonType[] | ICommonObject | ICommonObject[]
+}
+
+export interface INodeDisplay {
+    [key: string]: string[] | string
+}
+
+export interface INodeProperties {
+    label: string
+    name: string
+    type: string
+    icon: string
+    category: string
+    baseClasses: string[]
+    description?: string
+    filePath?: string
+}
+
+export interface INode extends INodeProperties {
+    inputs?: INodeParams[]
+    getBaseClasses?(): Promise<string[]>
+    getInstance?(nodeData: INodeData): Promise<string>
+    run?(nodeData: INodeData, input: string): Promise<string>
+}
+
+export interface INodeData extends INodeProperties {
+    inputs?: ICommonObject
+    instance?: any
+}

packages/components/src/index.ts

@@ -0,0 +1,2 @@
+export * from './Interface'
+export * from './utils'

packages/components/src/utils.ts

@@ -0,0 +1,144 @@
+import * as fs from 'fs'
+import * as path from 'path'
+
+export const numberOrExpressionRegex = '^(\\d+\\.?\\d*|{{.*}})$' //return true if string consists only numbers OR expression {{}}
+export const notEmptyRegex = '(.|\\s)*\\S(.|\\s)*' //return true if string is not empty or blank
+
+export const getBaseClasses = (targetClass: any) => {
+    const baseClasses: string[] = []
+
+    if (targetClass instanceof Function) {
+        let baseClass = targetClass
+
+        while (baseClass) {
+            const newBaseClass = Object.getPrototypeOf(baseClass)
+            if (newBaseClass && newBaseClass !== Object && newBaseClass.name) {
+                baseClass = newBaseClass
+                baseClasses.push(baseClass.name)
+            } else {
+                break
+            }
+        }
+    }
+    return baseClasses
+}
+
+/**
+ * Serialize axios query params
+ *
+ * @export
+ * @param {any} params
+ * @param {boolean} skipIndex // Set to true if you want same params to be: param=1&param=2 instead of: param[0]=1&param[1]=2
+ * @returns {string}
+ */
+export function serializeQueryParams(params: any, skipIndex?: boolean): string {
+    const parts: any[] = []
+
+    const encode = (val: string) => {
+        return encodeURIComponent(val)
+            .replace(/%3A/gi, ':')
+            .replace(/%24/g, '$')
+            .replace(/%2C/gi, ',')
+            .replace(/%20/g, '+')
+            .replace(/%5B/gi, '[')
+            .replace(/%5D/gi, ']')
+    }
+
+    const convertPart = (key: string, val: any) => {
+        if (val instanceof Date) val = val.toISOString()
+        else if (val instanceof Object) val = JSON.stringify(val)
+
+        parts.push(encode(key) + '=' + encode(val))
+    }
+
+    Object.entries(params).forEach(([key, val]) => {
+        if (val === null || typeof val === 'undefined') return
+
+        if (Array.isArray(val)) val.forEach((v, i) => convertPart(`${key}${skipIndex ? '' : `[${i}]`}`, v))
+        else convertPart(key, val)
+    })
+
+    return parts.join('&')
+}
+
+/**
+ * Handle error from try catch
+ *
+ * @export
+ * @param {any} error
+ * @returns {string}
+ */
+export function handleErrorMessage(error: any): string {
+    let errorMessage = ''
+
+    if (error.message) {
+        errorMessage += error.message + '. '
+    }
+
+    if (error.response && error.response.data) {
+        if (error.response.data.error) {
+            if (typeof error.response.data.error === 'object') errorMessage += JSON.stringify(error.response.data.error) + '. '
+            else if (typeof error.response.data.error === 'string') errorMessage += error.response.data.error + '. '
+        } else if (error.response.data.msg) errorMessage += error.response.data.msg + '. '
+        else if (error.response.data.Message) errorMessage += error.response.data.Message + '. '
+        else if (typeof error.response.data === 'string') errorMessage += error.response.data + '. '
+    }
+
+    if (!errorMessage) errorMessage = 'Unexpected Error.'
+
+    return errorMessage
+}
+
+/**
+ * Returns the path of node modules package
+ * @param {string} packageName
+ * @returns {string}
+ */
+export const getNodeModulesPackagePath = (packageName: string): string => {
+    const checkPaths = [
+        path.join(__dirname, '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', '..', '..', 'node_modules', packageName),
+        path.join(__dirname, '..', '..', '..', '..', '..', 'node_modules', packageName)
+    ]
+    for (const checkPath of checkPaths) {
+        if (fs.existsSync(checkPath)) {
+            return checkPath
+        }
+    }
+    return ''
+}
+
+/**
+ * Get input variables
+ * @param {string} paramValue
+ * @returns {boolean}
+ */
+export const getInputVariables = (paramValue: string): string[] => {
+    let returnVal = paramValue
+    const variableStack = []
+    const inputVariables = []
+    let startIdx = 0
+    const endIdx = returnVal.length - 1
+
+    while (startIdx < endIdx) {
+        const substr = returnVal.substring(startIdx, startIdx + 1)
+
+        // Store the opening double curly bracket
+        if (substr === '{') {
+            variableStack.push({ substr, startIdx: startIdx + 1 })
+        }
+
+        // Found the complete variable
+        if (substr === '}' && variableStack.length > 0 && variableStack[variableStack.length - 1].substr === '{') {
+            const variableStartIdx = variableStack[variableStack.length - 1].startIdx
+            const variableEndIdx = startIdx
+            const variableFullPath = returnVal.substring(variableStartIdx, variableEndIdx)
+            inputVariables.push(variableFullPath)
+            variableStack.pop()
+        }
+        startIdx += 1
+    }
+    return inputVariables
+}