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

package/jwt/Jwt.ts

@@ -0,0 +1,49 @@
+import { SignJWT, jwtVerify } from 'jose'
+import { validateSecretLength } from './validateSecretLength'
+import type { Algorithm } from './Algorithm'
+import type { Payload } from './Payload'
+
+class Jwt {
+  private readonly algorithm: Algorithm
+
+  private readonly secret: Uint8Array
+
+  public constructor(params: {
+    algorithm: Algorithm,
+    secret: string,
+  }) {
+    validateSecretLength(params.algorithm, params.secret)
+
+    this.algorithm = params.algorithm
+    this.secret = new TextEncoder().encode(params.secret)
+  }
+
+  public async createToken(payload: Payload): Promise<string> {
+    return new SignJWT(payload)
+      .setProtectedHeader({
+        typ: 'JWT',
+        alg: this.algorithm,
+      })
+      .sign(this.secret)
+  }
+
+  public async verifyToken<Type extends Payload>(
+    token: string,
+    timestamp: number,
+  ): Promise<Type | undefined> {
+    try {
+      const { payload } = await jwtVerify(token, this.secret, {
+        typ: 'JWT',
+        currentDate: new Date(timestamp * 1000),
+      })
+
+      return payload as Type
+    } 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.ts

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

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,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecretLengthError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class SecretLengthError extends BaseError_1.BaseError {
+    constructor() {
+        super('invalid secret length');
+    }
+}
+exports.SecretLengthError = SecretLengthError;

package/jwt/errors/SecretLengthError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class SecretLengthError extends BaseError {
+  public 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,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSecretLength = void 0;
+const Algorithm_1 = require("./Algorithm");
+const SecretLengthError_1 = require("./errors/SecretLengthError");
+const minSecretLength = {
+    [Algorithm_1.Algorithm.HS256]: 32,
+    [Algorithm_1.Algorithm.HS384]: 48,
+    [Algorithm_1.Algorithm.HS512]: 64,
+};
+const validateSecretLength = (algorithm, secret) => {
+    if (Buffer.from(secret).length < minSecretLength[algorithm]) {
+        throw new SecretLengthError_1.SecretLengthError();
+    }
+};
+exports.validateSecretLength = validateSecretLength;

package/jwt/validateSecretLength.ts

@@ -0,0 +1,18 @@
+import { Algorithm } from './Algorithm'
+import { SecretLengthError } from './errors/SecretLengthError'
+
+const minSecretLength = {
+  [Algorithm.HS256]: 32,
+  [Algorithm.HS384]: 48,
+  [Algorithm.HS512]: 64,
+}
+
+const validateSecretLength = (algorithm: Algorithm, secret: string): void => {
+  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,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Level = void 0;
+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 || (exports.Level = Level = {}));

package/logger/Level.ts

@@ -0,0 +1,13 @@
+enum Level {
+  TRACE = 'trace',
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+  FATAL = 'fatal',
+  OFF = 'off',
+}
+
+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,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+class Logger {
+}
+exports.Logger = Logger;

package/logger/Logger.ts

@@ -0,0 +1,19 @@
+abstract class Logger {
+  public abstract trace(message: string, data?: unknown): void
+
+  public abstract debug(message: string, data?: unknown): void
+
+  public abstract info(message: string, data?: unknown): void
+
+  public abstract warn(message: string, data?: unknown): void
+
+  public abstract error(message: string, data?: unknown): void
+
+  public abstract fatal(message: string, data?: unknown): void
+
+  public abstract close(): Promise<void>
+}
+
+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,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Severity = void 0;
+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 || (exports.Severity = Severity = {}));

package/logger/Severity.ts

@@ -0,0 +1,12 @@
+enum Severity {
+  TRACE = 10,
+  DEBUG = 20,
+  INFO = 30,
+  WARN = 40,
+  ERROR = 50,
+  FATAL = 60,
+}
+
+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,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;