apeframework 0.0.0-dev.2 → 0.0.0-dev.20

package/parser/factories/unit/createUnitParser.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUnitParser = void 0;
+const ParseError_1 = require("../../errors/ParseError");
+const parseNumber_1 = require("../../parseNumber");
+const parseString_1 = require("../../parseString");
+const createUnitParser = (params) => {
+    return (input) => {
+        let string;
+        try {
+            string = (0, parseString_1.parseString)(input);
+        }
+        catch (error) {
+            throw new ParseError_1.ParseError(params.type);
+        }
+        const units = [];
+        params.units.forEach((u) => {
+            units.push(u, { ...u, symbol: ` ${u.symbol}` });
+        });
+        units.sort((a, b) => {
+            return b.symbol.length - a.symbol.length;
+        });
+        const unit = units.find((u) => {
+            return string.toUpperCase().endsWith(u.symbol.toUpperCase());
+        });
+        let number;
+        try {
+            number = (0, parseNumber_1.parseNumber)(string.substring(0, string.length - (unit?.symbol.length ?? 0)));
+        }
+        catch (error) {
+            throw new ParseError_1.ParseError(params.type);
+        }
+        return number * (unit?.value ?? 1);
+    };
+};
+exports.createUnitParser = createUnitParser;

package/parser/factories/unit/createUnitParser.ts

@@ -0,0 +1,50 @@
+import { ParseError } from '../../errors/ParseError'
+import { parseNumber } from '../../parseNumber'
+import { parseString } from '../../parseString'
+import type { Unit } from './Unit'
+import type { Parser } from '../../Parser'
+
+const createUnitParser = (params: {
+  type: string,
+  units: Unit[],
+}): Parser<number> => {
+  return (input) => {
+    let string: string
+
+    try {
+      string = parseString(input)
+    } catch (error) {
+      throw new ParseError(params.type)
+    }
+
+    const units: Unit[] = []
+
+    params.units.forEach((u) => {
+      units.push(u, { ...u, symbol: ` ${u.symbol}` })
+    })
+
+    units.sort((a, b) => {
+      return b.symbol.length - a.symbol.length
+    })
+
+    const unit = units.find((u) => {
+      return string.toUpperCase().endsWith(u.symbol.toUpperCase())
+    })
+
+    let number: number
+
+    try {
+      number = parseNumber(
+        string.substring(0, string.length - (unit?.symbol.length ?? 0)),
+      )
+    } catch (error) {
+      throw new ParseError(params.type)
+    }
+
+    return number * (unit?.value ?? 1)
+  }
+}
+
+export {
+  createUnitParser,
+}

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,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBoolean = void 0;
+const ParseError_1 = require("./errors/ParseError");
+const parseBoolean = (input) => {
+    if ([
+        true,
+        1,
+        BigInt(1),
+        '1',
+        'TRUE',
+        'true',
+    ].includes(input)) {
+        return true;
+    }
+    else if ([
+        undefined,
+        null,
+        false,
+        0,
+        BigInt(0),
+        '',
+        '0',
+        'FALSE',
+        'false',
+    ].includes(input)) {
+        return false;
+    }
+    throw new ParseError_1.ParseError('boolean');
+};
+exports.parseBoolean = parseBoolean;

package/parser/parseBoolean.ts

@@ -0,0 +1,33 @@
+import { ParseError } from './errors/ParseError'
+import type { Parser } from './Parser'
+
+const parseBoolean: Parser<boolean> = (input) => {
+  if ([
+    true,
+    1,
+    BigInt(1),
+    '1',
+    'TRUE',
+    'true',
+  ].includes(input)) {
+    return true
+  } else if ([
+    undefined,
+    null,
+    false,
+    0,
+    BigInt(0),
+    '',
+    '0',
+    'FALSE',
+    'false',
+  ].includes(input)) {
+    return false
+  }
+
+  throw new ParseError('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 ParseError_1 = require("./errors/ParseError");
+const parseNumber_1 = require("./parseNumber");
+const parseInteger = (input) => {
+    let number;
+    try {
+        number = (0, parseNumber_1.parseNumber)(input);
+    }
+    catch (error) {
+        throw new ParseError_1.ParseError('integer');
+    }
+    if (!Number.isSafeInteger(number)) {
+        throw new ParseError_1.ParseError('integer');
+    }
+    return number;
+};
+exports.parseInteger = parseInteger;

package/parser/parseInteger.ts

@@ -0,0 +1,23 @@
+import { ParseError } from './errors/ParseError'
+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 ParseError('integer')
+  }
+
+  if (!Number.isSafeInteger(number)) {
+    throw new ParseError('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 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,14 @@
+"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 (['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,16 @@
+import { ParseError } from './errors/ParseError'
+import type { Parser } from './Parser'
+
+const parseString: Parser<string> = (input) => {
+  if ([undefined, null].includes(input)) {
+    return ''
+  } 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 bcryptjs_1 = __importDefault(require("bcryptjs"));
+const validateHashRounds_1 = require("./validateHashRounds");
+class Pwd {
+    hashRounds;
+    constructor(params) {
+        (0, validateHashRounds_1.validateHashRounds)(params.hashRounds);
+        this.hashRounds = params.hashRounds;
+    }
+    async hashPassword(password) {
+        return bcryptjs_1.default.hashSync(password, this.hashRounds);
+    }
+    async verifyPassword(password, hash) {
+        return bcryptjs_1.default.compareSync(password, hash);
+    }
+}
+exports.Pwd = Pwd;

package/pwd/Pwd.ts

@@ -0,0 +1,31 @@
+import bcrypt from 'bcryptjs'
+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.hashSync(password, this.hashRounds)
+  }
+
+  public async verifyPassword(
+    password: string,
+    hash: string,
+  ): Promise<boolean> {
+    return bcrypt.compareSync(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/server/ErrorHandler.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyError, FastifyReply, FastifyRequest } from 'fastify';
+type ErrorHandler = (error: FastifyError, request: FastifyRequest, response: FastifyReply) => Promise<void>;
+export { type ErrorHandler, };

package/server/ErrorHandler.ts

@@ -0,0 +1,11 @@
+import type { FastifyError, FastifyReply, FastifyRequest } from 'fastify'
+
+type ErrorHandler = (
+  error: FastifyError,
+  request: FastifyRequest,
+  response: FastifyReply,
+) => Promise<void>
+
+export {
+  type ErrorHandler,
+}

package/server/Format.d.ts

@@ -0,0 +1,9 @@
+import type { FormatDefinition } from 'ajv';
+type Format = NumberFormat | StringFormat;
+interface NumberFormat extends FormatDefinition<number> {
+    name: string;
+}
+interface StringFormat extends FormatDefinition<string> {
+    name: string;
+}
+export { type Format, };

package/server/Format.ts

@@ -0,0 +1,15 @@
+import type { FormatDefinition } from 'ajv'
+
+type Format = NumberFormat | StringFormat
+
+interface NumberFormat extends FormatDefinition<number> {
+  name: string,
+}
+
+interface StringFormat extends FormatDefinition<string> {
+  name: string,
+}
+
+export {
+  type Format,
+}

package/server/Handler.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyReply, FastifyRequest } from 'fastify';
+type Handler = (request: FastifyRequest, response: FastifyReply) => Promise<void>;
+export { type Handler, };

package/server/Handler.ts

@@ -0,0 +1,10 @@
+import type { FastifyReply, FastifyRequest } from 'fastify'
+
+type Handler = (
+  request: FastifyRequest,
+  response: FastifyReply,
+) => Promise<void>
+
+export {
+  type Handler,
+}

package/server/Method.d.ts

@@ -0,0 +1,8 @@
+declare enum Method {
+    DELETE = "DELETE",
+    GET = "GET",
+    PATCH = "PATCH",
+    POST = "POST",
+    PUT = "PUT"
+}
+export { Method, };