apeframework 0.0.0-dev.2 → 0.0.0-dev.4

package/logger/adapters/file/FileLogger.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileLogger = void 0;
+const pino_1 = __importDefault(require("pino"));
+const Level_1 = require("../../Level");
+const Logger_1 = require("../../Logger");
+const initFile_1 = require("./initFile");
+class FileLogger extends Logger_1.Logger {
+    logger;
+    context;
+    constructor(params) {
+        super();
+        (0, initFile_1.initFile)(params.path);
+        const stream = pino_1.default.destination(params.path);
+        this.logger = (0, pino_1.default)({
+            enabled: params.level !== Level_1.Level.OFF,
+            level: params.level ?? Level_1.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,
+        };
+    }
+}
+exports.FileLogger = FileLogger;

package/logger/adapters/file/FileLogger.ts

@@ -0,0 +1,87 @@
+import pino from 'pino'
+import { Level } from '../../Level'
+import { Logger } from '../../Logger'
+import { initFile } from './initFile'
+import type { Logger as PinoLogger } from 'pino'
+
+class FileLogger extends Logger {
+  private readonly logger: PinoLogger
+
+  private readonly context: object | undefined
+
+  public constructor(params: {
+    path: string,
+    level?: Level,
+    context?: object,
+  }) {
+    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
+  }
+
+  public trace(message: string, data?: unknown): void {
+    this.logger.trace(this.getPayload(message, data))
+  }
+
+  public debug(message: string, data?: unknown): void {
+    this.logger.debug(this.getPayload(message, data))
+  }
+
+  public info(message: string, data?: unknown): void {
+    this.logger.info(this.getPayload(message, data))
+  }
+
+  public warn(message: string, data?: unknown): void {
+    this.logger.warn(this.getPayload(message, data))
+  }
+
+  public error(message: string, data?: unknown): void {
+    this.logger.error(this.getPayload(message, data))
+  }
+
+  public fatal(message: string, data?: unknown): void {
+    this.logger.fatal(this.getPayload(message, data))
+  }
+
+  public async close(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.logger.flush((error) => {
+        if (error) {
+          reject(error)
+        }
+        resolve()
+      })
+    })
+  }
+
+  private getPayload(message: string, data?: unknown): object {
+    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,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileInitError = void 0;
+const BaseError_1 = require("../../../../error/BaseError");
+class FileInitError extends BaseError_1.BaseError {
+    constructor(path, message) {
+        super(`failed initializing file "${path}": ${message}`);
+    }
+}
+exports.FileInitError = FileInitError;

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

@@ -0,0 +1,11 @@
+import { BaseError } from '../../../../error/BaseError'
+
+class FileInitError extends BaseError {
+  public constructor(path: string, message: string) {
+    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,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initFile = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const FileInitError_1 = require("./errors/FileInitError");
+const initFile = (path) => {
+    if (path === '') {
+        throw new FileInitError_1.FileInitError('', 'empty path');
+    }
+    try {
+        fs_extra_1.default.ensureFileSync(path);
+    }
+    catch (error) {
+        throw new FileInitError_1.FileInitError(path, error.message);
+    }
+};
+exports.initFile = initFile;

package/logger/adapters/file/initFile.ts

@@ -0,0 +1,18 @@
+import fs from 'fs-extra'
+import { FileInitError } from './errors/FileInitError'
+
+const initFile = (path: string): void => {
+  if (path === '') {
+    throw new FileInitError('', 'empty path')
+  }
+
+  try {
+    fs.ensureFileSync(path)
+  } catch (error) {
+    throw new FileInitError(path, (error as 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,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopLogger = void 0;
+const Logger_1 = require("../../Logger");
+class NoopLogger extends Logger_1.Logger {
+    trace() { }
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+    fatal() { }
+    async close() { }
+}
+exports.NoopLogger = NoopLogger;

package/logger/adapters/noop/NoopLogger.ts

@@ -0,0 +1,21 @@
+import { Logger } from '../../Logger'
+
+class NoopLogger extends Logger {
+  public trace(): void { }
+
+  public debug(): void { }
+
+  public info(): void { }
+
+  public warn(): void { }
+
+  public error(): void { }
+
+  public fatal(): void { }
+
+  public async close(): Promise<void> { }
+}
+
+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,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdioLogger = void 0;
+const pino_1 = __importDefault(require("pino"));
+const pino_pretty_1 = __importDefault(require("pino-pretty"));
+const Level_1 = require("../../Level");
+const Logger_1 = require("../../Logger");
+class StdioLogger extends Logger_1.Logger {
+    logger;
+    context;
+    constructor(params) {
+        super();
+        const stream = params?.pretty
+            ? (0, pino_pretty_1.default)()
+            : pino_1.default.destination(process.stdout.fd);
+        this.logger = (0, pino_1.default)({
+            enabled: params?.level !== Level_1.Level.OFF,
+            level: params?.level ?? Level_1.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,
+        };
+    }
+}
+exports.StdioLogger = StdioLogger;

package/logger/adapters/stdio/StdioLogger.ts

@@ -0,0 +1,89 @@
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import { Level } from '../../Level'
+import { Logger } from '../../Logger'
+import type { Logger as PinoLogger } from 'pino'
+
+class StdioLogger extends Logger {
+  private readonly logger: PinoLogger
+
+  private readonly context: object | undefined
+
+  public constructor(params?: {
+    pretty?: boolean,
+    level?: Level,
+    context?: object,
+  }) {
+    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
+  }
+
+  public trace(message: string, data?: unknown): void {
+    this.logger.trace(this.getPayload(message, data))
+  }
+
+  public debug(message: string, data?: unknown): void {
+    this.logger.debug(this.getPayload(message, data))
+  }
+
+  public info(message: string, data?: unknown): void {
+    this.logger.info(this.getPayload(message, data))
+  }
+
+  public warn(message: string, data?: unknown): void {
+    this.logger.warn(this.getPayload(message, data))
+  }
+
+  public error(message: string, data?: unknown): void {
+    this.logger.error(this.getPayload(message, data))
+  }
+
+  public fatal(message: string, data?: unknown): void {
+    this.logger.fatal(this.getPayload(message, data))
+  }
+
+  public async close(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.logger.flush((error) => {
+        if (error) {
+          reject(error)
+        }
+        resolve()
+      })
+    })
+  }
+
+  private getPayload(message: string, data?: unknown): object {
+    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.ts

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

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.ts

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

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.ts

@@ -0,0 +1,20 @@
+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/List.d.ts

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

package/mailer/List.ts

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

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.ts

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

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.ts

@@ -0,0 +1,23 @@
+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/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, };