creo-flow-extensions-base 1.0.0-dev.1

package/README.md

@@ -0,0 +1 @@
+# cdh-flow-extension-base

package/lib/api/index.d.ts

@@ -0,0 +1 @@
+export declare const ownApi: import("axios").AxiosInstance;

package/lib/api/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownApi = void 0;
+const axios_1 = __importDefault(require("axios"));
+const baseApiUrl = process.env.baseApiUrl;
+exports.ownApi = axios_1.default.create({
+    baseURL: baseApiUrl,
+    timeout: 60000 * 2, // 120sec
+    maxContentLength: 200 * 1000 * 1024 * 1024, // 2 000 MB
+});
+const retryRequest = (error) => {
+    if (error.response && error.response.status === 502) {
+        return new Promise((resolve) => {
+            setTimeout(() => resolve((0, axios_1.default)(error.config)), 7000);
+        });
+    }
+    return Promise.reject(error);
+};
+exports.ownApi.interceptors.response.use(response => response, retryRequest);

package/lib/connection/index.d.ts

@@ -0,0 +1,18 @@
+import { IInputField } from '../fields/input';
+import { ISelectField } from '../fields/select';
+import { ICheckboxField } from '../fields/checkbox';
+export interface IConnectionStep {
+    title: string;
+    fields: (IInputField | ISelectField | ICheckboxField)[];
+}
+export interface IConnectionSchema {
+    type: string;
+    title: string;
+    name: string;
+    fields: (IInputField | ISelectField | ICheckboxField)[];
+    checkConnection: (...args: any) => Promise<any>;
+}
+export interface IConnectionSchemaField {
+    key: string;
+    value: string;
+}

package/lib/connection/index.js

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

package/lib/context/index.d.ts

@@ -0,0 +1,18 @@
+import { IDeleteContextToRedis, IGetContextFromRedis, IGetContextFromS3, IWriteContext, IWriteContextToRedis, IWriteContextToS3 } from './interfaces';
+declare class ContextService {
+    getContext({ methodProps, token, urls }: {
+        methodProps: any;
+        token: string;
+        urls?: Record<string, string>;
+    }): Promise<Record<string, any> | undefined>;
+    writeContext({ contextKey, data, token, url }: IWriteContext): Promise<void>;
+    private getContextByKeys;
+    private receiveContext;
+    getContextFromRedis({ contextKey, token }: IGetContextFromRedis): Promise<import("axios").AxiosResponse<any, any>>;
+    getContextFromS3({ url }: IGetContextFromS3): Promise<any>;
+    sendContextToRedis({ contextKey, data, token }: IWriteContextToRedis): Promise<void>;
+    sendContextToS3({ data, url }: IWriteContextToS3): Promise<void>;
+    deleteContextFromRedis({ contextKey, token }: IDeleteContextToRedis): Promise<void>;
+}
+export declare const contextService: ContextService;
+export {};

package/lib/context/index.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contextService = void 0;
+const api_1 = require("../api");
+const utils_1 = require("./utils");
+const axios_1 = __importDefault(require("axios"));
+const error_1 = require("../error");
+const v8_1 = require("v8");
+const zlib_1 = __importDefault(require("zlib"));
+const logger_1 = require("../logger");
+const redisSizeLimit = 1024 * 100; // 0.1mb
+class ContextService {
+    async getContext({ methodProps, token, urls }) {
+        try {
+            const contextReadKeys = (0, utils_1.getContextKeys)(methodProps);
+            if (!contextReadKeys?.length || !urls) {
+                logger_1.logger.info({
+                    message: 'No context to read (context keys not used)',
+                    location: this.constructor.name,
+                    payload: {
+                        contextReadKeys,
+                    }
+                });
+                return;
+            }
+            logger_1.logger.info({
+                message: 'Get context',
+                location: this.constructor.name,
+                payload: {
+                    contextReadKeys,
+                }
+            });
+            const context = await this.getContextByKeys({ contextKeys: contextReadKeys, token, urls });
+            logger_1.logger.info({
+                message: 'Context received',
+                location: this.constructor.name,
+                payload: {
+                    contextReadKeys,
+                }
+            });
+            return context;
+        }
+        catch (e) {
+            logger_1.logger.error({
+                message: 'Error while getting context',
+                location: this.constructor.name,
+                payload: {
+                    errorMessage: e.message,
+                }
+            });
+            throw new error_1.BaseError(`Error while getting context`);
+        }
+    }
+    async writeContext({ contextKey, data, token, url }) {
+        try {
+            const dataSize = (0, utils_1.calculateBiteSize)(data);
+            const isShouldBeWrittenToS3 = dataSize > redisSizeLimit;
+            logger_1.logger.info({
+                message: 'Write context',
+                location: this.constructor.name,
+                payload: {
+                    dataSize,
+                    redisSizeLimit,
+                    isShouldBeWrittenToS3,
+                }
+            });
+            if (!url) {
+                return;
+            }
+            if (isShouldBeWrittenToS3) {
+                await this.deleteContextFromRedis({ contextKey, token });
+                const result = await this.sendContextToS3({ data, url });
+                logger_1.logger.info({
+                    message: 'Context written to S3',
+                    location: this.constructor.name,
+                });
+                return result;
+            }
+            const result = await this.sendContextToRedis({ contextKey, data, token });
+            logger_1.logger.info({
+                message: 'Context written to Redis',
+                location: this.constructor.name,
+            });
+            return result;
+        }
+        catch (e) {
+            logger_1.logger.error({
+                message: 'Error while writing context',
+                location: this.constructor.name,
+                payload: {
+                    errorMessage: e.message,
+                }
+            });
+            throw new error_1.BaseError(`Error while writing context`);
+        }
+    }
+    async getContextByKeys({ contextKeys, token, urls }) {
+        const contextResults = {};
+        for (const contextKey of contextKeys) {
+            if (!contextKey)
+                return {};
+            const result = await this.receiveContext({ contextKey, token, url: urls[contextKey] });
+            contextResults[contextKey] = result;
+        }
+        return contextResults;
+    }
+    async receiveContext({ contextKey, token, url }) {
+        try {
+            logger_1.logger.info({
+                message: 'Get context by key from Redis',
+                location: this.constructor.name,
+                payload: {
+                    contextKey,
+                }
+            });
+            const contextResponse = await this.getContextFromRedis({ contextKey, token });
+            logger_1.logger.info({
+                message: 'Context by key from Redis received',
+                location: this.constructor.name,
+                payload: {
+                    contextKey,
+                }
+            });
+            return contextResponse.data;
+        }
+        catch (error) {
+            const axiosError = error;
+            if (axiosError?.response?.status === 404) {
+                logger_1.logger.info({
+                    message: 'Context by key not found in Redis. Get context by key from S3',
+                    location: this.constructor.name,
+                    payload: {
+                        contextKey,
+                    }
+                });
+                const result = await this.getContextFromS3({ url });
+                logger_1.logger.info({
+                    message: 'Context by key from S3 received',
+                    location: this.constructor.name,
+                    payload: {
+                        contextKey,
+                    }
+                });
+                return result;
+            }
+            throw error;
+        }
+    }
+    async getContextFromRedis({ contextKey, token }) {
+        const { flowContextId, flowId } = (0, utils_1.parseToken)(token);
+        return api_1.ownApi.get(`flows/${flowId}/contexts/${flowContextId}`, {
+            params: { contextKey },
+            headers: { 'context-token': token }
+        });
+    }
+    async getContextFromS3({ url }) {
+        const { data: response } = await axios_1.default.get(url, { responseType: 'arraybuffer' });
+        const uncompressed = zlib_1.default.unzipSync(response);
+        return (0, v8_1.deserialize)(uncompressed);
+    }
+    async sendContextToRedis({ contextKey, data, token }) {
+        const { flowContextId, flowId } = (0, utils_1.parseToken)(token);
+        await api_1.ownApi.patch(`flows/${flowId}/contexts/${flowContextId}`, { contextKey, contextData: data }, { headers: { 'context-token': token } });
+    }
+    async sendContextToS3({ data, url }) {
+        const serialized = (0, v8_1.serialize)(data);
+        const compressed = zlib_1.default.gzipSync(serialized);
+        await axios_1.default.put(url, compressed);
+    }
+    async deleteContextFromRedis({ contextKey, token }) {
+        const { flowContextId, flowId } = (0, utils_1.parseToken)(token);
+        await api_1.ownApi.delete(`flows/${flowId}/contexts/${flowContextId}/${contextKey}`, { headers: { 'context-token': token } });
+    }
+}
+exports.contextService = new ContextService();

package/lib/context/interfaces/index.d.ts

@@ -0,0 +1,32 @@
+export interface IGetContextProps {
+    contextKeys: string[];
+    token: string;
+    urls: {
+        [key: string]: string;
+    };
+}
+export type IWriteContext = IWriteContextToRedis & IWriteContextToS3;
+export interface IWriteContextToRedis {
+    contextKey: string;
+    data: any;
+    token: string;
+}
+export interface IWriteContextToS3 {
+    url: string;
+    data: any;
+}
+export interface IGetContextFromRedis {
+    contextKey: string;
+    token: string;
+}
+export interface IGetContextFromS3 {
+    url: string;
+}
+export interface ContextTokenPayload {
+    flowContextId: string;
+    flowId: string;
+}
+export interface IDeleteContextToRedis {
+    contextKey: string;
+    token: string;
+}

package/lib/context/interfaces/index.js

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

package/lib/context/utils/index.d.ts

@@ -0,0 +1,7 @@
+export declare const getContextKeys: (methodProps: any) => any[] | undefined;
+export declare const parseToken: (token: string) => {
+    flowContextId: string;
+    flowId: string;
+};
+export declare const calculateBiteSize: (value: any) => number;
+export declare const checkIsJSON: (myString: string) => boolean;

package/lib/context/utils/index.js

@@ -0,0 +1,69 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIsJSON = exports.calculateBiteSize = exports.parseToken = exports.getContextKeys = void 0;
+const jwt = __importStar(require("jsonwebtoken"));
+const v8_1 = require("v8");
+const getContextKeys = (methodProps) => {
+    const regex = /context\.([a-zA-Z0-9_]+)/g;
+    const matches = JSON.stringify(methodProps).match(regex);
+    const foundKeys = matches?.map((match) => match?.split('.')[1]) || undefined;
+    return foundKeys;
+};
+exports.getContextKeys = getContextKeys;
+const parseToken = (token) => {
+    try {
+        const decodedPayload = jwt.decode(token, { complete: true });
+        if (!decodedPayload || !decodedPayload.payload) {
+            throw new Error('Invalid JWT format');
+        }
+        const { flowContextId, flowId } = decodedPayload.payload;
+        if (!flowContextId || !flowId) {
+            throw new Error('Missing params in JWT payload');
+        }
+        return {
+            flowContextId,
+            flowId,
+        };
+    }
+    catch (error) {
+        throw new Error('Error parsing JWT payload');
+    }
+};
+exports.parseToken = parseToken;
+const calculateBiteSize = (value) => {
+    return Buffer.from((0, v8_1.serialize)(value)).length;
+};
+exports.calculateBiteSize = calculateBiteSize;
+const checkIsJSON = (myString) => {
+    try {
+        JSON.parse(myString);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.checkIsJSON = checkIsJSON;

package/lib/createExtension/index.d.ts

@@ -0,0 +1,36 @@
+import { IConnectionSchema } from '../connection';
+import { INodeDescriptor } from '../nodes';
+import { ExtensionTypes } from '../enum';
+export interface ICreateExtensionParams {
+    nodes: INodeDescriptor[];
+    connections?: IConnectionSchema[];
+    title: string;
+    icon: string;
+    type: ExtensionTypes;
+}
+declare enum EventTypes {
+    EXECUTE = "execute",
+    GET_EXTENSION_INFO = "getExtensionInfo",
+    GET_FULL_NODE = "getFullNode"
+}
+interface IEvent {
+    method?: {
+        name: string;
+        uri: string;
+        databaseName: string;
+        collectionName: string;
+        query?: string;
+    };
+    writeContextUrl: string;
+    readContextUrls: {
+        [contextKey: string]: string;
+    };
+    type: EventTypes;
+    contextKey: string;
+    flowContextToken: string;
+}
+export declare const createExtension: (extension: ICreateExtensionParams) => (event: IEvent) => Promise<{
+    statusCode: number;
+    body: string;
+}>;
+export {};

package/lib/createExtension/index.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExtension = void 0;
+const enum_1 = require("../fields/enum");
+const context_1 = require("../context");
+const error_1 = require("../error");
+const logger_1 = require("../logger");
+var EventTypes;
+(function (EventTypes) {
+    EventTypes["EXECUTE"] = "execute";
+    EventTypes["GET_EXTENSION_INFO"] = "getExtensionInfo";
+    EventTypes["GET_FULL_NODE"] = "getFullNode";
+})(EventTypes || (EventTypes = {}));
+// @TODO: add dependencies between fields for smart rendering. Now on each field change we need to get node info;
+// Disable node select fields without options.
+const createExtension = (extension) => async (event) => {
+    try {
+        const EventCallbacks = {
+            [EventTypes.EXECUTE]: execute,
+            [EventTypes.GET_EXTENSION_INFO]: getExtensionInfo,
+            [EventTypes.GET_FULL_NODE]: getFullNode,
+        };
+        const eventCallback = EventCallbacks[event.type];
+        const result = await eventCallback(event, extension);
+        return result;
+    }
+    catch (e) {
+        return {
+            statusCode: 500,
+            body: JSON.stringify({ message: `An error occurred ${e.message}` })
+        };
+    }
+};
+exports.createExtension = createExtension;
+const execute = async (event, extension) => {
+    try {
+        const methodProps = event?.method;
+        const method = methodProps?.name ? extension.nodes.find(({ name }) => name === methodProps.name) : undefined;
+        const writeContextUrl = event?.writeContextUrl;
+        const readContextUrls = event?.readContextUrls;
+        logger_1.logger.info({
+            message: `Start extension execution, extension: ${extension.title}`,
+            location: 'execute method',
+            payload: {
+                method,
+            }
+        });
+        if (!method) {
+            throw new Error('Unknown extension method');
+        }
+        ;
+        const contextWriteKey = event?.contextKey;
+        if (!contextWriteKey) {
+            throw new Error('Context key is not provided');
+        }
+        const contextToken = event?.flowContextToken;
+        if (!contextToken) {
+            throw new Error('Context token is not provided');
+        }
+        const context = await context_1.contextService.getContext({ methodProps, token: event.flowContextToken, urls: readContextUrls });
+        const response = await method.func(methodProps, context);
+        if (writeContextUrl && event.flowContextToken) {
+            await context_1.contextService.writeContext({ contextKey: contextWriteKey, data: response, token: event.flowContextToken, url: writeContextUrl });
+        }
+        logger_1.logger.info({
+            message: `Extension successfully executed, extension: ${extension.title}`,
+            location: 'execute method',
+            payload: {
+                method,
+            }
+        });
+        const logs = [...logger_1.logger.getLogs()];
+        logger_1.logger.clearLogs();
+        return { statusCode: 200, body: JSON.stringify({ logs }), };
+    }
+    catch (error) {
+        logger_1.logger.error({
+            message: `Extension execution failed, extension: ${extension.title}`,
+            location: 'execute method',
+            payload: {
+                errorMessage: error.message,
+            }
+        });
+        // TODO: Use for better error handling.
+        const isCaughtError = error instanceof error_1.BaseError;
+        const statusCode = isCaughtError ? 400 : 500;
+        const message = isCaughtError ? error.message : `An execution error occurred`;
+        const logs = [...logger_1.logger.getLogs()];
+        logger_1.logger.clearLogs();
+        return {
+            statusCode,
+            body: JSON.stringify({ message, logs }),
+        };
+    }
+};
+const getExtensionInfo = async (event, extension) => {
+    return {
+        statusCode: 200,
+        body: JSON.stringify(extension),
+    };
+};
+const getFullNode = async (event, extension) => {
+    try {
+        const methodProps = event?.method;
+        const method = methodProps?.name ? extension.nodes.find(({ name }) => name === methodProps.name) : undefined;
+        if (!method) {
+            throw new error_1.BaseError('Unknown extension method');
+        }
+        const fullFields = await Promise.all(method.fields.map(async (field) => {
+            const isSelect = field.type === enum_1.FieldTypes.SELECT;
+            if (!isSelect)
+                return field;
+            const options = field?.getOptions ? await field.getOptions(methodProps) : [];
+            return { ...field, options };
+        }));
+        return {
+            statusCode: 200,
+            body: JSON.stringify({ ...method, fields: fullFields }),
+        };
+    }
+    catch (error) {
+        const isCaughtError = error instanceof error_1.BaseError;
+        const statusCode = isCaughtError ? 400 : 500;
+        const message = isCaughtError ? error.message : 'An receiving node info error occurred';
+        return {
+            statusCode,
+            body: JSON.stringify({ message }),
+        };
+    }
+};

package/lib/enum/index.d.ts

@@ -0,0 +1,7 @@
+export declare enum ExtensionTypes {
+    DB_CONNECTION = "db_connection",
+    FILE = "file",
+    CHOICE = "choice",
+    PARALLEL = "parallel",
+    CODE = "code"
+}

package/lib/enum/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionTypes = void 0;
+var ExtensionTypes;
+(function (ExtensionTypes) {
+    ExtensionTypes["DB_CONNECTION"] = "db_connection";
+    ExtensionTypes["FILE"] = "file";
+    ExtensionTypes["CHOICE"] = "choice";
+    ExtensionTypes["PARALLEL"] = "parallel";
+    ExtensionTypes["CODE"] = "code";
+})(ExtensionTypes || (exports.ExtensionTypes = ExtensionTypes = {}));

package/lib/error/index.d.ts

@@ -0,0 +1,3 @@
+export declare class BaseError extends Error {
+    constructor(message: string);
+}

package/lib/error/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseError = void 0;
+class BaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+exports.BaseError = BaseError;

package/lib/fields/checkbox/index.d.ts

@@ -0,0 +1,18 @@
+import { FieldTypes } from "../enum";
+export interface ICheckboxField {
+    name: string;
+    label: string;
+    isRequired: boolean;
+    isChecked?: boolean;
+    type: FieldTypes.CHECKBOX;
+    dependsOn?: string[];
+}
+interface IProps {
+    name: string;
+    label?: string;
+    isRequired: boolean;
+    isChecked: boolean;
+    dependsOn?: string[];
+}
+export declare const createCheckboxField: (checkboxField: IProps) => ICheckboxField;
+export {};

package/lib/fields/checkbox/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCheckboxField = void 0;
+const enum_1 = require("../enum");
+const createCheckboxField = (checkboxField) => {
+    const { name, label = '', isChecked = false, isRequired, dependsOn } = checkboxField;
+    return {
+        name,
+        label,
+        isRequired,
+        isChecked,
+        type: enum_1.FieldTypes.CHECKBOX,
+        dependsOn
+    };
+};
+exports.createCheckboxField = createCheckboxField;

package/lib/fields/code/index.d.ts

@@ -0,0 +1,18 @@
+import { FieldTypes } from "../enum";
+export interface ICodeField {
+    label?: string;
+    name: string;
+    language: 'javascript' | 'python';
+    isRequired: boolean;
+    type: FieldTypes.CODE;
+    dependsOn?: string[];
+}
+interface IProps {
+    label?: string;
+    name: string;
+    language?: 'javascript';
+    isRequired: boolean;
+    dependsOn?: string[];
+}
+export declare const createCodeField: (codeField: IProps) => ICodeField;
+export {};

package/lib/fields/code/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodeField = void 0;
+const enum_1 = require("../enum");
+const createCodeField = (codeField) => {
+    const { name, label = '', language = 'javascript', isRequired, dependsOn, } = codeField;
+    return {
+        name,
+        label,
+        type: enum_1.FieldTypes.CODE,
+        language,
+        isRequired,
+        dependsOn,
+    };
+};
+exports.createCodeField = createCodeField;

package/lib/fields/enum/index.d.ts

@@ -0,0 +1,6 @@
+export declare enum FieldTypes {
+    CHECKBOX = "checkbox",
+    CODE = "code",
+    INPUT = "input",
+    SELECT = "select"
+}

package/lib/fields/enum/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FieldTypes = void 0;
+var FieldTypes;
+(function (FieldTypes) {
+    FieldTypes["CHECKBOX"] = "checkbox";
+    FieldTypes["CODE"] = "code";
+    FieldTypes["INPUT"] = "input";
+    FieldTypes["SELECT"] = "select";
+})(FieldTypes || (exports.FieldTypes = FieldTypes = {}));
+;

package/lib/fields/input/index.d.ts

@@ -0,0 +1,23 @@
+import { FieldTypes } from '../enum';
+import { IBehavior } from '../select';
+export interface IInputField {
+    name: string;
+    label: string;
+    placeholder?: string;
+    inputType?: 'text' | 'number' | 'password';
+    isRequired: boolean;
+    behavior?: IBehavior[];
+    type: FieldTypes.INPUT;
+    dependsOn?: string[];
+}
+interface IProps {
+    name: string;
+    label?: string;
+    inputType?: 'text' | 'number' | 'password';
+    placeholder?: string;
+    isRequired: boolean;
+    behavior?: IBehavior[];
+    dependsOn?: string[];
+}
+export declare const createInputField: (inputField: IProps) => IInputField;
+export {};

package/lib/fields/input/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInputField = void 0;
+const enum_1 = require("../enum");
+// const defaultValidation = {
+//   isRequired: true,
+//   type: 'string',
+// };
+const createInputField = (inputField) => {
+    const { name, label = '', placeholder = '', inputType = 'text', isRequired, dependsOn } = inputField; // validation = defaultValidation,
+    return {
+        type: enum_1.FieldTypes.INPUT,
+        name,
+        inputType,
+        label,
+        placeholder,
+        isRequired,
+        dependsOn,
+        // validation,
+    };
+};
+exports.createInputField = createInputField;

package/lib/fields/select/index.d.ts

@@ -0,0 +1,40 @@
+import { FieldTypes } from "../enum";
+interface IOptions {
+    label: string;
+    value: string;
+}
+export interface ISelectField {
+    type: FieldTypes.SELECT;
+    name: string;
+    label?: string;
+    placeholder?: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    getOptions?: (...args: any) => Promise<IOptions[]> | IOptions[];
+    behavior?: IBehavior[];
+    isRequired: boolean;
+    dependsOn?: string[];
+}
+export interface IBehavior {
+    action: 'disable';
+    condition: 'equals';
+    fieldName: string;
+    fieldValue: boolean | string | number | null | undefined;
+}
+interface IProps {
+    name: string;
+    label?: string;
+    placeholder?: string;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    behavior?: IBehavior[];
+    getOptions?: () => Promise<IOptions[]> | IOptions[];
+    isRequired: boolean;
+    dependsOn?: string[];
+}
+export declare const createSelectField: (selectFieldData: IProps) => ISelectField;
+export {};

package/lib/fields/select/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelectField = void 0;
+const enum_1 = require("../enum");
+const createSelectField = (selectFieldData) => {
+    const { name, label, placeholder, options, getOptions, isRequired, dependsOn } = selectFieldData;
+    return {
+        type: enum_1.FieldTypes.SELECT,
+        name,
+        label,
+        placeholder,
+        options,
+        getOptions,
+        isRequired,
+        dependsOn,
+    };
+};
+exports.createSelectField = createSelectField;

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './connection';
+export * from './createExtension';
+export * from './nodes';
+export * from './enum';
+export * from './fields/enum';
+export * from './error';

package/lib/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./connection"), exports);
+__exportStar(require("./createExtension"), exports);
+__exportStar(require("./nodes"), exports);
+__exportStar(require("./enum"), exports);
+__exportStar(require("./fields/enum"), exports);
+__exportStar(require("./error"), exports);

package/lib/logger/index.d.ts

@@ -0,0 +1,26 @@
+declare enum LogLevels {
+    ERROR = "error",
+    INFO = "info"
+}
+interface ILogProps {
+    location: string;
+    message: string;
+    payload?: {
+        [key: string]: any;
+    };
+}
+interface ILog extends ILogProps {
+    level: LogLevels;
+    timestamp: string;
+}
+declare class Logger {
+    private logs;
+    constructor();
+    info({ location, message, payload }: ILogProps): void;
+    error({ location, message, payload }: ILogProps): void;
+    getLogs(): ILog[];
+    clearLogs(): ILog[];
+    private getCurrentTimestamp;
+}
+export declare const logger: Logger;
+export {};

package/lib/logger/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const date_fns_1 = require("date-fns");
+var LogLevels;
+(function (LogLevels) {
+    LogLevels["ERROR"] = "error";
+    LogLevels["INFO"] = "info";
+})(LogLevels || (LogLevels = {}));
+class Logger {
+    logs;
+    constructor() {
+        this.logs = [];
+    }
+    info({ location, message, payload }) {
+        this.logs.push({ level: LogLevels.INFO, location, message, payload, timestamp: this.getCurrentTimestamp() });
+    }
+    error({ location, message, payload }) {
+        this.logs.push({ level: LogLevels.ERROR, location, message, payload, timestamp: this.getCurrentTimestamp() });
+    }
+    getLogs() {
+        return this.logs;
+    }
+    clearLogs() {
+        return this.logs = [];
+    }
+    getCurrentTimestamp() {
+        return (0, date_fns_1.format)(new Date(), "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
+    }
+}
+exports.logger = new Logger();

package/lib/nodes/index.d.ts

@@ -0,0 +1,19 @@
+import { ICheckboxField } from '../fields/checkbox';
+import { IInputField } from '../fields/input';
+import { ISelectField } from '../fields/select';
+import { ICodeField } from '../fields/code';
+type Field = IInputField | ISelectField | ICheckboxField | ICodeField;
+export interface INodeDescriptor {
+    name: string;
+    title: string;
+    fields: Field[];
+    func: (args: any, context?: any) => any;
+}
+interface IProps {
+    name: string;
+    title: string;
+    fields: Field[];
+    func: (args: any, context?: any) => any;
+}
+export declare const createNodeDescriptor: (params: IProps) => INodeDescriptor;
+export {};

package/lib/nodes/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodeDescriptor = void 0;
+const createNodeDescriptor = (params) => {
+    const { name, fields, func, title } = params;
+    return {
+        name,
+        title,
+        fields: fields || [],
+        func: func || null,
+    };
+};
+exports.createNodeDescriptor = createNodeDescriptor;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "creo-flow-extensions-base",
+  "version": "1.0.0-dev.1",
+  "main": "index.js",
+  "repository": "git@github.com:CloudDataHub/cdh-flow-extension-base.git",
+  "author": "Ilia Kobaliia",
+  "license": "ISC",
+  "scripts": {
+    "clean": "rm -rf ./lib",
+    "build": "npm run clean && tsc",
+    "publishPackage": "npm run build && npm publish",
+    "publishPackageDev": "npm run build && npm publish --tag dev",
+    "publishPackageQa": "npm run build && npm publish --tag qa"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.5",
+    "typescript": "^5.0.2"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "dependencies": {
+    "axios": "^1.6.2",
+    "date-fns": "^3.6.0",
+    "jsonwebtoken": "^9.0.2"
+  }
+}