apeframework 0.0.0-dev.2 → 0.0.0-dev.4

package/parser/parseMilliseconds.ts

@@ -0,0 +1,31 @@
+import { createUnitParser } from './factories/unit/createUnitParser'
+
+const parseMilliseconds = createUnitParser({
+  type: 'milliseconds',
+  units: [
+    {
+      symbol: 'ms',
+      value: 1,
+    },
+    {
+      symbol: 's',
+      value: 1000,
+    },
+    {
+      symbol: 'm',
+      value: 60000,
+    },
+    {
+      symbol: 'h',
+      value: 3600000,
+    },
+    {
+      symbol: 'd',
+      value: 86400000,
+    },
+  ],
+})
+
+export {
+  parseMilliseconds,
+}

package/parser/parseNumber.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from './Parser';
+declare const parseNumber: Parser<number>;
+export { parseNumber, };

package/parser/parseNumber.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumber = void 0;
+const ParseError_1 = require("./errors/ParseError");
+const parseNumber = (input) => {
+    if ([undefined, null].includes(input)) {
+        return 0;
+    }
+    else if (['object', 'function', 'symbol'].includes(typeof input)) {
+        throw new ParseError_1.ParseError('number');
+    }
+    const number = Number(input);
+    if (!Number.isFinite(number)) {
+        throw new ParseError_1.ParseError('number');
+    }
+    return number;
+};
+exports.parseNumber = parseNumber;

package/parser/parseNumber.ts

@@ -0,0 +1,22 @@
+import { ParseError } from './errors/ParseError'
+import type { Parser } from './Parser'
+
+const parseNumber: Parser<number> = (input) => {
+  if ([undefined, null].includes(input)) {
+    return 0
+  } else if (['object', 'function', 'symbol'].includes(typeof input)) {
+    throw new ParseError('number')
+  }
+
+  const number = Number(input)
+
+  if (!Number.isFinite(number)) {
+    throw new ParseError('number')
+  }
+
+  return number
+}
+
+export {
+  parseNumber,
+}

package/parser/parseString.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from './Parser';
+declare const parseString: Parser<string>;
+export { parseString, };

package/parser/parseString.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseString = void 0;
+const ParseError_1 = require("./errors/ParseError");
+const parseString = (input) => {
+    if ([undefined, null].includes(input)) {
+        return '';
+    }
+    else if (input === false) {
+        return '0';
+    }
+    else if (input === true) {
+        return '1';
+    }
+    else if (['object', 'function', 'symbol'].includes(typeof input)) {
+        throw new ParseError_1.ParseError('string');
+    }
+    return String(input);
+};
+exports.parseString = parseString;

package/parser/parseString.ts

@@ -0,0 +1,20 @@
+import { ParseError } from './errors/ParseError'
+import type { Parser } from './Parser'
+
+const parseString: Parser<string> = (input) => {
+  if ([undefined, null].includes(input)) {
+    return ''
+  } else if (input === false) {
+    return '0'
+  } else if (input === true) {
+    return '1'
+  } else if (['object', 'function', 'symbol'].includes(typeof input)) {
+    throw new ParseError('string')
+  }
+
+  return String(input)
+}
+
+export {
+  parseString,
+}

package/pwd/Pwd.d.ts

@@ -0,0 +1,9 @@
+declare class Pwd {
+    private readonly hashRounds;
+    constructor(params: {
+        hashRounds: number;
+    });
+    hashPassword(password: string): Promise<string>;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+}
+export { Pwd, };

package/pwd/Pwd.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pwd = void 0;
+const bcrypt_1 = __importDefault(require("bcrypt"));
+const validateHashRounds_1 = require("./validateHashRounds");
+class Pwd {
+    hashRounds;
+    constructor(params) {
+        (0, validateHashRounds_1.validateHashRounds)(params.hashRounds);
+        this.hashRounds = params.hashRounds;
+    }
+    async hashPassword(password) {
+        return bcrypt_1.default.hash(password, this.hashRounds);
+    }
+    async verifyPassword(password, hash) {
+        return bcrypt_1.default.compare(password, hash);
+    }
+}
+exports.Pwd = Pwd;

package/pwd/Pwd.ts

@@ -0,0 +1,31 @@
+import bcrypt from 'bcrypt'
+import { validateHashRounds } from './validateHashRounds'
+
+class Pwd {
+  private readonly hashRounds: number
+
+  public constructor(params: {
+    hashRounds: number,
+  }) {
+    validateHashRounds(params.hashRounds)
+
+    this.hashRounds = params.hashRounds
+  }
+
+  public async hashPassword(
+    password: string,
+  ): Promise<string> {
+    return bcrypt.hash(password, this.hashRounds)
+  }
+
+  public async verifyPassword(
+    password: string,
+    hash: string,
+  ): Promise<boolean> {
+    return bcrypt.compare(password, hash)
+  }
+}
+
+export {
+  Pwd,
+}

package/pwd/errors/HashRoundsError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class HashRoundsError extends BaseError {
+    constructor(hashRounds: number);
+}
+export { HashRoundsError, };

package/pwd/errors/HashRoundsError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashRoundsError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class HashRoundsError extends BaseError_1.BaseError {
+    constructor(hashRounds) {
+        super(`invalid hash rounds "${hashRounds}"`);
+    }
+}
+exports.HashRoundsError = HashRoundsError;

package/pwd/errors/HashRoundsError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class HashRoundsError extends BaseError {
+  public constructor(hashRounds: number) {
+    super(`invalid hash rounds "${hashRounds}"`)
+  }
+}
+
+export {
+  HashRoundsError,
+}

package/pwd/validateHashRounds.d.ts

@@ -0,0 +1,2 @@
+declare const validateHashRounds: (hashRounds: number) => void;
+export { validateHashRounds, };

package/pwd/validateHashRounds.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHashRounds = void 0;
+const HashRoundsError_1 = require("./errors/HashRoundsError");
+const validateHashRounds = (hashRounds) => {
+    if (hashRounds < 1) {
+        throw new HashRoundsError_1.HashRoundsError(hashRounds);
+    }
+};
+exports.validateHashRounds = validateHashRounds;

package/pwd/validateHashRounds.ts

@@ -0,0 +1,11 @@
+import { HashRoundsError } from './errors/HashRoundsError'
+
+const validateHashRounds = (hashRounds: number): void => {
+  if (hashRounds < 1) {
+    throw new HashRoundsError(hashRounds)
+  }
+}
+
+export {
+  validateHashRounds,
+}

package/tls/Tls.d.ts

@@ -0,0 +1,7 @@
+interface Tls {
+    key?: string;
+    cert?: string;
+    ca?: string;
+    verify?: boolean;
+}
+export { type Tls, };

package/tls/Tls.ts

@@ -0,0 +1,10 @@
+interface Tls {
+  key?: string,
+  cert?: string,
+  ca?: string,
+  verify?: boolean,
+}
+
+export {
+  type Tls,
+}

package/tls/errors/FileReadError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError';
+declare class FileReadError extends BaseError {
+    constructor(path: string, message: string);
+}
+export { FileReadError, };

package/tls/errors/FileReadError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReadError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class FileReadError extends BaseError_1.BaseError {
+    constructor(path, message) {
+        super(`failed reading file "${path}": ${message}`);
+    }
+}
+exports.FileReadError = FileReadError;

package/tls/errors/FileReadError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class FileReadError extends BaseError {
+  public constructor(path: string, message: string) {
+    super(`failed reading file "${path}": ${message}`)
+  }
+}
+
+export {
+  FileReadError,
+}

package/tls/getTls.d.ts

@@ -0,0 +1,8 @@
+import type { Tls } from './Tls';
+declare const getTls: (tls?: Tls) => {
+    key?: string;
+    cert?: string;
+    ca?: string;
+    rejectUnauthorized?: boolean;
+} | undefined;
+export { getTls, };

package/tls/getTls.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTls = void 0;
+const readFile_1 = require("./readFile");
+const getTls = (tls) => {
+    return tls
+        ? {
+            ...tls.key ? { key: (0, readFile_1.readFile)(tls.key) } : {},
+            ...tls.cert ? { cert: (0, readFile_1.readFile)(tls.cert) } : {},
+            ...tls.ca ? { ca: (0, readFile_1.readFile)(tls.ca) } : {},
+            ...tls.verify === undefined
+                ? {}
+                : { rejectUnauthorized: tls.verify },
+        }
+        : undefined;
+};
+exports.getTls = getTls;

package/tls/getTls.ts

@@ -0,0 +1,24 @@
+import { readFile } from './readFile'
+import type { Tls } from './Tls'
+
+const getTls = (tls?: Tls): {
+  key?: string,
+  cert?: string,
+  ca?: string,
+  rejectUnauthorized?: boolean,
+} | undefined => {
+  return tls
+    ? {
+      ...tls.key ? { key: readFile(tls.key) } : {},
+      ...tls.cert ? { cert: readFile(tls.cert) } : {},
+      ...tls.ca ? { ca: readFile(tls.ca) } : {},
+      ...tls.verify === undefined
+        ? {}
+        : { rejectUnauthorized: tls.verify },
+    }
+    : undefined
+}
+
+export {
+  getTls,
+}

package/tls/readFile.d.ts

@@ -0,0 +1,2 @@
+declare const readFile: (path: string) => string;
+export { readFile, };

package/tls/readFile.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const FileReadError_1 = require("./errors/FileReadError");
+const readFile = (path) => {
+    try {
+        if (fs_extra_1.default.existsSync(path)) {
+            return fs_extra_1.default.readFileSync(path).toString();
+        }
+    }
+    catch (error) {
+        throw new FileReadError_1.FileReadError(path, error.message);
+    }
+    throw new FileReadError_1.FileReadError(path, 'missing file');
+};
+exports.readFile = readFile;

package/tls/readFile.ts

@@ -0,0 +1,18 @@
+import fs from 'fs-extra'
+import { FileReadError } from './errors/FileReadError'
+
+const readFile = (path: string): string => {
+  try {
+    if (fs.existsSync(path)) {
+      return fs.readFileSync(path).toString()
+    }
+  } catch (error) {
+    throw new FileReadError(path, (error as Error).message)
+  }
+
+  throw new FileReadError(path, 'missing file')
+}
+
+export {
+  readFile,
+}

package/utils/getRandomHexString.d.ts

@@ -0,0 +1,2 @@
+declare const getRandomHexString: (length: number) => string;
+export { getRandomHexString, };

package/utils/getRandomHexString.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomHexString = void 0;
+const crypto_1 = require("crypto");
+const getRandomHexString = (length) => {
+    return (0, crypto_1.randomBytes)(length / 2 + 1).toString('hex').substring(0, length);
+};
+exports.getRandomHexString = getRandomHexString;

package/utils/getRandomHexString.ts

@@ -0,0 +1,9 @@
+import { randomBytes } from 'crypto'
+
+const getRandomHexString = (length: number): string => {
+  return randomBytes(length / 2 + 1).toString('hex').substring(0, length)
+}
+
+export {
+  getRandomHexString,
+}

package/utils/getTimestamp.d.ts

@@ -0,0 +1,2 @@
+declare const getTimestamp: () => number;
+export { getTimestamp, };

package/utils/getTimestamp.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimestamp = void 0;
+const getTimestamp = () => {
+    return Math.trunc(Date.now() / 1000);
+};
+exports.getTimestamp = getTimestamp;

package/utils/getTimestamp.ts

@@ -0,0 +1,7 @@
+const getTimestamp = (): number => {
+  return Math.trunc(Date.now() / 1000)
+}
+
+export {
+  getTimestamp,
+}

package/utils/isValidEmail.d.ts

@@ -0,0 +1,2 @@
+declare const isValidEmail: (email: string) => boolean;
+export { isValidEmail, };

package/utils/isValidEmail.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidEmail = void 0;
+const emailRegex = /^[^@\s]+@[^@\s]+\.[^@\s]+$/u;
+const isValidEmail = (email) => {
+    return emailRegex.test(email);
+};
+exports.isValidEmail = isValidEmail;

package/utils/isValidEmail.ts

@@ -0,0 +1,9 @@
+const emailRegex = /^[^@\s]+@[^@\s]+\.[^@\s]+$/u
+
+const isValidEmail = (email: string): boolean => {
+  return emailRegex.test(email)
+}
+
+export {
+  isValidEmail,
+}

package/utils/isValidGeolocation.d.ts

@@ -0,0 +1,2 @@
+declare const isValidGeolocation: (latitude: number, longitude: number) => boolean;
+export { isValidGeolocation, };

package/utils/isValidGeolocation.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidGeolocation = void 0;
+const isValidGeolocation = (latitude, longitude) => {
+    return latitude >= -90
+        && latitude <= 90
+        && longitude >= -180
+        && longitude <= 180;
+};
+exports.isValidGeolocation = isValidGeolocation;

package/utils/isValidGeolocation.ts

@@ -0,0 +1,10 @@
+const isValidGeolocation = (latitude: number, longitude: number): boolean => {
+  return latitude >= -90
+    && latitude <= 90
+    && longitude >= -180
+    && longitude <= 180
+}
+
+export {
+  isValidGeolocation,
+}

package/utils/isValidHexString.d.ts

@@ -0,0 +1,2 @@
+declare const isValidHexString: (string: string) => boolean;
+export { isValidHexString, };

package/utils/isValidHexString.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidHexString = void 0;
+const hexStringRegex = /^[0-9a-f]*$/u;
+const isValidHexString = (string) => {
+    return hexStringRegex.test(string);
+};
+exports.isValidHexString = isValidHexString;

package/utils/isValidHexString.ts

@@ -0,0 +1,9 @@
+const hexStringRegex = /^[0-9a-f]*$/u
+
+const isValidHexString = (string: string): boolean => {
+  return hexStringRegex.test(string)
+}
+
+export {
+  isValidHexString,
+}

package/utils/isValidJwtToken.d.ts

@@ -0,0 +1,2 @@
+declare const isValidJwtToken: (token: string) => boolean;
+export { isValidJwtToken, };

package/utils/isValidJwtToken.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidJwtToken = void 0;
+const jwtTokenRegex = /^[0-9A-Za-z-_]+\.[0-9A-Za-z-_]+\.[0-9A-Za-z-_]+$/u;
+const isValidJwtToken = (token) => {
+    return jwtTokenRegex.test(token);
+};
+exports.isValidJwtToken = isValidJwtToken;

package/utils/isValidJwtToken.ts

@@ -0,0 +1,9 @@
+const jwtTokenRegex = /^[0-9A-Za-z-_]+\.[0-9A-Za-z-_]+\.[0-9A-Za-z-_]+$/u
+
+const isValidJwtToken = (token: string): boolean => {
+  return jwtTokenRegex.test(token)
+}
+
+export {
+  isValidJwtToken,
+}

package/utils/isValidUrl.d.ts

@@ -0,0 +1,2 @@
+declare const isValidUrl: (url: string) => boolean;
+export { isValidUrl, };

package/utils/isValidUrl.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidUrl = void 0;
+const isValidUrl = (url) => {
+    try {
+        const parsed = new URL(url);
+        if (!['http:', 'https:'].includes(parsed.protocol)) {
+            return false;
+        }
+        if (!url.startsWith(`${parsed.protocol}//`)) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};
+exports.isValidUrl = isValidUrl;

package/utils/isValidUrl.ts

@@ -0,0 +1,21 @@
+const isValidUrl = (url: string): boolean => {
+  try {
+    const parsed = new URL(url)
+
+    if (!['http:', 'https:'].includes(parsed.protocol)) {
+      return false
+    }
+
+    if (!url.startsWith(`${parsed.protocol}//`)) {
+      return false
+    }
+
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+export {
+  isValidUrl,
+}

package/utils/isValidUuid.d.ts

@@ -0,0 +1,2 @@
+declare const isValidUuid: (uuid: string) => boolean;
+export { isValidUuid, };

package/utils/isValidUuid.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidUuid = void 0;
+const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+const isValidUuid = (uuid) => {
+    return uuidRegex.test(uuid);
+};
+exports.isValidUuid = isValidUuid;

package/utils/isValidUuid.ts

@@ -0,0 +1,10 @@
+const uuidRegex
+  = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u
+
+const isValidUuid = (uuid: string): boolean => {
+  return uuidRegex.test(uuid)
+}
+
+export {
+  isValidUuid,
+}

package/utils/wait.d.ts

@@ -0,0 +1,2 @@
+declare const wait: (milliseconds: number) => Promise<void>;
+export { wait, };

package/utils/wait.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wait = void 0;
+const wait = async (milliseconds) => {
+    return new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    });
+};
+exports.wait = wait;

package/utils/wait.ts

@@ -0,0 +1,9 @@
+const wait = async (milliseconds: number): Promise<void> => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds)
+  })
+}
+
+export {
+  wait,
+}