apeframework 0.0.0-dev.2 → 0.0.0-dev.3

package/parser/parseBoolean.d.ts

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

package/parser/parseBoolean.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = void 0;
+const ParserInputError_1 = require("./errors/ParserInputError");
+const parseBoolean = (input) => {
+    if ([true, 1, BigInt(1), '1'].includes(input)) {
+        return true;
+    }
+    else if ([undefined, null, false, 0, BigInt(0), '', '0'].includes(input)) {
+        return false;
+    }
+    throw new ParserInputError_1.ParserInputError('boolean');
+};
+exports.parseBoolean = parseBoolean;

package/parser/parseBoolean.ts

@@ -0,0 +1,16 @@
+import { ParserInputError } from './errors/ParserInputError'
+import type { Parser } from './Parser'
+
+const parseBoolean: Parser<boolean> = (input) => {
+  if ([true, 1, BigInt(1), '1'].includes(input)) {
+    return true
+  } else if ([undefined, null, false, 0, BigInt(0), '', '0'].includes(input)) {
+    return false
+  }
+
+  throw new ParserInputError('boolean')
+}
+
+export {
+  parseBoolean,
+}

package/parser/parseBytes.d.ts

@@ -0,0 +1,2 @@
+declare const parseBytes: import("./Parser").Parser<number>;
+export { parseBytes, };

package/parser/parseBytes.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBytes = void 0;
+const createUnitParser_1 = require("./factories/unit/createUnitParser");
+const parseBytes = (0, createUnitParser_1.createUnitParser)({
+    type: 'bytes',
+    units: [
+        {
+            symbol: 'B',
+            value: 1,
+        },
+        {
+            symbol: 'kB',
+            value: 1000,
+        },
+        {
+            symbol: 'MB',
+            value: 1000000,
+        },
+        {
+            symbol: 'GB',
+            value: 1000000000,
+        },
+        {
+            symbol: 'TB',
+            value: 1000000000000,
+        },
+        {
+            symbol: 'PB',
+            value: 1000000000000000,
+        },
+        {
+            symbol: 'KiB',
+            value: 1024,
+        },
+        {
+            symbol: 'MiB',
+            value: 131072,
+        },
+        {
+            symbol: 'GiB',
+            value: 134200000,
+        },
+        {
+            symbol: 'TiB',
+            value: 137400000000,
+        },
+        {
+            symbol: 'PiB',
+            value: 140700000000000,
+        },
+    ],
+});
+exports.parseBytes = parseBytes;

package/parser/parseBytes.ts

@@ -0,0 +1,55 @@
+import { createUnitParser } from './factories/unit/createUnitParser'
+
+const parseBytes = createUnitParser({
+  type: 'bytes',
+  units: [
+    {
+      symbol: 'B',
+      value: 1,
+    },
+    {
+      symbol: 'kB',
+      value: 1000,
+    },
+    {
+      symbol: 'MB',
+      value: 1000000,
+    },
+    {
+      symbol: 'GB',
+      value: 1000000000,
+    },
+    {
+      symbol: 'TB',
+      value: 1000000000000,
+    },
+    {
+      symbol: 'PB',
+      value: 1000000000000000,
+    },
+    {
+      symbol: 'KiB',
+      value: 1024,
+    },
+    {
+      symbol: 'MiB',
+      value: 131072,
+    },
+    {
+      symbol: 'GiB',
+      value: 134200000,
+    },
+    {
+      symbol: 'TiB',
+      value: 137400000000,
+    },
+    {
+      symbol: 'PiB',
+      value: 140700000000000,
+    },
+  ],
+})
+
+export {
+  parseBytes,
+}

package/parser/parseInteger.d.ts

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

package/parser/parseInteger.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInteger = void 0;
+const ParserInputError_1 = require("./errors/ParserInputError");
+const parseNumber_1 = require("./parseNumber");
+const parseInteger = (input) => {
+    let number;
+    try {
+        number = (0, parseNumber_1.parseNumber)(input);
+    }
+    catch (error) {
+        throw new ParserInputError_1.ParserInputError('integer');
+    }
+    if (!Number.isSafeInteger(number)) {
+        throw new ParserInputError_1.ParserInputError('integer');
+    }
+    return number;
+};
+exports.parseInteger = parseInteger;

package/parser/parseInteger.ts

@@ -0,0 +1,23 @@
+import { ParserInputError } from './errors/ParserInputError'
+import { parseNumber } from './parseNumber'
+import type { Parser } from './Parser'
+
+const parseInteger: Parser<number> = (input) => {
+  let number: number
+
+  try {
+    number = parseNumber(input)
+  } catch (error) {
+    throw new ParserInputError('integer')
+  }
+
+  if (!Number.isSafeInteger(number)) {
+    throw new ParserInputError('integer')
+  }
+
+  return number
+}
+
+export {
+  parseInteger,
+}

package/parser/parseMilliseconds.d.ts

@@ -0,0 +1,2 @@
+declare const parseMilliseconds: import("./Parser").Parser<number>;
+export { parseMilliseconds, };

package/parser/parseMilliseconds.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMilliseconds = void 0;
+const createUnitParser_1 = require("./factories/unit/createUnitParser");
+const parseMilliseconds = (0, createUnitParser_1.createUnitParser)({
+    type: 'milliseconds',
+    units: [
+        {
+            symbol: 'ms',
+            value: 1,
+        },
+        {
+            symbol: 's',
+            value: 1000,
+        },
+        {
+            symbol: 'm',
+            value: 60000,
+        },
+        {
+            symbol: 'h',
+            value: 3600000,
+        },
+        {
+            symbol: 'd',
+            value: 86400000,
+        },
+    ],
+});
+exports.parseMilliseconds = parseMilliseconds;

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 ParserInputError_1 = require("./errors/ParserInputError");
+const parseNumber = (input) => {
+    if ([undefined, null].includes(input)) {
+        return 0;
+    }
+    else if (['object', 'function', 'symbol'].includes(typeof input)) {
+        throw new ParserInputError_1.ParserInputError('number');
+    }
+    const number = Number(input);
+    if (!Number.isFinite(number)) {
+        throw new ParserInputError_1.ParserInputError('number');
+    }
+    return number;
+};
+exports.parseNumber = parseNumber;

package/parser/parseNumber.ts

@@ -0,0 +1,22 @@
+import { ParserInputError } from './errors/ParserInputError'
+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 ParserInputError('number')
+  }
+
+  const number = Number(input)
+
+  if (!Number.isFinite(number)) {
+    throw new ParserInputError('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 ParserInputError_1 = require("./errors/ParserInputError");
+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 ParserInputError_1.ParserInputError('string');
+    }
+    return String(input);
+};
+exports.parseString = parseString;

package/parser/parseString.ts

@@ -0,0 +1,20 @@
+import { ParserInputError } from './errors/ParserInputError'
+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 ParserInputError('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/PwdHashRoundsError.d.ts

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

package/pwd/errors/PwdHashRoundsError.js

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

package/pwd/errors/PwdHashRoundsError.ts

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

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 PwdHashRoundsError_1 = require("./errors/PwdHashRoundsError");
+const validateHashRounds = (hashRounds) => {
+    if (hashRounds < 1) {
+        throw new PwdHashRoundsError_1.PwdHashRoundsError(hashRounds);
+    }
+};
+exports.validateHashRounds = validateHashRounds;

package/pwd/validateHashRounds.ts

@@ -0,0 +1,11 @@
+import { PwdHashRoundsError } from './errors/PwdHashRoundsError'
+
+const validateHashRounds = (hashRounds: number): void => {
+  if (hashRounds < 1) {
+    throw new PwdHashRoundsError(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/TlsFileReadError.d.ts

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

package/tls/errors/TlsFileReadError.js

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

package/tls/errors/TlsFileReadError.ts

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

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 TlsFileReadError_1 = require("./errors/TlsFileReadError");
+const readFile = (path) => {
+    try {
+        if (fs_extra_1.default.existsSync(path)) {
+            return fs_extra_1.default.readFileSync(path).toString();
+        }
+    }
+    catch (error) {
+        throw new TlsFileReadError_1.TlsFileReadError(path, error.message);
+    }
+    throw new TlsFileReadError_1.TlsFileReadError(path, 'missing file');
+};
+exports.readFile = readFile;

package/tls/readFile.ts

@@ -0,0 +1,18 @@
+import fs from 'fs-extra'
+import { TlsFileReadError } from './errors/TlsFileReadError'
+
+const readFile = (path: string): string => {
+  try {
+    if (fs.existsSync(path)) {
+      return fs.readFileSync(path).toString()
+    }
+  } catch (error) {
+    throw new TlsFileReadError(path, (error as Error).message)
+  }
+
+  throw new TlsFileReadError(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, };