apeframework 0.0.0-dev.3 → 0.0.0-dev.31

package/dist/mailer/errors/ListUrlError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from '../../error/BaseError.js';
+declare class ListUrlError extends BaseError {
+    constructor(property: string, url: string);
+}
+export { ListUrlError, };

package/dist/mailer/errors/ListUrlError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class ListUrlError extends BaseError {
+    constructor(property, url) {
+        super(`invalid list ${property} url "${url}"`);
+    }
+}
+export { ListUrlError, };

package/{mailer → dist/mailer}/getIcalendar.d.ts

@@ -1,3 +1,3 @@
-import type { Event } from './Event';
+import type { Event } from './Event.js';
 declare const getIcalendar: (event: Event) => string;
 export { getIcalendar, };

package/{mailer → dist/mailer}/getIcalendar.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getIcalendar = void 0;
-const ical_generator_1 = require("ical-generator");
+import { ICalCalendar } from 'ical-generator';
 const getIcalendar = (event) => {
-    const calendar = new ical_generator_1.ICalCalendar({
+    const calendar = new ICalCalendar({
         method: event.method,
         events: [
             {
@@ -32,4 +29,4 @@ const getIcalendar = (event) => {
     });
     return calendar.toString();
 };
-exports.getIcalendar = getIcalendar;
+export { getIcalendar, };

package/dist/mailer/validateAddressEmail.js

@@ -0,0 +1,8 @@
+import { isValidEmail } from '../utils/isValidEmail.js';
+import { AddressEmailError } from './errors/AddressEmailError.js';
+const validateAddressEmail = (email) => {
+    if (!isValidEmail(email)) {
+        throw new AddressEmailError(email);
+    }
+};
+export { validateAddressEmail, };

package/dist/mailer/validateEventAttachmentUrl.js

@@ -0,0 +1,8 @@
+import { isValidUrl } from '../utils/isValidUrl.js';
+import { EventAttachmentUrlError } from './errors/EventAttachmentUrlError.js';
+const validateEventAttachmentUrl = (url) => {
+    if (!isValidUrl(url)) {
+        throw new EventAttachmentUrlError(url);
+    }
+};
+export { validateEventAttachmentUrl, };

package/dist/mailer/validateEventGeolocation.js

@@ -0,0 +1,8 @@
+import { isValidGeolocation } from '../utils/isValidGeolocation.js';
+import { EventGeolocationError } from './errors/EventGeolocationError.js';
+const validateEventGeolocation = (latitude, longitude) => {
+    if (!isValidGeolocation(latitude, longitude)) {
+        throw new EventGeolocationError(latitude, longitude);
+    }
+};
+export { validateEventGeolocation, };

package/dist/mailer/validateEventUrl.js

@@ -0,0 +1,8 @@
+import { isValidUrl } from '../utils/isValidUrl.js';
+import { EventUrlError } from './errors/EventUrlError.js';
+const validateEventUrl = (url) => {
+    if (!isValidUrl(url)) {
+        throw new EventUrlError(url);
+    }
+};
+export { validateEventUrl, };

package/dist/mailer/validateListUrl.js

@@ -0,0 +1,8 @@
+import { isValidUrl } from '../utils/isValidUrl.js';
+import { ListUrlError } from './errors/ListUrlError.js';
+const validateListUrl = (property, url) => {
+    if (!isValidUrl(url)) {
+        throw new ListUrlError(property, url);
+    }
+};
+export { validateListUrl, };

package/dist/parser/Parser.js

@@ -0,0 +1 @@
+export {};

package/dist/parser/errors/ParseError.d.ts

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

package/dist/parser/errors/ParseError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class ParseError extends BaseError {
+    constructor(type) {
+        super(`failed parsing ${type}`);
+    }
+}
+export { ParseError, };

package/dist/parser/factories/enum/createEnumParser.d.ts

@@ -0,0 +1,6 @@
+import type { Parser } from '../../Parser.js';
+declare const createEnumParser: <Enum extends Record<string, string | number>>(params: {
+    type: string;
+    enum: Enum;
+}) => Parser<Enum[keyof Enum]>;
+export { createEnumParser, };

package/dist/parser/factories/enum/createEnumParser.js

@@ -0,0 +1,10 @@
+import { ParseError } from '../../errors/ParseError.js';
+const createEnumParser = (params) => {
+    return (input) => {
+        if (!Object.values(params.enum).includes(input)) {
+            throw new ParseError(params.type);
+        }
+        return input;
+    };
+};
+export { createEnumParser, };

package/dist/parser/factories/unit/Unit.js

@@ -0,0 +1 @@
+export {};

package/{parser → dist/parser}/factories/unit/createUnitParser.d.ts

@@ -1,5 +1,5 @@
-import type { Unit } from './Unit';
-import type { Parser } from '../../Parser';
+import type { Unit } from './Unit.js';
+import type { Parser } from '../../Parser.js';
 declare const createUnitParser: (params: {
     type: string;
     units: Unit[];

package/dist/parser/factories/unit/createUnitParser.js

@@ -0,0 +1,33 @@
+import { ParseError } from '../../errors/ParseError.js';
+import { parseNumber } from '../../parseNumber.js';
+import { parseString } from '../../parseString.js';
+const createUnitParser = (params) => {
+    return (input) => {
+        let string;
+        try {
+            string = parseString(input);
+        }
+        catch (error) {
+            throw new 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 = 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 → dist/parser}/parseBoolean.d.ts

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

package/dist/parser/parseBoolean.js

@@ -0,0 +1,28 @@
+import { ParseError } from './errors/ParseError.js';
+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('boolean');
+};
+export { parseBoolean, };

package/dist/parser/parseBytes.d.ts

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

package/{parser → dist/parser}/parseBytes.js

@@ -1,8 +1,5 @@
-"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)({
+import { createUnitParser } from './factories/unit/createUnitParser.js';
+const parseBytes = createUnitParser({
     type: 'bytes',
     units: [
         {
@@ -51,4 +48,4 @@ const parseBytes = (0, createUnitParser_1.createUnitParser)({
         },
     ],
 });
-exports.parseBytes = parseBytes;
+export { parseBytes, };

package/{parser → dist/parser}/parseInteger.d.ts

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

package/dist/parser/parseInteger.js

@@ -0,0 +1,16 @@
+import { ParseError } from './errors/ParseError.js';
+import { parseNumber } from './parseNumber.js';
+const parseInteger = (input) => {
+    let number;
+    try {
+        number = parseNumber(input);
+    }
+    catch (error) {
+        throw new ParseError('integer');
+    }
+    if (!Number.isSafeInteger(number)) {
+        throw new ParseError('integer');
+    }
+    return number;
+};
+export { parseInteger, };

package/dist/parser/parseMilliseconds.d.ts

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

package/{parser → dist/parser}/parseMilliseconds.js

@@ -1,8 +1,5 @@
-"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)({
+import { createUnitParser } from './factories/unit/createUnitParser.js';
+const parseMilliseconds = createUnitParser({
     type: 'milliseconds',
     units: [
         {
@@ -27,4 +24,4 @@ const parseMilliseconds = (0, createUnitParser_1.createUnitParser)({
         },
     ],
 });
-exports.parseMilliseconds = parseMilliseconds;
+export { parseMilliseconds, };

package/{parser → dist/parser}/parseNumber.d.ts

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

package/dist/parser/parseNumber.js

@@ -0,0 +1,15 @@
+import { ParseError } from './errors/ParseError.js';
+const parseNumber = (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 → dist/parser}/parseString.d.ts

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

package/dist/parser/parseString.js

@@ -0,0 +1,11 @@
+import { ParseError } from './errors/ParseError.js';
+const parseString = (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/dist/pwd/Algorithm.d.ts

@@ -0,0 +1,6 @@
+declare enum Algorithm {
+    ARGON2D = 0,
+    ARGON2I = 1,
+    ARGON2ID = 2
+}
+export { Algorithm, };

package/dist/pwd/Algorithm.js

@@ -0,0 +1,7 @@
+var Algorithm;
+(function (Algorithm) {
+    Algorithm[Algorithm["ARGON2D"] = 0] = "ARGON2D";
+    Algorithm[Algorithm["ARGON2I"] = 1] = "ARGON2I";
+    Algorithm[Algorithm["ARGON2ID"] = 2] = "ARGON2ID";
+})(Algorithm || (Algorithm = {}));
+export { Algorithm, };

package/dist/pwd/Pwd.d.ts

@@ -0,0 +1,18 @@
+import type { Algorithm } from './Algorithm.js';
+declare class Pwd {
+    private readonly algorithm;
+    private readonly hashLength;
+    private readonly memoryCost;
+    private readonly timeCost;
+    private readonly parallelism;
+    constructor(params: {
+        algorithm: Algorithm;
+        hashLength?: number;
+        memoryCost?: number;
+        timeCost?: number;
+        parallelism?: number;
+    });
+    hashPassword(password: string): Promise<string>;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+}
+export { Pwd, };

package/dist/pwd/Pwd.js

@@ -0,0 +1,36 @@
+import argon2 from 'argon2';
+import { validateHashLength } from './validateHashLength.js';
+import { validateMemoryCost } from './validateMemoryCost.js';
+import { validateParallelism } from './validateParallelism.js';
+import { validateTimeCost } from './validateTimeCost.js';
+class Pwd {
+    algorithm;
+    hashLength;
+    memoryCost;
+    timeCost;
+    parallelism;
+    constructor(params) {
+        this.algorithm = params.algorithm;
+        validateHashLength(params.hashLength);
+        this.hashLength = params.hashLength;
+        validateMemoryCost(params.memoryCost);
+        this.memoryCost = params.memoryCost;
+        validateTimeCost(params.timeCost);
+        this.timeCost = params.timeCost;
+        validateParallelism(params.parallelism);
+        this.parallelism = params.parallelism;
+    }
+    async hashPassword(password) {
+        return argon2.hash(password, {
+            type: this.algorithm,
+            hashLength: this.hashLength,
+            memoryCost: this.memoryCost,
+            timeCost: this.timeCost,
+            parallelism: this.parallelism,
+        });
+    }
+    async verifyPassword(password, hash) {
+        return argon2.verify(hash, password);
+    }
+}
+export { Pwd, };

package/dist/pwd/errors/HashLengthError.d.ts

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

package/dist/pwd/errors/HashLengthError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class HashLengthError extends BaseError {
+    constructor(hashLength) {
+        super(`invalid hash length "${hashLength}"`);
+    }
+}
+export { HashLengthError, };

package/dist/pwd/errors/MemoryCostError.d.ts

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

package/dist/pwd/errors/MemoryCostError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class MemoryCostError extends BaseError {
+    constructor(memoryCost) {
+        super(`invalid memory cost "${memoryCost}"`);
+    }
+}
+export { MemoryCostError, };

package/dist/pwd/errors/ParallelismError.d.ts

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

package/dist/pwd/errors/ParallelismError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class ParallelismError extends BaseError {
+    constructor(parallelism) {
+        super(`invalid parallelism "${parallelism}"`);
+    }
+}
+export { ParallelismError, };

package/dist/pwd/errors/TimeCostError.d.ts

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

package/dist/pwd/errors/TimeCostError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError.js';
+class TimeCostError extends BaseError {
+    constructor(timeCost) {
+        super(`invalid time cost "${timeCost}"`);
+    }
+}
+export { TimeCostError, };

package/dist/pwd/validateHashLength.d.ts

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

package/dist/pwd/validateHashLength.js

@@ -0,0 +1,7 @@
+import { HashLengthError } from './errors/HashLengthError.js';
+const validateHashLength = (hashLength) => {
+    if (hashLength && hashLength < 4) {
+        throw new HashLengthError(hashLength);
+    }
+};
+export { validateHashLength, };

package/dist/pwd/validateMemoryCost.d.ts

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

package/dist/pwd/validateMemoryCost.js

@@ -0,0 +1,7 @@
+import { MemoryCostError } from './errors/MemoryCostError.js';
+const validateMemoryCost = (memoryCost) => {
+    if (memoryCost && memoryCost < 1024) {
+        throw new MemoryCostError(memoryCost);
+    }
+};
+export { validateMemoryCost, };

package/dist/pwd/validateParallelism.d.ts

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

package/dist/pwd/validateParallelism.js

@@ -0,0 +1,7 @@
+import { ParallelismError } from './errors/ParallelismError.js';
+const validateParallelism = (parallelism) => {
+    if (parallelism && parallelism < 1) {
+        throw new ParallelismError(parallelism);
+    }
+};
+export { validateParallelism, };

package/dist/pwd/validateTimeCost.d.ts

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

package/dist/pwd/validateTimeCost.js

@@ -0,0 +1,7 @@
+import { TimeCostError } from './errors/TimeCostError.js';
+const validateTimeCost = (timeCost) => {
+    if (timeCost && timeCost < 2) {
+        throw new TimeCostError(timeCost);
+    }
+};
+export { validateTimeCost, };

package/dist/server/ErrorHandler.d.ts

@@ -0,0 +1,5 @@
+import type { Request } from './Request.js';
+import type { Response } from './Response.js';
+import type { FastifyError } from 'fastify';
+type ErrorHandler = (error: FastifyError, request: Request, response: Response) => Promise<void>;
+export { type ErrorHandler, };

package/dist/server/ErrorHandler.js

@@ -0,0 +1 @@
+export {};

package/dist/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/dist/server/Format.js

@@ -0,0 +1 @@
+export {};

package/dist/server/Handler.d.ts

@@ -0,0 +1,4 @@
+import type { Request } from './Request.js';
+import type { Response } from './Response.js';
+type Handler = (request: Request, response: Response) => Promise<void>;
+export { type Handler, };

package/dist/server/Handler.js

@@ -0,0 +1 @@
+export {};

package/dist/server/Method.d.ts

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

package/dist/server/Method.js

@@ -0,0 +1,9 @@
+var Method;
+(function (Method) {
+    Method["DELETE"] = "DELETE";
+    Method["GET"] = "GET";
+    Method["PATCH"] = "PATCH";
+    Method["POST"] = "POST";
+    Method["PUT"] = "PUT";
+})(Method || (Method = {}));
+export { Method, };

package/dist/server/OpenApiFormat.d.ts

@@ -0,0 +1,5 @@
+declare enum OpenApiFormat {
+    JSON = "json",
+    YAML = "yaml"
+}
+export { OpenApiFormat, };

package/dist/server/OpenApiFormat.js

@@ -0,0 +1,6 @@
+var OpenApiFormat;
+(function (OpenApiFormat) {
+    OpenApiFormat["JSON"] = "json";
+    OpenApiFormat["YAML"] = "yaml";
+})(OpenApiFormat || (OpenApiFormat = {}));
+export { OpenApiFormat, };

package/dist/server/Request.d.ts

@@ -0,0 +1,5 @@
+import type { FastifyRequest } from 'fastify';
+interface Request extends FastifyRequest {
+    cookies: Record<string, string | undefined>;
+}
+export { type Request, };

package/dist/server/Request.js

@@ -0,0 +1 @@
+export {};

package/dist/server/Response.d.ts

@@ -0,0 +1,8 @@
+import type { CookieSerializeOptions } from '@fastify/cookie';
+import type { FastifyReply } from 'fastify';
+interface Response extends FastifyReply {
+    cookies: Record<string, string | undefined>;
+    setCookie: (name: string, value: string, options?: CookieSerializeOptions) => this;
+    clearCookie: (name: string, options?: CookieSerializeOptions) => this;
+}
+export { type Response, };

package/dist/server/Response.js

@@ -0,0 +1 @@
+export {};

package/dist/server/Route.d.ts

@@ -0,0 +1,12 @@
+import type { Handler } from './Handler.js';
+import type { Method } from './Method.js';
+import type { Schema } from './Schema.js';
+interface Route {
+    path: string;
+    method: Method;
+    name?: string;
+    description?: string;
+    schema: Schema;
+    handler: Handler;
+}
+export { type Route, };

package/dist/server/Route.js

@@ -0,0 +1 @@
+export {};

package/dist/server/Schema.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPIV3 } from 'openapi-types';
+interface Schema {
+    params?: OpenAPIV3.SchemaObject;
+    query?: OpenAPIV3.SchemaObject;
+    headers?: OpenAPIV3.SchemaObject;
+    body?: OpenAPIV3.SchemaObject;
+    response?: Record<number, OpenAPIV3.SchemaObject>;
+}
+export { type Schema, };

package/dist/server/Schema.js

@@ -0,0 +1 @@
+export {};