@oneuptime/common 1.0.0

package/Types/Workflow/Components/Workflow.ts

@@ -0,0 +1,44 @@
+import IconProp from '../../Icon/IconProp';
+import ComponentMetadata, {
+    ComponentInputType,
+    ComponentType,
+} from './../Component';
+
+const components: Array<ComponentMetadata> = [
+    {
+        id: 'workflow-run',
+        title: 'Execute Workflow',
+        category: 'Utils',
+        description: 'Execute another workflow',
+        iconProp: IconProp.Workflow,
+        componentType: ComponentType.Component,
+        arguments: [
+            {
+                type: ComponentInputType.AnyValue,
+                name: 'Value',
+                description: 'Value to pass to another workflow',
+                required: false,
+                id: 'value',
+            },
+        ],
+        returnValues: [],
+        inPorts: [
+            {
+                title: 'In',
+                description:
+                    'Please connect components to this port for this component to work.',
+                id: 'in',
+            },
+        ],
+        outPorts: [
+            {
+                title: 'Out',
+                description:
+                    'Connect to this port if you want other components to execute after the workflow is triggered',
+                id: 'out',
+            },
+        ],
+    },
+];
+
+export default components;

package/Types/Workflow/Components.ts

@@ -0,0 +1,78 @@
+import ComponentMetadata, { ComponentCategory } from './Component';
+import LogComponents from './Components/Log';
+import APIComponents from './Components/API';
+import ScheduleComponents from './Components/Schedule';
+import SlackComponents from './Components/Slack';
+import ConditionComponents from './Components/Condition';
+import JsonComponents from './Components/JSON';
+import JavaScriptComponents from './Components/JavaScript';
+import EmailComponents from './Components/Email';
+import WebhookComponents from './Components/Webhook';
+import ManualComponents from './Components/Manual';
+import WorkflowComponents from './Components/Workflow';
+
+import IconProp from '../Icon/IconProp';
+
+const components: Array<ComponentMetadata> = [
+    ...LogComponents,
+    ...APIComponents,
+    ...ScheduleComponents,
+    ...SlackComponents,
+    ...ConditionComponents,
+    ...JsonComponents,
+    ...JavaScriptComponents,
+    ...EmailComponents,
+    ...WebhookComponents,
+    ...WorkflowComponents,
+    ...ManualComponents,
+];
+
+export default components;
+
+export const Categories: Array<ComponentCategory> = [
+    {
+        name: 'Webhook',
+        description: 'Integrate any apps into the workflow with webhooks.',
+        icon: IconProp.AltGlobe,
+    },
+    {
+        name: 'API',
+        description: 'Integrate with any API out on the web.',
+        icon: IconProp.Globe,
+    },
+    {
+        name: 'Slack',
+        description: 'Integrate OneUptime with your Slack team.',
+        icon: IconProp.SendMessage,
+    },
+    {
+        name: 'Conditions',
+        description: 'Add logic to your workflows.',
+        icon: IconProp.Condition,
+    },
+    {
+        name: 'Custom Code',
+        description: 'Add JaavScript to your workflows.',
+        icon: IconProp.Code,
+    },
+    {
+        name: 'JSON',
+        description: 'Work with JSON Object in your workflows.',
+        icon: IconProp.JSON,
+    },
+    {
+        name: 'Schedule',
+        description: 'Make your workflows run at regular intervals.',
+        icon: IconProp.Clock,
+    },
+    {
+        name: 'Email',
+        description: 'Send email to anyone in your workflows.',
+        icon: IconProp.Clock,
+    },
+    {
+        name: 'Utils',
+        description: 'Utils that make workflow design simpler.',
+        icon: IconProp.Window,
+    },
+];

package/Types/Workflow/WorkflowPlan.ts

@@ -0,0 +1,8 @@
+enum WorkflowPlan {
+    'Free' = 0,
+    'Enterprise' = 9999999,
+    'Growth' = 500,
+    'Scale' = 2000,
+}
+
+export default WorkflowPlan;

package/Types/Workflow/WorkflowStatus.ts

@@ -0,0 +1,10 @@
+enum WorkflowStatus {
+    Scheduled = 'Scheduled',
+    Running = 'Running',
+    Success = 'Success',
+    Error = 'Error',
+    Timeout = 'Timeout',
+    WorkflowCountExceeded = 'WorkflowCountExceeded',
+}
+
+export default WorkflowStatus;

package/Types/XML.ts

@@ -0,0 +1,21 @@
+import BadDataException from './Exception/BadDataException';
+export default class XML {
+    private _xml: string = '';
+    public get xml(): string {
+        return this._xml;
+    }
+    public set xml(v: string) {
+        if (!v) {
+            throw new BadDataException('XML is not in valid format.');
+        }
+        this._xml = v;
+    }
+
+    public constructor(xml: string) {
+        this.xml = xml;
+    }
+
+    public toString(): string {
+        return this.xml;
+    }
+}

package/Typings/Index.d.ts

@@ -0,0 +1,3 @@
+declare module '*.png';
+declare module '*.jpg';
+declare module '*.gif';

package/Utils/API.ts

@@ -0,0 +1,348 @@
+import axios, { AxiosError, AxiosResponse } from 'axios';
+import URL from '../Types/API/URL';
+import { JSONObject, JSONArray } from '../Types/JSON';
+import Headers from '../Types/API/Headers';
+import HTTPResponse from '../Types/API/HTTPResponse';
+import HTTPErrorResponse from '../Types/API/HTTPErrorResponse';
+import HTTPMethod from '../Types/API/HTTPMethod';
+import APIException from '../Types/Exception/ApiException';
+import Protocol from '../Types/API/Protocol';
+import Hostname from '../Types/API/Hostname';
+import Route from '../Types/API/Route';
+import BaseModel from '../Models/BaseModel';
+import Dictionary from '../Types/Dictionary';
+import AnalyticsBaseModel from '../AnalyticsModels/BaseModel';
+
+export default class API {
+    private _protocol: Protocol = Protocol.HTTPS;
+    public get protocol(): Protocol {
+        return this._protocol;
+    }
+    public set protocol(v: Protocol) {
+        this._protocol = v;
+    }
+
+    private _hostname!: Hostname;
+    public get hostname(): Hostname {
+        return this._hostname;
+    }
+    public set hostname(v: Hostname) {
+        this._hostname = v;
+    }
+
+    private _baseRoute!: Route;
+    public get baseRoute(): Route {
+        return this._baseRoute;
+    }
+    public set baseRoute(v: Route) {
+        this._baseRoute = v;
+    }
+
+    public constructor(
+        protocol: Protocol,
+        hostname: Hostname,
+        baseRoute?: Route
+    ) {
+        this.protocol = protocol;
+        this.hostname = hostname;
+
+        if (baseRoute) {
+            this.baseRoute = baseRoute;
+        } else {
+            this.baseRoute = new Route('/');
+        }
+    }
+
+    public async get<
+        T extends JSONObject | JSONArray | BaseModel | Array<BaseModel>
+    >(
+        path: Route,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await API.get<T>(
+            new URL(
+                this.protocol,
+                this.hostname,
+                this.baseRoute.addRoute(path)
+            ),
+            data,
+            headers
+        );
+    }
+
+    public async delete<
+        T extends JSONObject | JSONArray | BaseModel | Array<BaseModel>
+    >(
+        path: Route,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await API.delete<T>(
+            new URL(
+                this.protocol,
+                this.hostname,
+                this.baseRoute.addRoute(path)
+            ),
+            data,
+            headers
+        );
+    }
+
+    public async head<
+        T extends JSONObject | JSONArray | BaseModel | Array<BaseModel>
+    >(
+        path: Route,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await API.head<T>(
+            new URL(
+                this.protocol,
+                this.hostname,
+                this.baseRoute.addRoute(path)
+            ),
+            data,
+            headers
+        );
+    }
+
+    public async put<
+        T extends JSONObject | JSONArray | BaseModel | Array<BaseModel>
+    >(
+        path: Route,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await API.put<T>(
+            new URL(
+                this.protocol,
+                this.hostname,
+                this.baseRoute.addRoute(path)
+            ),
+            data,
+            headers
+        );
+    }
+
+    public async post<
+        T extends JSONObject | JSONArray | BaseModel | Array<BaseModel>
+    >(
+        path: Route,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await API.post<T>(
+            new URL(
+                this.protocol,
+                this.hostname,
+                this.baseRoute.addRoute(path)
+            ),
+            data,
+            headers
+        );
+    }
+
+    protected static handleError(
+        error: HTTPErrorResponse | APIException
+    ): HTTPErrorResponse | APIException {
+        return error;
+    }
+
+    protected static async onResponseSuccessHeaders(
+        headers: Dictionary<string>
+    ): Promise<Dictionary<string>> {
+        return Promise.resolve(headers);
+    }
+
+    public static getDefaultHeaders(_props?: any): Headers {
+        const defaultHeaders: Headers = {
+            'Access-Control-Allow-Origin': '*',
+            Accept: 'application/json',
+            'Content-Type': 'application/json;charset=UTF-8',
+        };
+
+        return defaultHeaders;
+    }
+
+    protected static getHeaders(headers?: Headers): Headers {
+        let defaultHeaders: Headers = this.getDefaultHeaders();
+
+        if (headers) {
+            defaultHeaders = {
+                ...defaultHeaders,
+                ...headers,
+            };
+        }
+
+        return defaultHeaders;
+    }
+
+    public static async get<
+        T extends
+            | JSONObject
+            | JSONArray
+            | BaseModel
+            | Array<BaseModel>
+            | AnalyticsBaseModel
+            | Array<AnalyticsBaseModel>
+    >(
+        url: URL,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await this.fetch<T>(HTTPMethod.GET, url, data, headers);
+    }
+
+    public static async delete<
+        T extends
+            | JSONObject
+            | JSONArray
+            | BaseModel
+            | Array<BaseModel>
+            | AnalyticsBaseModel
+            | Array<AnalyticsBaseModel>
+    >(
+        url: URL,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await this.fetch(HTTPMethod.DELETE, url, data, headers);
+    }
+
+    public static async head<
+        T extends
+            | JSONObject
+            | JSONArray
+            | BaseModel
+            | Array<BaseModel>
+            | AnalyticsBaseModel
+            | Array<AnalyticsBaseModel>
+    >(
+        url: URL,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await this.fetch(HTTPMethod.HEAD, url, data, headers);
+    }
+
+    public static async put<
+        T extends
+            | JSONObject
+            | JSONArray
+            | BaseModel
+            | Array<BaseModel>
+            | AnalyticsBaseModel
+            | Array<AnalyticsBaseModel>
+    >(
+        url: URL,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await this.fetch(HTTPMethod.PUT, url, data, headers);
+    }
+
+    public static async post<
+        T extends
+            | JSONObject
+            | JSONArray
+            | BaseModel
+            | Array<BaseModel>
+            | AnalyticsBaseModel
+            | Array<AnalyticsBaseModel>
+    >(
+        url: URL,
+        data?: JSONObject | JSONArray,
+        headers?: Headers
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        return await this.fetch(HTTPMethod.POST, url, data, headers);
+    }
+
+    public static async fetch<
+        T extends
+            | JSONObject
+            | JSONArray
+            | BaseModel
+            | Array<BaseModel>
+            | AnalyticsBaseModel
+            | Array<AnalyticsBaseModel>
+    >(
+        method: HTTPMethod,
+        url: URL,
+        data?: JSONObject | JSONArray,
+        headers?: Headers,
+        params?: Dictionary<string>
+    ): Promise<HTTPResponse<T> | HTTPErrorResponse> {
+        const apiHeaders: Headers = this.getHeaders(headers);
+
+        if (params) {
+            url.addQueryParams(params);
+        }
+
+        try {
+            const finalHeaders: Dictionary<string> = {
+                ...apiHeaders,
+                ...headers,
+            };
+
+            let finalBody:
+                | JSONObject
+                | JSONArray
+                | URLSearchParams
+                | undefined = data;
+
+            // if content-type is form-url-encoded, then stringify the data
+
+            if (
+                finalHeaders['Content-Type'] ===
+                    'application/x-www-form-urlencoded' &&
+                data
+            ) {
+                finalBody = new URLSearchParams(data as Dictionary<string>);
+            }
+
+            const result: AxiosResponse = await axios({
+                method: method,
+                url: url.toString(),
+                headers: finalHeaders,
+                data: finalBody,
+            });
+
+            result.headers = await this.onResponseSuccessHeaders(
+                result.headers as Dictionary<string>
+            );
+
+            const response: HTTPResponse<T> = new HTTPResponse<T>(
+                result.status,
+                result.data,
+                result.headers as Dictionary<string>
+            );
+
+            return response;
+        } catch (e) {
+            const error: Error | AxiosError = e as Error | AxiosError;
+            let errorResponse: HTTPErrorResponse;
+            if (axios.isAxiosError(error)) {
+                // Do whatever you want with native error
+                errorResponse = this.getErrorResponse(error);
+            } else {
+                throw new APIException(error.message);
+            }
+
+            this.handleError(errorResponse);
+            return errorResponse;
+        }
+    }
+
+    private static getErrorResponse(error: AxiosError): HTTPErrorResponse {
+        if (error.response) {
+            return new HTTPErrorResponse(
+                error.response.status,
+                error.response.data as JSONObject | JSONArray,
+                error.response.headers as Dictionary<string>
+            );
+        }
+
+        throw new APIException('Endpoint is not available');
+    }
+}

package/Utils/Analytics.ts

@@ -0,0 +1,42 @@
+import Email from '../Types/Email';
+import { JSONObject } from '../Types/JSON';
+import posthog from 'posthog-js';
+
+export default class Analytics {
+    private _isInitialized: boolean = false;
+    public get isInitialized(): boolean {
+        return this._isInitialized;
+    }
+    public set isInitialized(v: boolean) {
+        this._isInitialized = v;
+    }
+
+    public constructor(apiHost: string, apiKey: string) {
+        if (apiHost && apiKey) {
+            posthog.init(apiKey, { api_host: apiHost, autocapture: false });
+            this.isInitialized = true;
+        }
+    }
+
+    public userAuth(email: Email): void {
+        if (!this.isInitialized) {
+            return;
+        }
+        posthog.identify(email.toString());
+    }
+
+    public logout(): void {
+        if (!this.isInitialized) {
+            return;
+        }
+        posthog.reset();
+    }
+
+    public capture(eventName: string, data?: JSONObject): void {
+        if (!this.isInitialized) {
+            return;
+        }
+
+        posthog.capture(eventName, data);
+    }
+}

package/Utils/CronTime.ts

@@ -0,0 +1,6 @@
+export const EVERY_MINUTE: string = '* * * * *';
+export const EVERY_DAY: string = '0 8 * * *';
+export const EVERY_HOUR: string = '1 * * * *';
+export const EVERY_FIVE_MINUTE: string = '*/5 * * * *';
+export const EVERY_FIVE_SECONDS: string = '*/5 * * * * *';
+export const EVERY_WEEK: string = '0 0 * * 0';

package/Utils/Faker.ts

@@ -0,0 +1,34 @@
+import { faker } from '@faker-js/faker';
+import Email from '../Types/Email';
+import Name from '../Types/Name';
+import Phone from '../Types/Phone';
+
+export default class Faker {
+    public static generateName(): string {
+        return faker.string.alphanumeric(10);
+    }
+
+    public static generateCompanyName(): string {
+        return faker.company.name();
+    }
+
+    public static randomNumbers(count: number): string {
+        const randomNumbers: Array<number> = [];
+        for (let i: number = 0; i < count; i++) {
+            randomNumbers.push(Math.floor(Math.random() * 10)); // You can adjust the range as needed
+        }
+        return randomNumbers.join('');
+    }
+
+    public static generateUserFullName(): Name {
+        return new Name(faker.person.fullName());
+    }
+
+    public static generateEmail(): Email {
+        return new Email(faker.internet.email());
+    }
+
+    public static generatePhone(): Phone {
+        return new Phone(faker.phone.number('+1##########'));
+    }
+}

package/Utils/Realtime.ts

@@ -0,0 +1,39 @@
+import DatabaseType from '../Types/BaseDatabase/DatabaseType';
+import { JSONObject } from '../Types/JSON';
+import ObjectID from '../Types/ObjectID';
+
+export enum EventName {
+    ListenToModalEvent = 'ListenToModelEvent',
+}
+
+export enum ModelEventType {
+    Create = 'Create',
+    Update = 'Update',
+    Delete = 'Delete',
+}
+
+export interface ListenToModelEventJSON {
+    modelName: string;
+    modelType: DatabaseType;
+    query: JSONObject;
+    eventType: ModelEventType;
+    tenantId: string;
+    select: JSONObject;
+}
+
+export interface EnableRealtimeEventsOn {
+    create?: boolean | undefined;
+    update?: boolean | undefined;
+    delete?: boolean | undefined;
+    read?: boolean | undefined;
+}
+
+export default class RealtimeUtil {
+    public static getRoomId(
+        tenantId: string | ObjectID,
+        modelName: string,
+        eventType: ModelEventType
+    ): string {
+        return tenantId.toString() + '-' + modelName + '-' + eventType;
+    }
+}

package/Utils/Slug.ts

@@ -0,0 +1,21 @@
+import slugify from 'slugify';
+import Faker from './Faker';
+
+export default class Slug {
+    public static getSlug(name: string | null): string {
+        if (name === null) {
+            name = Faker.generateName();
+        }
+
+        name = String(name);
+        if (!name || !name.trim()) {
+            return '';
+        }
+
+        let slug: string = slugify(name, { remove: /[&*+~.,\\/()|'"!:@]+/g });
+        slug = `${slug}-${Faker.randomNumbers(10)}`;
+        slug = slug.toLowerCase();
+
+        return slug;
+    }
+}

package/Utils/UUID.ts

@@ -0,0 +1,7 @@
+import { v1 as uuidv1 } from 'uuid';
+
+export default class UUID {
+    public static generate(): string {
+        return uuidv1();
+    }
+}