@oneuptime/common 1.0.0

package/Types/Exception/DatabaseNotConnectedException.ts

@@ -0,0 +1,11 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class DatabaseNotConnectedException extends Exception {
+    public constructor(message?: string) {
+        super(
+            ExceptionCode.DatabaseNotConnectedException,
+            message || 'Database not connected'
+        );
+    }
+}

package/Types/Exception/Exception.ts

@@ -0,0 +1,22 @@
+import ExceptionCode from './ExceptionCode';
+
+export default class Exception extends Error {
+    private _code: ExceptionCode = ExceptionCode.GeneralException;
+
+    public get code(): ExceptionCode {
+        return this._code;
+    }
+
+    public set code(value: ExceptionCode) {
+        this._code = value;
+    }
+
+    public constructor(code: ExceptionCode, message: string) {
+        super(message);
+        this.code = code;
+    }
+
+    public getMessage(): string {
+        return this.message;
+    }
+}

package/Types/Exception/ExceptionCode.ts

@@ -0,0 +1,21 @@
+enum ExceptionCode {
+    NotImplementedException = 0,
+    GeneralException = 1,
+    APIException = 2,
+    DatabaseNotConnectedException = 3,
+    BadOperationException = 5,
+    WebRequestException = 6,
+    BadDataException = 400,
+    BadRequestException = 400,
+    UnabletoReachServerException = 415,
+    ServerException = 500,
+    NotAuthorizedException = 403,
+    NotAuthenticatedException = 401,
+    PaymentRequiredException = 402,
+    NotFoundException = 404,
+    TimeoutException = 408,
+    TenantNotFoundException = 405,
+    SsoAuthorizationException = 406,
+}
+
+export default ExceptionCode;

package/Types/Exception/NotAuthenticatedException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class NotAuthenticatedException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.NotAuthenticatedException, message);
+    }
+}

package/Types/Exception/NotAuthorizedException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class NotAuthorizedException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.NotAuthorizedException, message);
+    }
+}

package/Types/Exception/NotFoundException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class NotFoundException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.NotFoundException, message);
+    }
+}

package/Types/Exception/NotImplementedException.ts

@@ -0,0 +1,11 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class NotImplementedException extends Exception {
+    public constructor() {
+        super(
+            ExceptionCode.NotImplementedException,
+            'This code is not implemented'
+        );
+    }
+}

package/Types/Exception/PaymentRequiredException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class PaymentRequiredException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.PaymentRequiredException, message);
+    }
+}

package/Types/Exception/ServerException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class ServerException extends Exception {
+    public constructor(message?: string) {
+        super(ExceptionCode.ServerException, message || 'Server Error');
+    }
+}

package/Types/Exception/SsoAuthorizationException.ts

@@ -0,0 +1,17 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class SSOAuthorizationException extends Exception {
+    private static message: string = 'SSO Authorization Required';
+
+    public constructor() {
+        super(
+            ExceptionCode.SsoAuthorizationException,
+            SSOAuthorizationException.message
+        );
+    }
+
+    public static isException(errorMessage: string): boolean {
+        return errorMessage === SSOAuthorizationException.message;
+    }
+}

package/Types/Exception/TenantNotFoundException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class TenantNotFoundException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.TenantNotFoundException, message);
+    }
+}

package/Types/Exception/TimeoutException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class TimeoutException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.TimeoutException, message);
+    }
+}

package/Types/Exception/UnableToReachServer.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class UnableToReachServer extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.UnabletoReachServerException, message);
+    }
+}

package/Types/Exception/WebsiteRequestException.ts

@@ -0,0 +1,8 @@
+import Exception from './Exception';
+import ExceptionCode from './ExceptionCode';
+
+export default class WebsiteRequestException extends Exception {
+    public constructor(message: string) {
+        super(ExceptionCode.WebRequestException, message);
+    }
+}

package/Types/File/MimeType.ts

@@ -0,0 +1,12 @@
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
+
+enum MimeType {
+    aac = 'audio/aac',
+    png = 'image/png',
+    jpg = 'image/jpeg',
+    jpeg = 'image/jpeg',
+
+    // TODO add more mime types.
+}
+
+export default MimeType;

package/Types/File.ts

@@ -0,0 +1,4 @@
+export interface File {
+    name: string;
+    contentType: string;
+}

package/Types/Filter/Filter.ts

@@ -0,0 +1 @@
+export default class Filter {}

package/Types/Filter/FilterCondition.ts

@@ -0,0 +1,6 @@
+enum FilterCondition {
+    And = 'And',
+    Or = 'Or',
+}
+
+export default FilterCondition;

package/Types/Filter/FilterType.ts

@@ -0,0 +1,10 @@
+enum FilterType {
+    EqualTo = 'EqualTo',
+    NotEqualTo = 'NotEqualTo',
+    LessThan = 'LessThan',
+    GreaterThan = 'GreaterThan',
+    GreaterThanOrEqualTo = 'GreaterThanOrEqualTo',
+    LessThanOrEqualTo = 'LessThanOrEqualTo',
+}
+
+export default FilterType;

package/Types/FunctionTypes.ts

@@ -0,0 +1,4 @@
+export type PromiseVoidFunction = () => Promise<void>;
+export type VoidFunction = () => void;
+export type ErrorFunction = (err: Error) => void;
+export type PromiseRejectErrorFunction = (err: Error) => void;

package/Types/GenericFunction.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+type GenericFunction = Function;
+
+export default GenericFunction;

package/Types/GenericObject.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line @typescript-eslint/ban-types
+type GenericObject = Object;
+
+export default GenericObject;

package/Types/HashCode.ts

@@ -0,0 +1,11 @@
+export default class HashCode {
+    public static fromString(text: string): number {
+        let hash: number = 0;
+        for (let i: number = 0; i < text.length; i++) {
+            const code: number = text.charCodeAt(i);
+            hash = (hash << 5) - hash + code;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+        return hash;
+    }
+}

package/Types/HashedString.ts

@@ -0,0 +1,105 @@
+import { FindOperator } from 'typeorm';
+import UUID from '../Utils/UUID';
+import DatabaseProperty from './Database/DatabaseProperty';
+import BadOperationException from './Exception/BadOperationException';
+import ObjectID from './ObjectID';
+import CryptoJS from 'crypto-js';
+import { JSONObject, ObjectType } from './JSON';
+import BadDataException from './Exception/BadDataException';
+
+export default class HashedString extends DatabaseProperty {
+    private isHashed: boolean = false;
+
+    private _value: string = '';
+    public get value(): string {
+        return this._value;
+    }
+    public set value(v: string) {
+        this._value = v;
+    }
+
+    public constructor(value: string, isValueHashed: boolean = false) {
+        super();
+        this.value = value;
+        this.isHashed = isValueHashed;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.HashedString,
+            value: (this as HashedString).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): HashedString {
+        if (json['_type'] === ObjectType.HashedString) {
+            return new HashedString((json['value'] as string) || '');
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    public override toString(): string {
+        return this.value;
+    }
+
+    public static generate(): HashedString {
+        return new this(UUID.generate());
+    }
+
+    protected static override toDatabase(
+        value: HashedString | FindOperator<HashedString>
+    ): string | null {
+        if (value) {
+            if (typeof value === 'string') {
+                value = new HashedString(value);
+            }
+
+            return value.toString();
+        }
+
+        return null;
+    }
+
+    public isValueHashed(): boolean {
+        return this.isHashed;
+    }
+
+    public async hashValue(encryptionSecret: ObjectID | null): Promise<string> {
+        if (!this.value) {
+            return '';
+        }
+
+        if (this.isHashed) {
+            throw new BadOperationException('Value is already hashed');
+        }
+
+        const valueToHash: string = (encryptionSecret || '') + this.value;
+        this.isHashed = true;
+
+        this.value = CryptoJS.SHA256(valueToHash).toString();
+        return this.value;
+    }
+
+    public static async hashValue(
+        value: string,
+        encryptionSecret: ObjectID | null
+    ): Promise<string> {
+        const hashstring: HashedString = new HashedString(value, false);
+        return await hashstring.hashValue(encryptionSecret);
+    }
+
+    protected static override fromDatabase(
+        _value: string
+    ): HashedString | null {
+        if (_value) {
+            return new HashedString(_value, true);
+        }
+
+        return null;
+    }
+
+    public static fromString(value: string): HashedString {
+        return new HashedString(value, false);
+    }
+}

package/Types/Html.ts

@@ -0,0 +1,17 @@
+export default class HTML {
+    private _html: string = '';
+    public get html(): string {
+        return this._html;
+    }
+    public set html(v: string) {
+        this._html = v;
+    }
+
+    public constructor(html: string) {
+        this.html = html;
+    }
+
+    public toString(): string {
+        return this.html;
+    }
+}

package/Types/IP/IP.ts

@@ -0,0 +1,114 @@
+import { FindOperator } from 'typeorm';
+import DatabaseProperty from '../Database/DatabaseProperty';
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import Typeof from '../Typeof';
+import IPType from './IPType';
+
+export default class IP extends DatabaseProperty {
+    private _ip: string = '';
+    protected type: IPType = IPType.IPv4;
+    public get ip(): string {
+        return this._ip;
+    }
+    public set ip(value: string) {
+        if (IP.isIPv4(value)) {
+            this._ip = value;
+            this.type = IPType.IPv4;
+        } else if (IP.isIPv6(value)) {
+            this._ip = value;
+            this.type = IPType.IPv6;
+        } else {
+            throw new BadDataException('IP is not a valid address');
+        }
+    }
+
+    public constructor(ip: string) {
+        super();
+
+        this.ip = ip;
+    }
+
+    public static fromString(ip: string): IP {
+        return new IP(ip);
+    }
+
+    public static isIP(ip: string): boolean {
+        if (IP.isIPv4(ip) || IP.isIPv6(ip)) {
+            return true;
+        }
+        return false;
+    }
+
+    public override toString(): string {
+        return this.ip;
+    }
+
+    private static isIPv4(str: string): boolean {
+        const regexExp: RegExp =
+            /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/gi;
+        const result: boolean = regexExp.test(str);
+
+        return result;
+    }
+
+    private static isIPv6(str: string): boolean {
+        const regexExp: RegExp =
+            /(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))/gi;
+        return regexExp.test(str);
+    }
+
+    public isIPv4(): boolean {
+        if (IP.isIPv4(this.ip)) {
+            return true;
+        }
+        return false;
+    }
+
+    public isIPv6(): boolean {
+        if (IP.isIPv6(this.ip)) {
+            return true;
+        }
+        return false;
+    }
+
+    public static override fromJSON(json: JSONObject): IP {
+        if (json && json['_type'] !== ObjectType.IP) {
+            throw new BadDataException('Invalid JSON for IP');
+        }
+
+        if (json && json['value'] && typeof json['value'] !== Typeof.String) {
+            throw new BadDataException('Invalid JSON for IP');
+        }
+
+        return new IP(json['value'] as string);
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            value: this.toString(),
+            _type: ObjectType.IP,
+        };
+    }
+
+    public static override toDatabase(
+        value: IP | FindOperator<IP>
+    ): string | null {
+        if (value) {
+            if (typeof value === 'string') {
+                value = new IP(value);
+            }
+
+            return value.toString();
+        }
+
+        return null;
+    }
+
+    public static override fromDatabase(value: string): IP | null {
+        if (value) {
+            return new IP(value);
+        }
+        return null;
+    }
+}

package/Types/IP/IPType.ts

@@ -0,0 +1,6 @@
+enum IPType {
+    IPv4 = 'IPv4',
+    IPv6 = 'IPv6',
+}
+
+export default IPType;

package/Types/IP/IPv4.ts

@@ -0,0 +1,12 @@
+import BadDataException from '../Exception/BadDataException';
+import IP from './IP';
+
+export default class IPv4 extends IP {
+    public constructor(ip: string) {
+        super(ip);
+
+        if (!this.isIPv4()) {
+            throw new BadDataException('IP is not a valid IPv4 address');
+        }
+    }
+}

package/Types/IP/IPv6.ts

@@ -0,0 +1,12 @@
+import BadDataException from '../Exception/BadDataException';
+import IP from './IP';
+
+export default class IPv4 extends IP {
+    public constructor(ip: string) {
+        super(ip);
+
+        if (!this.isIPv6()) {
+            throw new BadDataException('IP is not a valid IPv6 address');
+        }
+    }
+}

package/Types/Icon/IconProp.ts

@@ -0,0 +1,125 @@
+enum IconProp {
+    File = 'File',
+    Automation = 'Automation',
+    Workflow = 'Workflow',
+    TableCells = 'TableCells',
+    Layout = 'Layout',
+    Compass = 'Compass',
+    User = 'User',
+    Disc = 'Disc',
+    Settings = 'Settings',
+    Criteria = 'Criteria',
+    Notification = 'Notification',
+    CursorArrowRays = 'CursorArrowRays',
+    ArrowUpDown = 'ArrowUpDown',
+    Cube = 'Cube',
+    Swatch = 'Swatch',
+    Squares = 'Squares',
+    RectangleStack = 'RectangleStack',
+    ChartBar = 'ChartBar',
+    CircleClose = 'CircleClose',
+    SquareStack = 'SquareStack',
+    Calendar = 'Calendar',
+    Help = 'Help',
+    Reload = 'Reload',
+    Book = 'Book',
+    JSON = 'JSON',
+    Signal = 'Signal',
+    Stop = 'Stop',
+    Database = 'Database',
+    ChevronDown = 'ChevronDown',
+    Pencil = 'Pencil',
+    Flag = 'Flag',
+    Copy = 'Copy',
+    ChevronRight = 'ChevronRight',
+    ChevronUp = 'ChevronUp',
+    Play = 'Play',
+    ChevronLeft = 'ChevronLeft',
+    UpDownArrow = 'UpDownArrow',
+    Public = 'Public',
+    Home = 'Home',
+    Graph = 'Graph',
+    Variable = 'Variable',
+    ListBullet = 'ListBullet',
+    Image = 'Image',
+    Grid = 'Grid',
+    More = 'More',
+    Condition = 'Condition',
+    Activity = 'Activity',
+    Alert = 'Alert',
+    Call = 'Call',
+    List = 'List',
+    CheckCircle = 'CheckCircle',
+    Search = 'Search',
+    TextFile = 'TextFile',
+    Globe = 'Globe',
+    Logout = 'Logout',
+    Billing = 'Billing',
+    Email = 'Email',
+    Slack = 'Slack',
+    Time = 'Time',
+    Terminal = 'Terminal',
+    Drag = 'Drag',
+    Error = 'Error',
+    Code = 'Code',
+    Report = 'Report',
+    Team = 'Team',
+    Lock = 'Lock',
+    Key = 'Key',
+    Folder = 'Folder',
+    Integrations = 'Integrations',
+    SMS = 'SMS',
+    Info = 'Info',
+    Success = 'Success',
+    Trash = 'Trash',
+    Close = 'Close',
+    RSS = 'RSS',
+    Add = 'Add',
+    Label = 'Label',
+    Refresh = 'Refresh',
+    Filter = 'Filter',
+    Edit = 'Edit',
+    Hide = 'Hide',
+    Check = 'Check',
+    True = 'True',
+    False = 'False',
+    Text = 'Text',
+    Circle = 'Circle',
+    Webhook = 'Webhook',
+    SendMessage = 'SendMessage',
+    ExternalLink = 'ExternalLink',
+    Link = 'Link',
+    Layers = 'Layers',
+    Clock = 'Clock',
+    Invoice = 'Invoice',
+    Upgrade = 'Upgrade',
+    Star = 'Star',
+    Download = 'Download',
+    ErrorSolid = 'ErrorSolid',
+    Spinner = 'Spinner',
+    AltGlobe = 'AltGlobe',
+    ArrowCircleRight = 'ArrowCircleRight',
+    ArrowCircleUp = 'ArrowCircleUp',
+    ArrowCircleDown = 'ArrowCircleDown',
+    ArrowCircleLeft = 'ArrowCircleLeft',
+    Announcement = 'Announcement',
+    Window = 'Window',
+    AddFolder = 'AddFolder',
+    AddImage = 'AddImage',
+    Chat = 'Chat',
+    Wrench = 'Wrench',
+    TransparentCube = 'TransparentCube',
+    Logs = 'Logs',
+    Bolt = 'Bolt',
+    BarsArrowUp = 'BarsArrowUp',
+    BarsArrowDown = 'BarsArrowDown',
+    Bell = 'Bell',
+    BellRinging = 'BellRinging',
+    AdjustmentVertical = 'AdjustmentVertical',
+    AdjustmentHorizontal = 'AdjustmentHorizontal',
+    Minus = 'Minus',
+    MinusSmall = 'MinusSmall',
+    Template = 'Template',
+}
+
+export default IconProp;

package/Types/IncomingRequest/IncomingRequestCustomFields.ts

@@ -0,0 +1 @@
+export default class IncomingRequestCustomFields {}

package/Types/Infrastructure/BasicMetrics.ts

@@ -0,0 +1,26 @@
+export interface MemoryMetrics {
+    total: number;
+    free: number;
+    used: number;
+    percentUsed: number;
+    percentFree: number;
+}
+
+export interface CPUMetrics {
+    percentUsage: number;
+}
+
+export interface BasicDiskMetrics {
+    total: number;
+    free: number;
+    used: number;
+    diskPath: string;
+    percentUsed: number;
+    percentFree: number;
+}
+
+export default interface BasicInfrastructureMetrics {
+    cpuMetrics: CPUMetrics;
+    memoryMetrics: MemoryMetrics;
+    diskMetrics: Array<BasicDiskMetrics>;
+}