@oneuptime/common 1.0.0

package/Types/BaseDatabase/EqualToOrNull.ts

@@ -0,0 +1,37 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import SerializableObject from '../SerializableObject';
+
+export default class EqualToOrNull extends SerializableObject {
+    private _value!: string;
+    public get value(): string {
+        return this._value;
+    }
+    public set value(v: string) {
+        this._value = v;
+    }
+
+    public constructor(value: string) {
+        super();
+        this.value = value;
+    }
+
+    public override toString(): string {
+        return this.value;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.EqualToOrNull,
+            value: (this as EqualToOrNull).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): EqualToOrNull {
+        if (json['_type'] === ObjectType.EqualToOrNull) {
+            return new EqualToOrNull(json['value'] as string);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/GreaterThan.ts

@@ -0,0 +1,24 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import CompareBase from '../Database/CompareBase';
+
+export default class GreaterThan extends CompareBase {
+    public constructor(value: number | Date) {
+        super(value);
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.GreaterThan,
+            value: (this as GreaterThan).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): GreaterThan {
+        if (json['_type'] === ObjectType.GreaterThan) {
+            return new GreaterThan(json['value'] as number | Date);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/GreaterThanOrEqual.ts

@@ -0,0 +1,24 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import CompareBase from '../Database/CompareBase';
+
+export default class GreaterThanOrEqual extends CompareBase {
+    public constructor(value: number | Date) {
+        super(value);
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.GreaterThanOrEqual,
+            value: (this as GreaterThanOrEqual).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): GreaterThanOrEqual {
+        if (json['_type'] === ObjectType.GreaterThanOrEqual) {
+            return new GreaterThanOrEqual(json['value'] as number | Date);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/InBetween.ts

@@ -0,0 +1,77 @@
+import OneUptimeDate from '../Date';
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import SerializableObject from '../SerializableObject';
+
+export default class InBetween extends SerializableObject {
+    private _startValue!: number | Date | string;
+    public get startValue(): number | Date | string {
+        return this._startValue;
+    }
+    public set startValue(v: number | Date | string) {
+        this._startValue = v;
+    }
+
+    private _endValue!: number | Date | string;
+    public get endValue(): number | Date | string {
+        return this._endValue;
+    }
+    public set endValue(v: number | Date | string) {
+        this._endValue = v;
+    }
+
+    public constructor(
+        startValue: number | Date | string,
+        endValue: number | Date | string
+    ) {
+        super();
+        this.endValue = endValue;
+        this.startValue = startValue;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.InBetween,
+            startValue: (this as InBetween).startValue,
+            endValue: (this as InBetween).endValue,
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): InBetween {
+        if (json['_type'] === ObjectType.InBetween) {
+            return new InBetween(
+                json['startValue'] as number | Date | string,
+                json['endValue'] as number | Date | string
+            );
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    public override toString(): string {
+        let startValue: number | Date | string = this.startValue;
+        let endValue: number | Date | string = this.endValue;
+
+        if (startValue instanceof Date) {
+            startValue = OneUptimeDate.asDateForDatabaseQuery(startValue);
+        }
+
+        if (endValue instanceof Date) {
+            endValue = OneUptimeDate.asDateForDatabaseQuery(endValue);
+        }
+
+        if (startValue.toString() === endValue.toString()) {
+            return this.startValue.toString();
+        }
+
+        return this.startValue.toString() + ' - ' + this.endValue.toString();
+    }
+
+    public toStartValueString(): string {
+        return this.startValue.toString();
+    }
+
+    public toEndValueString(): string {
+        return this.endValue.toString();
+    }
+}

package/Types/BaseDatabase/Includes.ts

@@ -0,0 +1,47 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import JSONFunctions from '../JSONFunctions';
+import ObjectID from '../ObjectID';
+import SerializableObject from '../SerializableObject';
+
+export type IncludesType = Array<string> | Array<ObjectID>;
+
+export default class Includes extends SerializableObject {
+    private _values: IncludesType = [];
+
+    public get values(): IncludesType {
+        return this._values;
+    }
+
+    public set values(v: IncludesType) {
+        this._values = v;
+    }
+
+    public constructor(values: IncludesType) {
+        super();
+        this.values = values;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.Includes,
+            value: (this as Includes)._values,
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): Includes {
+        if (json['_type'] === ObjectType.Includes) {
+            const valuesArray: Array<string> = [];
+
+            for (const value of (json['value'] as Array<string>) || []) {
+                valuesArray.push(
+                    JSONFunctions.deserializeValue(value) as string
+                );
+            }
+
+            return new Includes(valuesArray);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/IsNull.ts

@@ -0,0 +1,28 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import SerializableObject from '../SerializableObject';
+
+export default class IsNull extends SerializableObject {
+    public constructor() {
+        super();
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.IsNull,
+            value: null,
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): IsNull {
+        if (json['_type'] === ObjectType.IsNull) {
+            return new IsNull();
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    public override toString(): string {
+        return '';
+    }
+}

package/Types/BaseDatabase/LessThan.ts

@@ -0,0 +1,24 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import CompareBase from '../Database/CompareBase';
+
+export default class LessThan extends CompareBase {
+    public constructor(value: number | Date) {
+        super(value);
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.LessThan,
+            value: (this as LessThan).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): LessThan {
+        if (json['_type'] === ObjectType.LessThan) {
+            return new LessThan(json['value'] as number | Date);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/LessThanOrEqual.ts

@@ -0,0 +1,24 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import CompareBase from '../Database/CompareBase';
+
+export default class LessThanOrEqual extends CompareBase {
+    public constructor(value: number | Date) {
+        super(value);
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.LessThanOrEqual,
+            value: (this as LessThanOrEqual).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): LessThanOrEqual {
+        if (json['_type'] === ObjectType.LessThanOrEqual) {
+            return new LessThanOrEqual(json['value'] as number | Date);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/ModelPermission.ts

@@ -0,0 +1,37 @@
+import Permission, {
+    PermissionHelper,
+    UserPermission,
+    UserTenantAccessPermission,
+    instanceOfUserTenantAccessPermission,
+} from '../Permission';
+
+export default class ModelPermission {
+    public static hasPermissions(
+        userProjectPermissions: UserTenantAccessPermission | Array<Permission>,
+        modelPermissions: Array<Permission>
+    ): boolean {
+        let userPermissions: Array<Permission> = [];
+
+        if (
+            instanceOfUserTenantAccessPermission(userProjectPermissions) &&
+            userProjectPermissions.permissions &&
+            Array.isArray(userProjectPermissions.permissions)
+        ) {
+            userPermissions = userProjectPermissions.permissions.map(
+                (item: UserPermission) => {
+                    return item.permission;
+                }
+            );
+        } else {
+            userPermissions = userProjectPermissions as Array<Permission>;
+        }
+
+        return Boolean(
+            userPermissions &&
+                PermissionHelper.doesPermissionsIntersect(
+                    modelPermissions,
+                    userPermissions
+                )
+        );
+    }
+}

package/Types/BaseDatabase/NotEqual.ts

@@ -0,0 +1,37 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import SerializableObject from '../SerializableObject';
+
+export default class NotEqual extends SerializableObject {
+    private _value!: string;
+    public get value(): string {
+        return this._value;
+    }
+    public set value(v: string) {
+        this._value = v;
+    }
+
+    public constructor(value: string) {
+        super();
+        this.value = value;
+    }
+
+    public override toString(): string {
+        return this.value;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.NotEqual,
+            value: (this as NotEqual).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): NotEqual {
+        if (json['_type'] === ObjectType.NotEqual) {
+            return new NotEqual(json['value'] as string);
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/NotNull.ts

@@ -0,0 +1,28 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import SerializableObject from '../SerializableObject';
+
+export default class NotNull extends SerializableObject {
+    public constructor() {
+        super();
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.NotNull,
+            value: null,
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): NotNull {
+        if (json['_type'] === ObjectType.NotNull) {
+            return new NotNull();
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+
+    public override toString(): string {
+        return '';
+    }
+}

package/Types/BaseDatabase/Search.ts

@@ -0,0 +1,39 @@
+import BadDataException from '../Exception/BadDataException';
+import { JSONObject, ObjectType } from '../JSON';
+import SerializableObject from '../SerializableObject';
+
+export default class Search extends SerializableObject {
+    private _searchValue!: string;
+
+    public get value(): string {
+        return this._searchValue;
+    }
+
+    public set value(v: string) {
+        this._searchValue = v;
+    }
+
+    public constructor(value: string) {
+        super();
+        this.value = value;
+    }
+
+    public override toString(): string {
+        return this.value;
+    }
+
+    public override toJSON(): JSONObject {
+        return {
+            _type: ObjectType.Search,
+            value: (this as Search).toString(),
+        };
+    }
+
+    public static override fromJSON(json: JSONObject): Search {
+        if (json['_type'] === ObjectType.Search) {
+            return new Search((json['value'] as string) || '');
+        }
+
+        throw new BadDataException('Invalid JSON: ' + JSON.stringify(json));
+    }
+}

package/Types/BaseDatabase/SortOrder.ts

@@ -0,0 +1,6 @@
+enum SortOrder {
+    Ascending = 'ASC',
+    Descending = 'DESC',
+}
+
+export default SortOrder;

package/Types/BaseDatabase/TableBillingAccessControl.ts

@@ -0,0 +1,8 @@
+import { PlanSelect } from '../Billing/SubscriptionPlan';
+
+export default interface TableBillingAccessControl {
+    create: PlanSelect;
+    read: PlanSelect;
+    update: PlanSelect;
+    delete: PlanSelect;
+}

package/Types/Billing/MeteredPlan.ts

@@ -0,0 +1,27 @@
+export default class MeteredPlan {
+    private priceId: string;
+    private unitName: string;
+    private pricePerUnitInUSD: number;
+
+    public constructor(data: {
+        priceId: string;
+        pricePerUnitInUSD: number;
+        unitName: string;
+    }) {
+        this.priceId = data.priceId;
+        this.pricePerUnitInUSD = data.pricePerUnitInUSD;
+        this.unitName = data.unitName;
+    }
+
+    public getPriceId(): string {
+        return this.priceId;
+    }
+
+    public getPricePerUnit(): number {
+        return this.pricePerUnitInUSD;
+    }
+
+    public getUnitName(): string {
+        return this.unitName;
+    }
+}