@oneuptime/common 7.0.2513 → 7.0.2550

package/Types/Database/DatabaseProperty.ts

@@ -1,51 +1,51 @@
-import NotImplementedException from '../Exception/NotImplementedException';
-import { JSONArray, JSONObject } from '../JSON';
-import SerializableObject from '../SerializableObject';
-import { FindOperator } from 'typeorm';
-import { ValueTransformer } from 'typeorm/decorator/options/ValueTransformer';
+import NotImplementedException from "../Exception/NotImplementedException";
+import { JSONArray, JSONObject } from "../JSON";
+import SerializableObject from "../SerializableObject";
+import { FindOperator } from "typeorm";
+import { ValueTransformer } from "typeorm/decorator/options/ValueTransformer";
 
 export default class DatabaseProperty extends SerializableObject {
-    public constructor() {
-        super();
-    }
+  public constructor() {
+    super();
+  }
 
-    protected static fromDatabase(
-        _value: string | number | JSONObject | JSONArray
-    ): DatabaseProperty | null {
-        throw new NotImplementedException();
-    }
+  protected static fromDatabase(
+    _value: string | number | JSONObject | JSONArray,
+  ): DatabaseProperty | null {
+    throw new NotImplementedException();
+  }
 
-    protected static toDatabase(
-        _value: DatabaseProperty | FindOperator<DatabaseProperty>
-    ): string | number | JSONObject | JSONArray | null {
-        throw new NotImplementedException();
-    }
+  protected static toDatabase(
+    _value: DatabaseProperty | FindOperator<DatabaseProperty>,
+  ): string | number | JSONObject | JSONArray | null {
+    throw new NotImplementedException();
+  }
 
-    protected static _fromDatabase(
-        value: string | number | JSONObject | JSONArray
-    ): DatabaseProperty | null {
-        return this.fromDatabase(value);
-    }
+  protected static _fromDatabase(
+    value: string | number | JSONObject | JSONArray,
+  ): DatabaseProperty | null {
+    return this.fromDatabase(value);
+  }
 
-    protected static _toDatabase(
-        value: DatabaseProperty | FindOperator<DatabaseProperty>
-    ): string | number | JSONObject | JSONArray | null {
-        // if its a RAW query. Return a raw query.
-        if (value && (value as any)._type === 'raw') {
-            return value as any;
-        }
-
-        return this.toDatabase(value);
+  protected static _toDatabase(
+    value: DatabaseProperty | FindOperator<DatabaseProperty>,
+  ): string | number | JSONObject | JSONArray | null {
+    // if its a RAW query. Return a raw query.
+    if (value && (value as any)._type === "raw") {
+      return value as any;
     }
 
-    public static getDatabaseTransformer(): ValueTransformer {
-        return {
-            to: (value: any) => {
-                return this._toDatabase(value);
-            },
-            from: (value: any) => {
-                return this._fromDatabase(value);
-            },
-        };
-    }
+    return this.toDatabase(value);
+  }
+
+  public static getDatabaseTransformer(): ValueTransformer {
+    return {
+      to: (value: any) => {
+        return this._toDatabase(value);
+      },
+      from: (value: any) => {
+        return this._fromDatabase(value);
+      },
+    };
+  }
 }

package/Types/Database/Date.ts

@@ -1,28 +1,28 @@
-import InBetween from '../BaseDatabase/InBetween';
-import OneUptimeDate from '../Date';
+import InBetween from "../BaseDatabase/InBetween";
+import OneUptimeDate from "../Date";
 
 export default class DatabaseDate {
-    public static asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
-        date: string | Date
-    ): InBetween {
-        let startValue: string | Date = date;
+  public static asDateStartOfTheDayEndOfTheDayForDatabaseQuery(
+    date: string | Date,
+  ): InBetween {
+    let startValue: string | Date = date;
 
-        if (!(startValue instanceof Date)) {
-            startValue = OneUptimeDate.fromString(startValue);
-        }
+    if (!(startValue instanceof Date)) {
+      startValue = OneUptimeDate.fromString(startValue);
+    }
 
-        let endValue: string | Date = date;
+    let endValue: string | Date = date;
 
-        if (!(endValue instanceof Date)) {
-            endValue = OneUptimeDate.fromString(endValue);
-        }
+    if (!(endValue instanceof Date)) {
+      endValue = OneUptimeDate.fromString(endValue);
+    }
 
-        startValue = OneUptimeDate.getStartOfDay(startValue);
-        endValue = OneUptimeDate.getEndOfDay(endValue);
+    startValue = OneUptimeDate.getStartOfDay(startValue);
+    endValue = OneUptimeDate.getEndOfDay(endValue);
 
-        return new InBetween(
-            OneUptimeDate.toDatabaseDate(startValue),
-            OneUptimeDate.toDatabaseDate(endValue)
-        );
-    }
+    return new InBetween(
+      OneUptimeDate.toDatabaseDate(startValue),
+      OneUptimeDate.toDatabaseDate(endValue),
+    );
+  }
 }

package/Types/Database/EnableDocumentation.ts

@@ -1,13 +1,12 @@
-import GenericFunction from '../GenericFunction';
+import GenericFunction from "../GenericFunction";
 
 export interface EnableDocumentationProps {
-    isMasterAdminApiDocs?: boolean | undefined;
+  isMasterAdminApiDocs?: boolean | undefined;
 }
 
 export default (props?: EnableDocumentationProps | undefined) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.enableDocumentation = true;
-        ctr.prototype.isMasterAdminApiDocs =
-            props?.isMasterAdminApiDocs || false;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.enableDocumentation = true;
+    ctr.prototype.isMasterAdminApiDocs = props?.isMasterAdminApiDocs || false;
+  };
 };

package/Types/Database/EnableWorkflow.ts

@@ -1,8 +1,8 @@
-import EnableWorkflowOn from '../BaseDatabase/EnableWorkflowOn';
-import GenericFunction from '../GenericFunction';
+import EnableWorkflowOn from "../BaseDatabase/EnableWorkflowOn";
+import GenericFunction from "../GenericFunction";
 
 export default (enableWorkflowOn: EnableWorkflowOn) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.enableWorkflowOn = enableWorkflowOn;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.enableWorkflowOn = enableWorkflowOn;
+  };
 };

package/Types/Database/IsPermissionsIf.ts

@@ -1,18 +1,18 @@
-import GenericFunction from '../GenericFunction';
-import Permission from '../Permission';
+import GenericFunction from "../GenericFunction";
+import Permission from "../Permission";
 
 export default (
-    permission: Permission,
-    columnName: string,
-    value: string | boolean | null
+  permission: Permission,
+  columnName: string,
+  value: string | boolean | null,
 ) => {
-    return (ctr: GenericFunction) => {
-        if (!ctr.prototype.isPermissionIf) {
-            ctr.prototype.isPermissionIf = {};
-        }
+  return (ctr: GenericFunction) => {
+    if (!ctr.prototype.isPermissionIf) {
+      ctr.prototype.isPermissionIf = {};
+    }
 
-        ctr.prototype.isPermissionIf[permission] = {
-            [columnName]: value,
-        };
+    ctr.prototype.isPermissionIf[permission] = {
+      [columnName]: value,
     };
+  };
 };

package/Types/Database/LabelsColumn.ts

@@ -1,7 +1,7 @@
-import GenericFunction from '../GenericFunction';
+import GenericFunction from "../GenericFunction";
 
 export default (columnName: string) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.labelsColumn = columnName;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.labelsColumn = columnName;
+  };
 };

package/Types/Database/MultiTenentQueryAllowed.ts

@@ -1,7 +1,7 @@
-import GenericFunction from '../GenericFunction';
+import GenericFunction from "../GenericFunction";
 
 export default (allowed: boolean) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.isMultiTenantRequestAllowed = allowed;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.isMultiTenantRequestAllowed = allowed;
+  };
 };

package/Types/Database/PartialEntity.ts

@@ -1,3 +1,3 @@
-import { QueryDeepPartialEntity } from 'typeorm/query-builder/QueryPartialEntity';
+import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 
 export default QueryDeepPartialEntity;

package/Types/Database/SlugifyColumn.ts

@@ -1,8 +1,8 @@
-import GenericFunction from '../GenericFunction';
+import GenericFunction from "../GenericFunction";
 
 export default (columnName: string, saveSlugToColumnName: string) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.slugifyColumn = columnName;
-        ctr.prototype.saveSlugToColumn = saveSlugToColumnName;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.slugifyColumn = columnName;
+    ctr.prototype.saveSlugToColumn = saveSlugToColumnName;
+  };
 };

package/Types/Database/TableColumn.ts

@@ -1,66 +1,66 @@
-import BaseModel, { BaseModelType } from '../../Models/BaseModel';
-import Dictionary from '../Dictionary';
-import { ReflectionMetadataType } from '../Reflection';
-import TableColumnType from './TableColumnType';
-import 'reflect-metadata';
+import BaseModel, { BaseModelType } from "../../Models/BaseModel";
+import Dictionary from "../Dictionary";
+import { ReflectionMetadataType } from "../Reflection";
+import TableColumnType from "./TableColumnType";
+import "reflect-metadata";
 
-const tableColumn: Symbol = Symbol('TableColumn');
+const tableColumn: symbol = Symbol("TableColumn");
 
 export interface TableColumnMetadata {
-    title?: string;
-    description?: string;
-    placeholder?: string;
-    isDefaultValueColumn?: boolean;
-    required?: boolean;
-    unique?: boolean;
-    hashed?: boolean;
-    encrypted?: boolean;
-    manyToOneRelationColumn?: string;
-    type: TableColumnType;
-    canReadOnRelationQuery?: boolean;
-    modelType?: BaseModelType;
-    forceGetDefaultValueOnCreate?: () => string | number | boolean; // overwrites any value that is being passed and generates a new one. Useful for generating OTPs, etc.
+  title?: string;
+  description?: string;
+  placeholder?: string;
+  isDefaultValueColumn?: boolean;
+  required?: boolean;
+  unique?: boolean;
+  hashed?: boolean;
+  encrypted?: boolean;
+  manyToOneRelationColumn?: string;
+  type: TableColumnType;
+  canReadOnRelationQuery?: boolean;
+  modelType?: BaseModelType;
+  forceGetDefaultValueOnCreate?: () => string | number | boolean; // overwrites any value that is being passed and generates a new one. Useful for generating OTPs, etc.
 }
 
 export default (props: TableColumnMetadata): ReflectionMetadataType => {
-    return Reflect.metadata(tableColumn, props);
+  return Reflect.metadata(tableColumn, props);
 };
 
 type GetTableColumnFunction = <T extends BaseModel>(
-    target: T,
-    propertyKey: string
+  target: T,
+  propertyKey: string,
 ) => TableColumnMetadata;
 
 export const getTableColumn: GetTableColumnFunction = <T extends BaseModel>(
-    target: T,
-    propertyKey: string
+  target: T,
+  propertyKey: string,
 ): TableColumnMetadata => {
-    return Reflect.getMetadata(
-        tableColumn,
-        target,
-        propertyKey
-    ) as TableColumnMetadata;
+  return Reflect.getMetadata(
+    tableColumn,
+    target,
+    propertyKey,
+  ) as TableColumnMetadata;
 };
 
 type GetTableColumnsFunction = <T extends BaseModel>(
-    target: T
+  target: T,
 ) => Dictionary<TableColumnMetadata>;
 
 export const getTableColumns: GetTableColumnsFunction = <T extends BaseModel>(
-    target: T
+  target: T,
 ): Dictionary<TableColumnMetadata> => {
-    const dictonary: Dictionary<TableColumnMetadata> = {};
-    const keys: Array<string> = Object.keys(target);
+  const dictonary: Dictionary<TableColumnMetadata> = {};
+  const keys: Array<string> = Object.keys(target);
 
-    for (const key of keys) {
-        if (Reflect.getMetadata(tableColumn, target, key)) {
-            dictonary[key] = Reflect.getMetadata(
-                tableColumn,
-                target,
-                key
-            ) as TableColumnMetadata;
-        }
+  for (const key of keys) {
+    if (Reflect.getMetadata(tableColumn, target, key)) {
+      dictonary[key] = Reflect.getMetadata(
+        tableColumn,
+        target,
+        key,
+      ) as TableColumnMetadata;
     }
+  }
 
-    return dictonary;
+  return dictonary;
 };

package/Types/Database/TableColumnType.ts

@@ -1,43 +1,43 @@
 enum ColumnType {
-    Version = 'Version',
-    Phone = 'Phone',
-    HashedString = 'Hashed String',
-    Password = 'Password',
-    Email = 'Email',
-    Color = 'Color',
-    Slug = 'Slug',
-    Name = 'Name',
-    Description = 'Description',
-    ObjectID = 'Object ID',
-    File = 'File',
-    Buffer = 'Buffer',
-    ShortURL = 'Short URL',
-    Markdown = 'Markdown',
-    Domain = 'Domain',
-    LongURL = 'URL',
-    ShortText = 'Text',
-    OTP = 'One Time Password',
-    LongText = 'Long Text',
-    VeryLongText = 'Very Long Text',
-    HTML = 'HTML',
-    JavaScript = 'JavaSCript',
-    CSS = 'CSS',
-    Date = 'Date',
-    Boolean = 'Boolean',
-    Array = 'Array',
-    SmallPositiveNumber = 'Small Positive Number',
-    PositiveNumber = 'Positive Number',
-    BigPositiveNumber = 'Big Positive Number',
-    SmallNumber = 'Small Number',
-    Number = 'Number',
-    BigNumber = 'Big Number',
-    Entity = 'Entity',
-    EntityArray = 'Entity Array',
-    JSON = 'JSON',
-    Permission = 'Permission',
-    CustomFieldType = 'Custom Field Type',
-    MonitorType = 'Monitor Type',
-    WorkflowStatus = 'Workflow Status',
+  Version = "Version",
+  Phone = "Phone",
+  HashedString = "Hashed String",
+  Password = "Password",
+  Email = "Email",
+  Color = "Color",
+  Slug = "Slug",
+  Name = "Name",
+  Description = "Description",
+  ObjectID = "Object ID",
+  File = "File",
+  Buffer = "Buffer",
+  ShortURL = "Short URL",
+  Markdown = "Markdown",
+  Domain = "Domain",
+  LongURL = "URL",
+  ShortText = "Text",
+  OTP = "One Time Password",
+  LongText = "Long Text",
+  VeryLongText = "Very Long Text",
+  HTML = "HTML",
+  JavaScript = "JavaSCript",
+  CSS = "CSS",
+  Date = "Date",
+  Boolean = "Boolean",
+  Array = "Array",
+  SmallPositiveNumber = "Small Positive Number",
+  PositiveNumber = "Positive Number",
+  BigPositiveNumber = "Big Positive Number",
+  SmallNumber = "Small Number",
+  Number = "Number",
+  BigNumber = "Big Number",
+  Entity = "Entity",
+  EntityArray = "Entity Array",
+  JSON = "JSON",
+  Permission = "Permission",
+  CustomFieldType = "Custom Field Type",
+  MonitorType = "Monitor Type",
+  WorkflowStatus = "Workflow Status",
 }
 
 export default ColumnType;

package/Types/Database/TableMetadata.ts

@@ -1,18 +1,18 @@
-import GenericFunction from '../GenericFunction';
-import IconProp from '../Icon/IconProp';
+import GenericFunction from "../GenericFunction";
+import IconProp from "../Icon/IconProp";
 
 export default (props: {
-    tableName: string;
-    singularName: string;
-    pluralName: string;
-    icon: IconProp;
-    tableDescription: string;
+  tableName: string;
+  singularName: string;
+  pluralName: string;
+  icon: IconProp;
+  tableDescription: string;
 }) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.singularName = props.singularName;
-        ctr.prototype.tableName = props.tableName;
-        ctr.prototype.icon = props.icon;
-        ctr.prototype.tableDescription = props.tableDescription;
-        ctr.prototype.pluralName = props.pluralName;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.singularName = props.singularName;
+    ctr.prototype.tableName = props.tableName;
+    ctr.prototype.icon = props.icon;
+    ctr.prototype.tableDescription = props.tableDescription;
+    ctr.prototype.pluralName = props.pluralName;
+  };
 };

package/Types/Database/TenantColumn.ts

@@ -1,7 +1,7 @@
-import GenericFunction from '../GenericFunction';
+import GenericFunction from "../GenericFunction";
 
 export default (columnName: string) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.tenantColumn = columnName;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.tenantColumn = columnName;
+  };
 };

package/Types/Database/TotalItemsBy.ts

@@ -1,13 +1,13 @@
-import GenericFunction from '../GenericFunction';
+import GenericFunction from "../GenericFunction";
 
 export default (
-    columnName: string,
-    totalItems: number,
-    errorMessage: string
+  columnName: string,
+  totalItems: number,
+  errorMessage: string,
 ) => {
-    return (ctr: GenericFunction) => {
-        ctr.prototype.totalItemsByColumnName = columnName;
-        ctr.prototype.totalItemsNumber = totalItems;
-        ctr.prototype.totalItemsErrorMessage = errorMessage;
-    };
+  return (ctr: GenericFunction) => {
+    ctr.prototype.totalItemsByColumnName = columnName;
+    ctr.prototype.totalItemsNumber = totalItems;
+    ctr.prototype.totalItemsErrorMessage = errorMessage;
+  };
 };

package/Types/Database/UniqueColumnBy.ts

@@ -1,49 +1,49 @@
-import BaseModel from '../../Models/BaseModel';
-import Dictionary from '../Dictionary';
-import { ReflectionMetadataType } from '../Reflection';
-import 'reflect-metadata';
+import BaseModel from "../../Models/BaseModel";
+import Dictionary from "../Dictionary";
+import { ReflectionMetadataType } from "../Reflection";
+import "reflect-metadata";
 
-const uniqueColumnBy: Symbol = Symbol('UniqueColumnBy');
+const uniqueColumnBy: symbol = Symbol("UniqueColumnBy");
 
 export default (columnName: string | Array<string>): ReflectionMetadataType => {
-    return Reflect.metadata(uniqueColumnBy, columnName);
+  return Reflect.metadata(uniqueColumnBy, columnName);
 };
 
 type GetUniqueColumnByFunction = <T extends BaseModel>(
-    target: T,
-    propertyKey: string
+  target: T,
+  propertyKey: string,
 ) => string;
 
 export const getUniqueColumnBy: GetUniqueColumnByFunction = <
-    T extends BaseModel
+  T extends BaseModel,
 >(
-    target: T,
-    propertyKey: string
+  target: T,
+  propertyKey: string,
 ): string => {
-    return Reflect.getMetadata(uniqueColumnBy, target, propertyKey) as string;
+  return Reflect.getMetadata(uniqueColumnBy, target, propertyKey) as string;
 };
 
 type GetUniqueColumnsByFunction = <T extends BaseModel>(
-    target: T
+  target: T,
 ) => Dictionary<string>;
 
 export const getUniqueColumnsBy: GetUniqueColumnsByFunction = <
-    T extends BaseModel
+  T extends BaseModel,
 >(
-    target: T
+  target: T,
 ): Dictionary<string> => {
-    const dictonary: Dictionary<string> = {};
-    const keys: Array<string> = Object.keys(target);
-
-    for (const key of keys) {
-        if (Reflect.getMetadata(uniqueColumnBy, target, key)) {
-            dictonary[key] = Reflect.getMetadata(
-                uniqueColumnBy,
-                target,
-                key
-            ) as string;
-        }
+  const dictonary: Dictionary<string> = {};
+  const keys: Array<string> = Object.keys(target);
+
+  for (const key of keys) {
+    if (Reflect.getMetadata(uniqueColumnBy, target, key)) {
+      dictonary[key] = Reflect.getMetadata(
+        uniqueColumnBy,
+        target,
+        key,
+      ) as string;
     }
+  }
 
-    return dictonary;
+  return dictonary;
 };

package/Types/DatabaseType.ts

@@ -1,6 +1,6 @@
 enum DatabaseType {
-    Postgres = 'postgres',
-    Clickhouse = 'clickhouse',
+  Postgres = "postgres",
+  Clickhouse = "clickhouse",
 }
 
 export default DatabaseType;