apeframework 0.0.0-dev.9 → 0.2.0

package/{mailer → dist/mailer}/adapters/noop/NoopMailer.d.ts

@@ -1,5 +1,5 @@
-import { Mailer } from '../../Mailer';
-import type { Mail } from '../../Mail';
+import { Mailer } from '../../Mailer.js';
+import type { Mail } from '../../Mail.js';
 declare class NoopMailer extends Mailer {
     sendMail(mail: Mail): Promise<string>;
     close(): Promise<void>;

package/dist/mailer/adapters/noop/NoopMailer.js

@@ -0,0 +1,9 @@
+import { randomUUID } from 'node:crypto';
+import { Mailer } from '../../Mailer.js';
+class NoopMailer extends Mailer {
+    async sendMail(mail) {
+        return `${randomUUID()}@${mail.from.email.split('@')[1]}`;
+    }
+    async close() { }
+}
+export { NoopMailer, };

package/{mailer → dist/mailer}/adapters/smtp/SmtpMailer.d.ts

@@ -1,6 +1,6 @@
-import { Mailer } from '../../Mailer';
-import type { Tls } from '../../../tls/Tls';
-import type { Mail } from '../../Mail';
+import { Mailer } from '../../Mailer.js';
+import type { Tls } from '../../../tls/Tls.js';
+import type { Mail } from '../../Mail.js';
 declare class SmtpMailer extends Mailer {
     private readonly transporter;
     constructor(params: {

package/dist/mailer/adapters/smtp/SmtpMailer.js

@@ -0,0 +1,54 @@
+import nodemailer from 'nodemailer';
+import { getTls } from '../../../tls/getTls.js';
+import { getIcalendar } from '../../getIcalendar.js';
+import { Mailer } from '../../Mailer.js';
+import { getAddress } from './getAddress.js';
+import { getAddresses } from './getAddresses.js';
+import { getAttachments } from './getAttachments.js';
+class SmtpMailer extends Mailer {
+    transporter;
+    constructor(params) {
+        super();
+        this.transporter = nodemailer.createTransport({
+            host: params.host,
+            port: params.port,
+            secure: params.secure ?? false,
+            tls: getTls(params.tls),
+            auth: params.user || params.password
+                ? {
+                    user: params.user,
+                    pass: params.password,
+                }
+                : undefined,
+            pool: true,
+            maxConnections: params.maxConnections ?? 5,
+        });
+    }
+    async sendMail(mail) {
+        const result = await this.transporter.sendMail({
+            from: getAddress(mail.from),
+            sender: getAddress(mail.sender),
+            replyTo: getAddress(mail.replyTo),
+            to: getAddresses(mail.to),
+            cc: getAddresses(mail.cc),
+            bcc: getAddresses(mail.bcc),
+            subject: mail.subject,
+            text: mail.text,
+            html: mail.html,
+            attachments: getAttachments(mail.attachments),
+            icalEvent: mail.event
+                ? {
+                    filename: mail.event.fileName ?? 'event.ics',
+                    method: mail.event.method,
+                    content: getIcalendar(mail.event),
+                }
+                : undefined,
+            list: { ...mail.list },
+        });
+        return result.messageId.slice(1, -1);
+    }
+    async close() {
+        this.transporter.close();
+    }
+}
+export { SmtpMailer, };

package/dist/mailer/adapters/smtp/getAddress.d.ts

@@ -0,0 +1,7 @@
+import type { Address } from '../../Address.js';
+interface NodemailerAddress {
+    address: string;
+    name: string;
+}
+declare const getAddress: (address?: Address) => NodemailerAddress | undefined;
+export { getAddress, };

package/{mailer → dist/mailer}/adapters/smtp/getAddress.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAddress = void 0;
 const getAddress = (address) => {
     return address
         ? {
@@ -9,4 +6,4 @@ const getAddress = (address) => {
         }
         : undefined;
 };
-exports.getAddress = getAddress;
+export { getAddress, };

package/dist/mailer/adapters/smtp/getAddresses.d.ts

@@ -0,0 +1,7 @@
+import type { Address } from '../../Address.js';
+interface NodemailerAddress {
+    address: string;
+    name: string;
+}
+declare const getAddresses: (addresses?: Address[]) => NodemailerAddress[];
+export { getAddresses, };

package/dist/mailer/adapters/smtp/getAddresses.js

@@ -0,0 +1,11 @@
+import { getAddress } from './getAddress.js';
+const getAddresses = (addresses) => {
+    return addresses
+        ? addresses
+            .map(getAddress)
+            .filter((address) => {
+            return address !== undefined;
+        })
+        : [];
+};
+export { getAddresses, };

package/dist/mailer/adapters/smtp/getAttachments.d.ts

@@ -0,0 +1,10 @@
+import type { Attachment } from '../../Attachment.js';
+import type { Readable } from 'node:stream';
+interface NodemailerAttachment {
+    filename: string;
+    cid: string;
+    contentType: string | undefined;
+    content: Buffer | Readable | string;
+}
+declare const getAttachments: (attachments?: Attachment[]) => NodemailerAttachment[];
+export { getAttachments, };

package/{mailer → dist/mailer}/adapters/smtp/getAttachments.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAttachments = void 0;
 const getAttachments = (attachments) => {
     return attachments
         ? attachments
@@ -14,4 +11,4 @@ const getAttachments = (attachments) => {
         })
         : [];
 };
-exports.getAttachments = getAttachments;
+export { getAttachments, };

package/{mailer → dist/mailer}/errors/AddressEmailError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class AddressEmailError extends BaseError {
     constructor(email: string);
 }

package/dist/mailer/errors/AddressEmailError.js

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

package/{mailer → dist/mailer}/errors/EventAttachmentUrlError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class EventAttachmentUrlError extends BaseError {
     constructor(url: string);
 }

package/dist/mailer/errors/EventAttachmentUrlError.js

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

package/{mailer → dist/mailer}/errors/EventGeolocationError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class EventGeolocationError extends BaseError {
     constructor(latitude: number, longitude: number);
 }

package/dist/mailer/errors/EventGeolocationError.js

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

package/{mailer → dist/mailer}/errors/EventUrlError.d.ts

@@ -1,4 +1,4 @@
-import { BaseError } from '../../error/BaseError';
+import { BaseError } from '../../error/BaseError.js';
 declare class EventUrlError extends BaseError {
     constructor(url: string);
 }

package/dist/mailer/errors/EventUrlError.js

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

package/{mailer → dist/mailer}/errors/ListUrlError.d.ts

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

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/{parser → dist/parser}/errors/ParseError.d.ts

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

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/{parser → dist/parser}/factories/unit/createUnitParser.js

@@ -1,17 +1,14 @@
-"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");
+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 = (0, parseString_1.parseString)(input);
+            string = parseString(input);
         }
         catch (error) {
-            throw new ParseError_1.ParseError(params.type);
+            throw new ParseError(params.type);
         }
         const units = [];
         params.units.forEach((u) => {
@@ -25,12 +22,12 @@ const createUnitParser = (params) => {
         });
         let number;
         try {
-            number = (0, parseNumber_1.parseNumber)(string.substring(0, string.length - (unit?.symbol.length ?? 0)));
+            number = parseNumber(string.substring(0, string.length - (unit?.symbol.length ?? 0)));
         }
         catch (error) {
-            throw new ParseError_1.ParseError(params.type);
+            throw new ParseError(params.type);
         }
         return number * (unit?.value ?? 1);
     };
 };
-exports.createUnitParser = createUnitParser;
+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, };