zavadil-ts-common 2.2.6 → 2.2.8

package/src/oauth/OAuthUtil.ts

@@ -1,107 +1,104 @@
-import { StringUtil, ObjectUtil } from "../util";
+import {StringUtil, ObjectUtil} from "../util";
 import {PERMISSION_LEVELS, PermissionLevel, TokenResponsePayloadBase} from "./Types";
 
 export class OAuthUtil {
-  static isValidToken(token?: TokenResponsePayloadBase | null): boolean {
-    return (
-      ObjectUtil.notEmpty(token) &&
-      StringUtil.notBlank(token.token) &&
-      !OAuthUtil.isTokenExpired(token)
-    );
-  }
 
-  static isTokenExpired(token?: TokenResponsePayloadBase | null): boolean {
-    if (token === undefined || token === null) return false;
-    if (token.expires === undefined || token.expires === null) return false;
-    return token.expires < new Date();
-  }
+	static isValidToken(token?: TokenResponsePayloadBase | null): boolean {
+		return ObjectUtil.isObject(token) && StringUtil.notBlank(token.token) && !OAuthUtil.isTokenExpired(token);
+	}
 
-  static isTokenReadyForRefresh(
-    token?: TokenResponsePayloadBase | null,
-  ): boolean {
-    if (token === undefined || token === null) return false;
-    if (OAuthUtil.isTokenExpired(token)) return false;
-    if (token.expires === undefined || token.expires === null) return false;
-    const middle = new Date(
-      (token.expires.getTime() + token.issuedAt.getTime()) / 2,
-    );
-    const now = new Date();
-    return middle < now;
-  }
+	static isTokenExpired(token?: TokenResponsePayloadBase | null): boolean {
+		if (token === undefined || token === null) return false;
+		if (token.expires === undefined || token.expires === null) return false;
+		return token.expires < new Date();
+	}
 
-  public static getScopeString(privilege: string, level: PermissionLevel) {
-    return `${level}:${privilege}`;
-  }
+	static isTokenReadyForRefresh(
+		token?: TokenResponsePayloadBase | null,
+	): boolean {
+		if (token === undefined || token === null) return false;
+		if (OAuthUtil.isTokenExpired(token)) return false;
+		if (token.expires === undefined || token.expires === null) return false;
+		const middle = new Date(
+			(token.expires.getTime() + token.issuedAt.getTime()) / 2,
+		);
+		const now = new Date();
+		return middle < now;
+	}
 
-  public static extractPrivilege(scope: string): string {
-    const arr = scope.split(":");
-    if (arr.length < 2) return "";
-    return arr[1];
-  }
+	public static getScopeString(privilege: string, level: PermissionLevel) {
+		return `${level}:${privilege}`;
+	}
 
-  public static isPermissionLevel(value: string): value is PermissionLevel {
-    return (PERMISSION_LEVELS as readonly string[]).includes(value);
-  }
+	public static extractPrivilege(scope: string): string {
+		const arr = scope.split(":");
+		if (arr.length < 2) return "";
+		return arr[1];
+	}
 
-  public static extractPermissionLevel(scope: string): PermissionLevel {
-    const arr = scope.split(":");
-    if (arr.length === 0) throw new Error(`Scope value ${scope} is invalid!`);
-    const str = arr[0];
-    if (!OAuthUtil.isPermissionLevel(str))
-      throw new Error(`"${str} is not valid permission level!`);
-    return str;
-  }
+	public static isPermissionLevel(value: string): value is PermissionLevel {
+		return (PERMISSION_LEVELS as readonly string[]).includes(value);
+	}
 
-  public static getLevel(level: PermissionLevel): number {
-    switch (level) {
-      case "admin":
-        return 3;
-      case "write":
-        return 2;
-      case "read":
-        return 1;
-      default:
-        return 0;
-    }
-  }
+	public static extractPermissionLevel(scope: string): PermissionLevel {
+		const arr = scope.split(":");
+		if (arr.length === 0) throw new Error(`Scope value ${scope} is invalid!`);
+		const str = arr[0];
+		if (!OAuthUtil.isPermissionLevel(str))
+			throw new Error(`"${str} is not valid permission level!`);
+		return str;
+	}
 
-  /**
-   * Returns true if given scope grants permission for specific privilege on at least required level.
-   *
-   * @param ownedScope        Existing scope, usually owned by user in form of access token
-   * @param requiredScopeOrPrivilege Required privilege name or whole scope (omit minLevel)
-   * @param minLevel          Required minimal permission level
-   */
-  public static hasPermission(
-    ownedScope: string,
-    requiredScopeOrPrivilege: string,
-    minLevel?: PermissionLevel,
-  ): boolean {
-    if (minLevel === undefined) {
-      try {
-        minLevel = OAuthUtil.extractPermissionLevel(requiredScopeOrPrivilege);
-        requiredScopeOrPrivilege = OAuthUtil.extractPrivilege(
-          requiredScopeOrPrivilege,
-        );
-      } catch (e) {
-        minLevel = "admin";
-      }
-    }
+	public static getLevel(level: PermissionLevel): number {
+		switch (level) {
+			case "admin":
+				return 3;
+			case "write":
+				return 2;
+			case "read":
+				return 1;
+			default:
+				return 0;
+		}
+	}
 
-    const ownedLevel = OAuthUtil.extractPermissionLevel(ownedScope);
-    // owned level must be at least equal to the required
-    if (OAuthUtil.getLevel(ownedLevel) < OAuthUtil.getLevel(minLevel))
-      return false;
+	/**
+	 * Returns true if given scope grants permission for specific privilege on at least required level.
+	 *
+	 * @param ownedScope        Existing scope, usually owned by user in form of access token
+	 * @param requiredScopeOrPrivilege Required privilege name or whole scope (omit minLevel)
+	 * @param minLevel          Required minimal permission level
+	 */
+	public static hasPermission(
+		ownedScope: string,
+		requiredScopeOrPrivilege: string,
+		minLevel?: PermissionLevel,
+	): boolean {
+		if (minLevel === undefined) {
+			try {
+				minLevel = OAuthUtil.extractPermissionLevel(requiredScopeOrPrivilege);
+				requiredScopeOrPrivilege = OAuthUtil.extractPrivilege(
+					requiredScopeOrPrivilege,
+				);
+			} catch (e) {
+				minLevel = "admin";
+			}
+		}
 
-    const ownedPrivilege = OAuthUtil.extractPrivilege(ownedScope);
-    // super admin, has privilege for all resources
-    if (ownedPrivilege === "*") return true;
-    // user has exactly the required privilege
-    if (ownedPrivilege === requiredScopeOrPrivilege) return true;
-    // now the only possibility is that user has privilege ending with * covering the required privilege
-    if (!ownedPrivilege?.endsWith("/*")) return false;
+		const ownedLevel = OAuthUtil.extractPermissionLevel(ownedScope);
+		// owned level must be at least equal to the required
+		if (OAuthUtil.getLevel(ownedLevel) < OAuthUtil.getLevel(minLevel))
+			return false;
 
-    const ownedParent = ownedPrivilege.replace("/*", "");
-    return requiredScopeOrPrivilege?.startsWith(ownedParent) ?? false;
-  }
+		const ownedPrivilege = OAuthUtil.extractPrivilege(ownedScope);
+		// super admin, has privilege for all resources
+		if (ownedPrivilege === "*") return true;
+		// user has exactly the required privilege
+		if (ownedPrivilege === requiredScopeOrPrivilege) return true;
+		// now the only possibility is that user has privilege ending with * covering the required privilege
+		if (!ownedPrivilege?.endsWith("/*")) return false;
+
+		const ownedParent = ownedPrivilege.replace("/*", "");
+		return requiredScopeOrPrivilege?.startsWith(ownedParent) ?? false;
+	}
 }

package/src/util/ArrayUtil.ts

@@ -2,6 +2,10 @@ import { ObjectUtil } from "./ObjectUtil";
 
 export class ArrayUtil {
 
+	static isArray(arr: any): arr is Array<any> {
+		return Array.isArray(arr);
+	}
+
 	static isEmpty(arr?: Array<any> | null): arr is null | undefined {
 		return ObjectUtil.isEmpty(arr) || arr.length === 0;
 	}

package/src/util/JsonUtil.ts

@@ -17,4 +17,9 @@ export class JsonUtil {
 	static parse(json?: string | null): any {
 		return JsonUtil.parseWithDates(json);
 	}
+
+	static serialize(o: any): string {
+		return JSON.stringify(o);
+	}
+
 }

package/src/util/NumberUtil.ts

@@ -4,6 +4,11 @@ export class NumberUtil {
 		return n === undefined || n === null || Number.isNaN(n);
 	}
 
+	static isNumber(n: any): n is number {
+		if (NumberUtil.isEmpty(n)) return false;
+		return typeof n === "number";
+	}
+
 	static notEmpty(n?: number | null): n is number {
 		return !NumberUtil.isEmpty(n);
 	}

package/src/util/ObjectUtil.ts

@@ -4,8 +4,13 @@ export class ObjectUtil {
 		return obj === undefined || obj === null;
 	}
 
-	static notEmpty(obj: any): obj is object {
-		return !ObjectUtil.isEmpty(obj);
+	static isObject(o: any): o is Record<string, unknown> {
+		if (ObjectUtil.isEmpty(o)) return false;
+		return typeof o === "object";
+	}
+
+	static notEmpty(obj: any): obj is Record<string, unknown> {
+		return !ObjectUtil.isObject(obj);
 	}
 
 	static clone<T>(obj: T): T {

package/src/util/StringUtil.ts

@@ -1,15 +1,25 @@
 import {HashUtil} from "./HashUtil";
 import {ObjectUtil} from "./ObjectUtil";
+import {NumberUtil} from "./NumberUtil";
+import {ArrayUtil} from "./ArrayUtil";
+import {JsonUtil} from "./JsonUtil";
 
 export class StringUtil {
+
 	static isString(str: any): str is string {
+		if (ObjectUtil.isEmpty(str)) return false;
 		return typeof str === "string";
 	}
 
 	static toString(s: any): string {
 		if (StringUtil.isString(s)) return s;
-		if (StringUtil.isString(s.message)) return s.message; // Errors
-		return s?.toString?.() ?? "";
+		if (NumberUtil.isNumber(s)) return s.toString();
+		if (ArrayUtil.isArray(s)) return `[${s.map(i => StringUtil.toString(i)).join(',')}]`;
+		if (ObjectUtil.isObject(s)) {
+			if (StringUtil.isString(s.message)) return s.message; // Errors
+			return JsonUtil.serialize(s);
+		}
+		return StringUtil.getNonEmpty(s);
 	}
 
 	static isEmpty(str: string | null | undefined): str is null | undefined {

package/tests/index.test.ts

@@ -1,4 +1,23 @@
-import {StringUtil, JsonUtil, RestClient, UrlUtil, EmailUtil} from '../src';
+import {StringUtil, JsonUtil, RestClient, UrlUtil, EmailUtil, ObjectUtil, ArrayUtil} from '../src';
+
+describe('testing ObjectUtil', () => {
+	test('isEmpty', () => {
+		expect(ObjectUtil.isEmpty(undefined)).toBe(true);
+		expect(ObjectUtil.isEmpty(null)).toBe(true);
+		expect(ObjectUtil.isEmpty([])).toBe(false);
+		expect(ObjectUtil.isEmpty({})).toBe(false);
+		expect(ObjectUtil.isEmpty('')).toBe(false);
+		expect(ObjectUtil.isEmpty('test')).toBe(false);
+	});
+	test('isObject', () => {
+		expect(ObjectUtil.isObject(undefined)).toBe(false);
+		expect(ObjectUtil.isObject(null)).toBe(false);
+		expect(ObjectUtil.isObject([])).toBe(true);
+		expect(ObjectUtil.isObject({})).toBe(true);
+		expect(ObjectUtil.isObject('')).toBe(false);
+		expect(ObjectUtil.isObject('test')).toBe(false);
+	});
+});
 
 describe('testing StringUtil', () => {
 	test('isEmpty', () => {
@@ -15,6 +34,24 @@ describe('testing StringUtil', () => {
 		expect(StringUtil.isBlank(null)).toBe(true);
 		expect(StringUtil.isBlank(undefined)).toBe(true);
 	});
+	test('isString', () => {
+		expect(StringUtil.isString('test')).toBe(true);
+		expect(StringUtil.isString('  ')).toBe(true);
+		expect(StringUtil.isString('')).toBe(true);
+		expect(StringUtil.isString(null)).toBe(false);
+		expect(StringUtil.isString(undefined)).toBe(false);
+		expect(StringUtil.isString({})).toBe(false);
+		expect(StringUtil.isString([])).toBe(false);
+	});
+	test('toString', () => {
+		expect(StringUtil.toString('test')).toBe('test');
+		expect(StringUtil.toString('  ')).toBe('  ');
+		expect(StringUtil.toString('')).toBe('');
+		expect(StringUtil.toString(null)).toBe('');
+		expect(StringUtil.toString(undefined)).toBe('');
+		expect(StringUtil.toString({})).toBe('{}');
+		expect(StringUtil.toString([1, 2, 3])).toBe('[1,2,3]');
+	});
 	test('getNonEmpty', () => {
 		expect(StringUtil.getNonEmpty('test')).toBe('test');
 		expect(StringUtil.getNonEmpty('', 'test')).toBe('test');
@@ -30,6 +67,24 @@ describe('testing StringUtil', () => {
 	});
 });
 
+describe('testing ArrayUtil', () => {
+	test('isEmpty', () => {
+		expect(ArrayUtil.isEmpty(undefined)).toBe(true);
+		expect(ArrayUtil.isEmpty(null)).toBe(true);
+		expect(ArrayUtil.isEmpty([])).toBe(true);
+		expect(ArrayUtil.isEmpty([1,2,3])).toBe(false);
+	});
+	test('isArray', () => {
+		expect(ArrayUtil.isArray(undefined)).toBe(false);
+		expect(ArrayUtil.isArray(null)).toBe(false);
+		expect(ArrayUtil.isArray([])).toBe(true);
+		expect(ArrayUtil.isArray([1,2,3])).toBe(true);
+		expect(ArrayUtil.isArray({})).toBe(false);
+		expect(ArrayUtil.isArray('')).toBe(false);
+		expect(ArrayUtil.isArray('test')).toBe(false);
+	});
+});
+
 describe('testing JsonUtil', () => {
 	test('parseWithDates', () => {
 		const myObj = {
@@ -37,7 +92,7 @@ describe('testing JsonUtil', () => {
 			sval: "str",
 			nval: 13
 		}
-		const myStr = JSON.stringify(myObj);
+		const myStr = JsonUtil.serialize(myObj);
 		const parsed = JsonUtil.parseWithDates(myStr);
 
 		expect(typeof parsed.dval).toBe('object');