apeframework 0.0.0-dev.2 → 0.0.0-dev.21

package/jwt/Jwt.d.ts

@@ -0,0 +1,13 @@
+import type { Algorithm } from './Algorithm';
+import type { Payload } from './Payload';
+declare class Jwt {
+    private readonly algorithm;
+    private readonly secret;
+    constructor(params: {
+        algorithm: Algorithm;
+        secret: string;
+    });
+    createToken(payload: Payload): Promise<string>;
+    verifyToken<Type extends Payload>(token: string, timestamp: number): Promise<Type | undefined>;
+}
+export { Jwt, };

package/jwt/Jwt.js

@@ -0,0 +1,32 @@
+import { SignJWT, jwtVerify } from 'jose';
+import { validateSecretLength } from './validateSecretLength';
+class Jwt {
+    algorithm;
+    secret;
+    constructor(params) {
+        validateSecretLength(params.algorithm, params.secret);
+        this.algorithm = params.algorithm;
+        this.secret = new TextEncoder().encode(params.secret);
+    }
+    async createToken(payload) {
+        return new SignJWT(payload)
+            .setProtectedHeader({
+            typ: 'JWT',
+            alg: this.algorithm,
+        })
+            .sign(this.secret);
+    }
+    async verifyToken(token, timestamp) {
+        try {
+            const { payload } = await jwtVerify(token, this.secret, {
+                typ: 'JWT',
+                currentDate: new Date(timestamp * 1000),
+            });
+            return payload;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+}
+export { Jwt, };

package/jwt/Payload.d.ts

@@ -0,0 +1,11 @@
+interface Payload {
+    [key: string]: unknown;
+    iss?: string;
+    aud?: string[];
+    sub?: string;
+    jti?: string;
+    iat?: number;
+    exp?: number;
+    nbf?: number;
+}
+export { type Payload, };

package/jwt/Payload.js

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

package/jwt/errors/SecretLengthError.d.ts

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

package/jwt/errors/SecretLengthError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../error/BaseError';
+class SecretLengthError extends BaseError {
+    constructor() {
+        super('invalid secret length');
+    }
+}
+export { SecretLengthError, };

package/jwt/validateSecretLength.d.ts

@@ -0,0 +1,3 @@
+import { Algorithm } from './Algorithm';
+declare const validateSecretLength: (algorithm: Algorithm, secret: string) => void;
+export { validateSecretLength, };

package/jwt/validateSecretLength.js

@@ -0,0 +1,13 @@
+import { Algorithm } from './Algorithm';
+import { SecretLengthError } from './errors/SecretLengthError';
+const minSecretLength = {
+    [Algorithm.HS256]: 32,
+    [Algorithm.HS384]: 48,
+    [Algorithm.HS512]: 64,
+};
+const validateSecretLength = (algorithm, secret) => {
+    if (Buffer.from(secret).length < minSecretLength[algorithm]) {
+        throw new SecretLengthError();
+    }
+};
+export { validateSecretLength, };

package/logger/Level.d.ts

@@ -0,0 +1,10 @@
+declare enum Level {
+    TRACE = "trace",
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    FATAL = "fatal",
+    OFF = "off"
+}
+export { Level, };

package/logger/Level.js

@@ -0,0 +1,11 @@
+var Level;
+(function (Level) {
+    Level["TRACE"] = "trace";
+    Level["DEBUG"] = "debug";
+    Level["INFO"] = "info";
+    Level["WARN"] = "warn";
+    Level["ERROR"] = "error";
+    Level["FATAL"] = "fatal";
+    Level["OFF"] = "off";
+})(Level || (Level = {}));
+export { Level, };

package/logger/Logger.d.ts

@@ -0,0 +1,10 @@
+declare abstract class Logger {
+    abstract trace(message: string, data?: unknown): void;
+    abstract debug(message: string, data?: unknown): void;
+    abstract info(message: string, data?: unknown): void;
+    abstract warn(message: string, data?: unknown): void;
+    abstract error(message: string, data?: unknown): void;
+    abstract fatal(message: string, data?: unknown): void;
+    abstract close(): Promise<void>;
+}
+export { Logger, };

package/logger/Logger.js

@@ -0,0 +1,3 @@
+class Logger {
+}
+export { Logger, };

package/logger/Severity.d.ts

@@ -0,0 +1,9 @@
+declare enum Severity {
+    TRACE = 10,
+    DEBUG = 20,
+    INFO = 30,
+    WARN = 40,
+    ERROR = 50,
+    FATAL = 60
+}
+export { Severity, };

package/logger/Severity.js

@@ -0,0 +1,10 @@
+var Severity;
+(function (Severity) {
+    Severity[Severity["TRACE"] = 10] = "TRACE";
+    Severity[Severity["DEBUG"] = 20] = "DEBUG";
+    Severity[Severity["INFO"] = 30] = "INFO";
+    Severity[Severity["WARN"] = 40] = "WARN";
+    Severity[Severity["ERROR"] = 50] = "ERROR";
+    Severity[Severity["FATAL"] = 60] = "FATAL";
+})(Severity || (Severity = {}));
+export { Severity, };

package/logger/adapters/file/FileLogger.d.ts

@@ -0,0 +1,20 @@
+import { Level } from '../../Level';
+import { Logger } from '../../Logger';
+declare class FileLogger extends Logger {
+    private readonly logger;
+    private readonly context;
+    constructor(params: {
+        path: string;
+        level?: Level;
+        context?: object;
+    });
+    trace(message: string, data?: unknown): void;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    fatal(message: string, data?: unknown): void;
+    close(): Promise<void>;
+    private getPayload;
+}
+export { FileLogger, };

package/logger/adapters/file/FileLogger.js

@@ -0,0 +1,64 @@
+import pino from 'pino';
+import { Level } from '../../Level';
+import { Logger } from '../../Logger';
+import { initFile } from './initFile';
+class FileLogger extends Logger {
+    logger;
+    context;
+    constructor(params) {
+        super();
+        initFile(params.path);
+        const stream = pino.destination(params.path);
+        this.logger = pino({
+            enabled: params.level !== Level.OFF,
+            level: params.level ?? Level.INFO,
+            messageKey: 'message',
+            formatters: {
+                level(label, number) {
+                    return {
+                        level: label,
+                        severity: number,
+                    };
+                },
+                bindings: () => { return {}; },
+            },
+        }, stream);
+        this.context = params.context;
+    }
+    trace(message, data) {
+        this.logger.trace(this.getPayload(message, data));
+    }
+    debug(message, data) {
+        this.logger.debug(this.getPayload(message, data));
+    }
+    info(message, data) {
+        this.logger.info(this.getPayload(message, data));
+    }
+    warn(message, data) {
+        this.logger.warn(this.getPayload(message, data));
+    }
+    error(message, data) {
+        this.logger.error(this.getPayload(message, data));
+    }
+    fatal(message, data) {
+        this.logger.fatal(this.getPayload(message, data));
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.logger.flush((error) => {
+                if (error) {
+                    reject(error);
+                }
+                resolve();
+            });
+        });
+    }
+    getPayload(message, data) {
+        return {
+            ...this.context,
+            message,
+            data,
+        };
+    }
+}
+export { FileLogger, };

package/logger/adapters/file/errors/FileInitError.d.ts

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

package/logger/adapters/file/errors/FileInitError.js

@@ -0,0 +1,7 @@
+import { BaseError } from '../../../../error/BaseError';
+class FileInitError extends BaseError {
+    constructor(path, message) {
+        super(`failed initializing file "${path}": ${message}`);
+    }
+}
+export { FileInitError, };

package/logger/adapters/file/initFile.d.ts

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

package/logger/adapters/file/initFile.js

@@ -0,0 +1,14 @@
+import fs from 'fs-extra';
+import { FileInitError } from './errors/FileInitError';
+const initFile = (path) => {
+    if (path === '') {
+        throw new FileInitError('', 'empty path');
+    }
+    try {
+        fs.ensureFileSync(path);
+    }
+    catch (error) {
+        throw new FileInitError(path, error.message);
+    }
+};
+export { initFile, };

package/logger/adapters/noop/NoopLogger.d.ts

@@ -0,0 +1,11 @@
+import { Logger } from '../../Logger';
+declare class NoopLogger extends Logger {
+    trace(): void;
+    debug(): void;
+    info(): void;
+    warn(): void;
+    error(): void;
+    fatal(): void;
+    close(): Promise<void>;
+}
+export { NoopLogger, };

package/logger/adapters/noop/NoopLogger.js

@@ -0,0 +1,11 @@
+import { Logger } from '../../Logger';
+class NoopLogger extends Logger {
+    trace() { }
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+    fatal() { }
+    async close() { }
+}
+export { NoopLogger, };

package/logger/adapters/stdio/StdioLogger.d.ts

@@ -0,0 +1,20 @@
+import { Level } from '../../Level';
+import { Logger } from '../../Logger';
+declare class StdioLogger extends Logger {
+    private readonly logger;
+    private readonly context;
+    constructor(params?: {
+        pretty?: boolean;
+        level?: Level;
+        context?: object;
+    });
+    trace(message: string, data?: unknown): void;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    fatal(message: string, data?: unknown): void;
+    close(): Promise<void>;
+    private getPayload;
+}
+export { StdioLogger, };

package/logger/adapters/stdio/StdioLogger.js

@@ -0,0 +1,67 @@
+import pino from 'pino';
+import pretty from 'pino-pretty';
+import { Level } from '../../Level';
+import { Logger } from '../../Logger';
+class StdioLogger extends Logger {
+    logger;
+    context;
+    constructor(params) {
+        super();
+        const stream = params?.pretty
+            ? pretty()
+            : pino.destination(process.stdout.fd);
+        this.logger = pino({
+            enabled: params?.level !== Level.OFF,
+            level: params?.level ?? Level.INFO,
+            messageKey: 'message',
+            formatters: {
+                level(label, number) {
+                    return {
+                        level: label,
+                        ...params?.pretty
+                            ? {}
+                            : { severity: number },
+                    };
+                },
+                bindings: () => { return {}; },
+            },
+        }, stream);
+        this.context = params?.context;
+    }
+    trace(message, data) {
+        this.logger.trace(this.getPayload(message, data));
+    }
+    debug(message, data) {
+        this.logger.debug(this.getPayload(message, data));
+    }
+    info(message, data) {
+        this.logger.info(this.getPayload(message, data));
+    }
+    warn(message, data) {
+        this.logger.warn(this.getPayload(message, data));
+    }
+    error(message, data) {
+        this.logger.error(this.getPayload(message, data));
+    }
+    fatal(message, data) {
+        this.logger.fatal(this.getPayload(message, data));
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.logger.flush((error) => {
+                if (error) {
+                    reject(error);
+                }
+                resolve();
+            });
+        });
+    }
+    getPayload(message, data) {
+        return {
+            ...this.context,
+            message,
+            data,
+        };
+    }
+}
+export { StdioLogger, };

package/mailer/Address.d.ts

@@ -0,0 +1,5 @@
+interface Address {
+    email: string;
+    name?: string;
+}
+export { type Address, };

package/mailer/Address.js

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

package/mailer/Attachment.d.ts

@@ -0,0 +1,7 @@
+import type { Readable } from 'stream';
+interface Attachment {
+    fileName: string;
+    contentType?: string;
+    content: Buffer | Readable | string;
+}
+export { type Attachment, };

package/mailer/Attachment.js

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

package/mailer/Event.d.ts

@@ -0,0 +1,16 @@
+import type { Location } from './Location';
+import type { Method } from './Method';
+interface Event {
+    fileName?: string;
+    method: Method;
+    id?: string;
+    start: Date;
+    end: Date;
+    allDay?: boolean;
+    name: string;
+    description?: string;
+    url?: string;
+    location?: Location;
+    attachments?: string[];
+}
+export { type Event, };

package/mailer/Event.js

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

package/mailer/List.d.ts

@@ -0,0 +1,7 @@
+interface List {
+    id?: string;
+    help?: string;
+    subscribe?: string;
+    unsubscribe?: string;
+}
+export { type List, };

package/mailer/List.js

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

package/mailer/Location.d.ts

@@ -0,0 +1,9 @@
+interface Location {
+    name: string;
+    address?: string;
+    geo?: {
+        latitude: number;
+        longitude: number;
+    };
+}
+export { type Location, };

package/mailer/Location.js

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

package/mailer/Mail.d.ts

@@ -0,0 +1,19 @@
+import type { Address } from './Address';
+import type { Attachment } from './Attachment';
+import type { Event } from './Event';
+import type { List } from './List';
+interface Mail {
+    from: Address;
+    sender?: Address;
+    replyTo?: Address;
+    to: Address[];
+    cc?: Address[];
+    bcc?: Address[];
+    subject: string;
+    text: string;
+    html?: string;
+    attachments?: Attachment[];
+    event?: Event;
+    list?: List;
+}
+export { type Mail, };

package/mailer/Mail.js

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

package/mailer/Mailer.d.ts

@@ -0,0 +1,7 @@
+import type { Mail } from './Mail';
+declare abstract class Mailer {
+    send(mail: Mail): Promise<string>;
+    abstract sendMail(mail: Mail): Promise<string>;
+    abstract close(): Promise<void>;
+}
+export { Mailer, };

package/mailer/Mailer.js

@@ -0,0 +1,47 @@
+import { validateAddressEmail } from './validateAddressEmail';
+import { validateEventAttachmentUrl } from './validateEventAttachmentUrl';
+import { validateEventGeolocation } from './validateEventGeolocation';
+import { validateEventUrl } from './validateEventUrl';
+import { validateListUrl } from './validateListUrl';
+class Mailer {
+    async send(mail) {
+        validateAddressEmail(mail.from.email);
+        if (mail.sender) {
+            validateAddressEmail(mail.sender.email);
+        }
+        if (mail.replyTo) {
+            validateAddressEmail(mail.replyTo.email);
+        }
+        mail.to.forEach((address) => {
+            validateAddressEmail(address.email);
+        });
+        if (mail.cc) {
+            mail.cc.forEach((address) => {
+                validateAddressEmail(address.email);
+            });
+        }
+        if (mail.bcc) {
+            mail.bcc.forEach((address) => {
+                validateAddressEmail(address.email);
+            });
+        }
+        if (mail.event?.url) {
+            validateEventUrl(mail.event.url);
+        }
+        if (mail.event?.location?.geo) {
+            validateEventGeolocation(mail.event.location.geo.latitude, mail.event.location.geo.longitude);
+        }
+        if (mail.event?.attachments) {
+            mail.event.attachments.forEach((attachment) => {
+                validateEventAttachmentUrl(attachment);
+            });
+        }
+        if (mail.list) {
+            Object.entries(mail.list).forEach(([property, url]) => {
+                validateListUrl(property, url);
+            });
+        }
+        return this.sendMail(mail);
+    }
+}
+export { Mailer, };

package/mailer/Method.d.ts

@@ -0,0 +1,5 @@
+declare enum Method {
+    PUBLISH = "PUBLISH",
+    CANCEL = "CANCEL"
+}
+export { Method, };

package/mailer/Method.js

@@ -0,0 +1,6 @@
+var Method;
+(function (Method) {
+    Method["PUBLISH"] = "PUBLISH";
+    Method["CANCEL"] = "CANCEL";
+})(Method || (Method = {}));
+export { Method, };

package/mailer/adapters/noop/NoopMailer.d.ts

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

package/mailer/adapters/noop/NoopMailer.js

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

package/mailer/adapters/smtp/SmtpMailer.d.ts

@@ -0,0 +1,18 @@
+import { Mailer } from '../../Mailer';
+import type { Tls } from '../../../tls/Tls';
+import type { Mail } from '../../Mail';
+declare class SmtpMailer extends Mailer {
+    private readonly transporter;
+    constructor(params: {
+        host: string;
+        port: number;
+        secure?: boolean;
+        tls?: Tls;
+        user?: string;
+        password?: string;
+        maxConnections?: number;
+    });
+    sendMail(mail: Mail): Promise<string>;
+    close(): Promise<void>;
+}
+export { SmtpMailer, };

package/mailer/adapters/smtp/SmtpMailer.js

@@ -0,0 +1,54 @@
+import nodemailer from 'nodemailer';
+import { getTls } from '../../../tls/getTls';
+import { Mailer } from '../../Mailer';
+import { getIcalendar } from '../../getIcalendar';
+import { getAddress } from './getAddress';
+import { getAddresses } from './getAddresses';
+import { getAttachments } from './getAttachments';
+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/mailer/adapters/smtp/getAddress.d.ts

@@ -0,0 +1,4 @@
+import type { Address } from '../../Address';
+import type { Address as NodemailerAddress } from 'nodemailer/lib/mailer';
+declare const getAddress: (address?: Address) => NodemailerAddress | undefined;
+export { getAddress, };