@oneuptime/common 1.0.0

package/Types/Database/DatabaseProperty.ts

@@ -0,0 +1,51 @@
+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';
+
+export default class DatabaseProperty extends SerializableObject {
+    public constructor() {
+        super();
+    }
+
+    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 _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);
+    }
+
+    public static getDatabaseTransformer(): ValueTransformer {
+        return {
+            to: (value: any) => {
+                return this._toDatabase(value);
+            },
+            from: (value: any) => {
+                return this._fromDatabase(value);
+            },
+        };
+    }
+}

package/Types/Database/Date.ts

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

package/Types/Database/EnableDocumentation.ts

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

package/Types/Database/EnableWorkflow.ts

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

package/Types/Database/IsPermissionsIf.ts

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

package/Types/Database/LabelsColumn.ts

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

package/Types/Database/LimitMax.ts

@@ -0,0 +1,4 @@
+const LIMIT_MAX: number = 10000;
+export const LIMIT_PER_PROJECT: number = 1000;
+export const DEFAULT_LIMIT: number = 10;
+export default LIMIT_MAX;

package/Types/Database/MultiTenentQueryAllowed.ts

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

package/Types/Database/PartialEntity.ts

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

package/Types/Database/SlugifyColumn.ts

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

package/Types/Database/TableColumn.ts

@@ -0,0 +1,66 @@
+import 'reflect-metadata';
+import BaseModel, { BaseModelType } from '../../Models/BaseModel';
+import Dictionary from '../Dictionary';
+import { ReflectionMetadataType } from '../Reflection';
+import TableColumnType from './TableColumnType';
+
+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.
+}
+
+export default (props: TableColumnMetadata): ReflectionMetadataType => {
+    return Reflect.metadata(tableColumn, props);
+};
+
+type GetTableColumnFunction = <T extends BaseModel>(
+    target: T,
+    propertyKey: string
+) => TableColumnMetadata;
+
+export const getTableColumn: GetTableColumnFunction = <T extends BaseModel>(
+    target: T,
+    propertyKey: string
+): TableColumnMetadata => {
+    return Reflect.getMetadata(
+        tableColumn,
+        target,
+        propertyKey
+    ) as TableColumnMetadata;
+};
+
+type GetTableColumnsFunction = <T extends BaseModel>(
+    target: T
+) => Dictionary<TableColumnMetadata>;
+
+export const getTableColumns: GetTableColumnsFunction = <T extends BaseModel>(
+    target: T
+): Dictionary<TableColumnMetadata> => {
+    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;
+        }
+    }
+
+    return dictonary;
+};

package/Types/Database/TableColumnType.ts

@@ -0,0 +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',
+}
+
+export default ColumnType;

package/Types/Database/TableMetadata.ts

@@ -0,0 +1,18 @@
+import IconProp from '../Icon/IconProp';
+import GenericFunction from '../GenericFunction';
+
+export default (props: {
+    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;
+    };
+};

package/Types/Database/TenantColumn.ts

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

package/Types/Database/TotalItemsBy.ts

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

package/Types/Database/UniqueColumnBy.ts

@@ -0,0 +1,49 @@
+import 'reflect-metadata';
+import BaseModel from '../../Models/BaseModel';
+import Dictionary from '../Dictionary';
+import { ReflectionMetadataType } from '../Reflection';
+
+const uniqueColumnBy: Symbol = Symbol('UniqueColumnBy');
+
+export default (columnName: string | Array<string>): ReflectionMetadataType => {
+    return Reflect.metadata(uniqueColumnBy, columnName);
+};
+
+type GetUniqueColumnByFunction = <T extends BaseModel>(
+    target: T,
+    propertyKey: string
+) => string;
+
+export const getUniqueColumnBy: GetUniqueColumnByFunction = <
+    T extends BaseModel
+>(
+    target: T,
+    propertyKey: string
+): string => {
+    return Reflect.getMetadata(uniqueColumnBy, target, propertyKey) as string;
+};
+
+type GetUniqueColumnsByFunction = <T extends BaseModel>(
+    target: T
+) => Dictionary<string>;
+
+export const getUniqueColumnsBy: GetUniqueColumnsByFunction = <
+    T extends BaseModel
+>(
+    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;
+        }
+    }
+
+    return dictonary;
+};

package/Types/DatabaseType.ts

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