apeframework 0.0.0-dev.2 → 0.0.0-dev.3

package/jwt/Jwt.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Jwt = void 0;
+const jose_1 = require("jose");
+const validateSecretLength_1 = require("./validateSecretLength");
+class Jwt {
+    algorithm;
+    secret;
+    issuer;
+    audience;
+    expiration;
+    constructor(params) {
+        (0, validateSecretLength_1.validateSecretLength)(params.algorithm, params.secret);
+        this.algorithm = params.algorithm;
+        this.secret = new TextEncoder().encode(params.secret);
+        this.issuer = params.issuer;
+        this.audience = params.audience;
+        this.expiration = params.expiration;
+    }
+    async createToken(payload) {
+        const jwt = new jose_1.SignJWT(Object.fromEntries(Object.entries(payload).filter(([key]) => {
+            return !['subject', 'issuedAt', 'id'].includes(key);
+        })));
+        jwt
+            .setProtectedHeader({ typ: 'JWT', alg: this.algorithm })
+            .setIssuer(this.issuer)
+            .setAudience(this.audience)
+            .setSubject(payload.subject)
+            .setIssuedAt(payload.issuedAt);
+        if (this.expiration) {
+            jwt.setExpirationTime(payload.issuedAt + this.expiration);
+        }
+        if (payload.id) {
+            jwt.setJti(payload.id);
+        }
+        return jwt.sign(this.secret);
+    }
+    async verifyToken(token, timestamp) {
+        try {
+            const { payload: jwt } = await (0, jose_1.jwtVerify)(token, this.secret, {
+                typ: 'JWT',
+                algorithms: [this.algorithm],
+                audience: this.audience,
+                currentDate: new Date(timestamp * 1000),
+            });
+            const payload = Object.fromEntries(Object.entries(jwt).filter(([key]) => {
+                return !['iss', 'aud', 'sub', 'iat', 'exp', 'jti'].includes(key);
+            }));
+            return {
+                subject: jwt.sub,
+                issuedAt: jwt.iat,
+                ...jwt.jti ? { id: jwt.jti } : {},
+                ...payload,
+            };
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+}
+exports.Jwt = Jwt;

package/jwt/Jwt.ts

@@ -0,0 +1,92 @@
+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
+
+  private readonly issuer: string
+
+  private readonly audience: string
+
+  private readonly expiration: number | undefined
+
+  public constructor(params: {
+    algorithm: Algorithm,
+    secret: string,
+    issuer: string,
+    audience: string,
+    expiration?: number,
+  }) {
+    validateSecretLength(params.algorithm, params.secret)
+
+    this.algorithm = params.algorithm
+    this.secret = new TextEncoder().encode(params.secret)
+    this.issuer = params.issuer
+    this.audience = params.audience
+    this.expiration = params.expiration
+  }
+
+  public async createToken(payload: Payload): Promise<string> {
+    const jwt = new SignJWT(
+      Object.fromEntries(
+        Object.entries(payload).filter(([key]) => {
+          return !['subject', 'issuedAt', 'id'].includes(key)
+        }),
+      ),
+    )
+
+    jwt
+      .setProtectedHeader({ typ: 'JWT', alg: this.algorithm })
+      .setIssuer(this.issuer)
+      .setAudience(this.audience)
+      .setSubject(payload.subject)
+      .setIssuedAt(payload.issuedAt)
+
+    if (this.expiration) {
+      jwt.setExpirationTime(payload.issuedAt + this.expiration)
+    }
+
+    if (payload.id) {
+      jwt.setJti(payload.id)
+    }
+
+    return jwt.sign(this.secret)
+  }
+
+  public async verifyToken<Type extends Payload>(
+    token: string,
+    timestamp: number,
+  ): Promise<Type | undefined> {
+    try {
+      const { payload: jwt } = await jwtVerify(token, this.secret, {
+        typ: 'JWT',
+        algorithms: [this.algorithm],
+        audience: this.audience,
+        currentDate: new Date(timestamp * 1000),
+      })
+
+      const payload = Object.fromEntries(
+        Object.entries(jwt).filter(([key]) => {
+          return !['iss', 'aud', 'sub', 'iat', 'exp', 'jti'].includes(key)
+        }),
+      )
+
+      return {
+        subject: jwt.sub,
+        issuedAt: jwt.iat,
+        ...jwt.jti ? { id: jwt.jti } : {},
+        ...payload,
+      } as Type
+    } catch (error) {
+      return undefined
+    }
+  }
+}
+
+export {
+  Jwt,
+}

package/jwt/Payload.d.ts

@@ -0,0 +1,7 @@
+interface Payload {
+    [key: string]: unknown;
+    subject: string;
+    issuedAt: number;
+    id?: string;
+}
+export { type Payload, };

package/jwt/Payload.ts

@@ -0,0 +1,10 @@
+interface Payload {
+  [key: string]: unknown,
+  subject: string,
+  issuedAt: number,
+  id?: string,
+}
+
+export {
+  type Payload,
+}

package/jwt/errors/JwtSecretLengthError.d.ts

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

package/jwt/errors/JwtSecretLengthError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtSecretLengthError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class JwtSecretLengthError extends BaseError_1.BaseError {
+    constructor() {
+        super('invalid secret length');
+    }
+}
+exports.JwtSecretLengthError = JwtSecretLengthError;

package/jwt/errors/JwtSecretLengthError.ts

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

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 JwtSecretLengthError_1 = require("./errors/JwtSecretLengthError");
+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 JwtSecretLengthError_1.JwtSecretLengthError();
+    }
+};
+exports.validateSecretLength = validateSecretLength;

package/jwt/validateSecretLength.ts

@@ -0,0 +1,18 @@
+import { Algorithm } from './Algorithm'
+import { JwtSecretLengthError } from './errors/JwtSecretLengthError'
+
+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 JwtSecretLengthError()
+  }
+}
+
+export {
+  validateSecretLength,
+}

package/logger/Level.d.ts

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

package/logger/Level.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Level = void 0;
+var Level;
+(function (Level) {
+    Level[Level["TRACE"] = 10] = "TRACE";
+    Level[Level["DEBUG"] = 20] = "DEBUG";
+    Level[Level["INFO"] = 30] = "INFO";
+    Level[Level["WARN"] = 40] = "WARN";
+    Level[Level["ERROR"] = 50] = "ERROR";
+    Level[Level["FATAL"] = 60] = "FATAL";
+})(Level || (exports.Level = Level = {}));

package/logger/Level.ts

@@ -0,0 +1,12 @@
+enum Level {
+  TRACE = 10,
+  DEBUG = 20,
+  INFO = 30,
+  WARN = 40,
+  ERROR = 50,
+  FATAL = 60,
+}
+
+export {
+  Level,
+}

package/logger/Logger.d.ts

@@ -0,0 +1,10 @@
+interface Logger {
+    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>;
+}
+export { type Logger, };

package/logger/Logger.ts

@@ -0,0 +1,13 @@
+interface Logger {
+  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>,
+}
+
+export {
+  type Logger,
+}

package/logger/Severity.d.ts

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

package/logger/Severity.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Severity = void 0;
+var Severity;
+(function (Severity) {
+    Severity["TRACE"] = "trace";
+    Severity["DEBUG"] = "debug";
+    Severity["INFO"] = "info";
+    Severity["WARN"] = "warn";
+    Severity["ERROR"] = "error";
+    Severity["FATAL"] = "fatal";
+    Severity["OFF"] = "off";
+})(Severity || (exports.Severity = Severity = {}));

package/logger/Severity.ts

@@ -0,0 +1,13 @@
+enum Severity {
+  TRACE = 'trace',
+  DEBUG = 'debug',
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+  FATAL = 'fatal',
+  OFF = 'off',
+}
+
+export {
+  Severity,
+}

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

@@ -0,0 +1,20 @@
+import { Severity } from '../../Severity';
+import type { Logger } from '../../Logger';
+declare class FileLogger implements Logger {
+    private readonly logger;
+    private readonly context;
+    constructor(params: {
+        path: string;
+        severity?: Severity;
+        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 getData;
+}
+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 Severity_1 = require("../../Severity");
+const initFile_1 = require("./initFile");
+class FileLogger {
+    logger;
+    context;
+    constructor(params) {
+        (0, initFile_1.initFile)(params.path);
+        const stream = pino_1.default.destination(params.path);
+        this.logger = (0, pino_1.default)({
+            enabled: params.severity !== Severity_1.Severity.OFF,
+            level: params.severity ?? Severity_1.Severity.INFO,
+            messageKey: 'message',
+            formatters: {
+                level(label, number) {
+                    return {
+                        level: number,
+                        severity: label,
+                    };
+                },
+                bindings: () => {
+                    return {};
+                },
+            },
+        }, stream);
+        this.context = params.context;
+    }
+    trace(message, data) {
+        this.logger.trace(this.getData(message, data));
+    }
+    debug(message, data) {
+        this.logger.debug(this.getData(message, data));
+    }
+    info(message, data) {
+        this.logger.info(this.getData(message, data));
+    }
+    warn(message, data) {
+        this.logger.warn(this.getData(message, data));
+    }
+    error(message, data) {
+        this.logger.error(this.getData(message, data));
+    }
+    fatal(message, data) {
+        this.logger.fatal(this.getData(message, data));
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.logger.flush((error) => {
+                if (error) {
+                    reject(error);
+                }
+                resolve();
+            });
+        });
+    }
+    getData(message, data) {
+        return {
+            message,
+            data,
+            ...this.context,
+        };
+    }
+}
+exports.FileLogger = FileLogger;

package/logger/adapters/file/FileLogger.ts

@@ -0,0 +1,87 @@
+import pino from 'pino'
+import { Severity } from '../../Severity'
+import { initFile } from './initFile'
+import type { Logger } from '../../Logger'
+import type { Logger as PinoLogger } from 'pino'
+
+class FileLogger implements Logger {
+  private readonly logger: PinoLogger
+
+  private readonly context: object | undefined
+
+  public constructor(params: {
+    path: string,
+    severity?: Severity,
+    context?: object,
+  }) {
+    initFile(params.path)
+
+    const stream = pino.destination(params.path)
+
+    this.logger = pino({
+      enabled: params.severity !== Severity.OFF,
+      level: params.severity ?? Severity.INFO,
+      messageKey: 'message',
+      formatters: {
+        level(label, number) {
+          return {
+            level: number,
+            severity: label,
+          }
+        },
+        bindings: () => {
+          return {}
+        },
+      },
+    }, stream)
+
+    this.context = params.context
+  }
+
+  public trace(message: string, data?: unknown): void {
+    this.logger.trace(this.getData(message, data))
+  }
+
+  public debug(message: string, data?: unknown): void {
+    this.logger.debug(this.getData(message, data))
+  }
+
+  public info(message: string, data?: unknown): void {
+    this.logger.info(this.getData(message, data))
+  }
+
+  public warn(message: string, data?: unknown): void {
+    this.logger.warn(this.getData(message, data))
+  }
+
+  public error(message: string, data?: unknown): void {
+    this.logger.error(this.getData(message, data))
+  }
+
+  public fatal(message: string, data?: unknown): void {
+    this.logger.fatal(this.getData(message, data))
+  }
+
+  public async close(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      this.logger.flush((error) => {
+        if (error) {
+          reject(error)
+        }
+        resolve()
+      })
+    })
+  }
+
+  private getData(message: string, data?: unknown): object {
+    return {
+      message,
+      data,
+      ...this.context,
+    }
+  }
+}
+
+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 type { Logger } from '../../Logger';
+declare class NoopLogger implements 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,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoopLogger = void 0;
+class NoopLogger {
+    trace() { }
+    debug() { }
+    info() { }
+    warn() { }
+    error() { }
+    fatal() { }
+    async close() { }
+}
+exports.NoopLogger = NoopLogger;

package/logger/adapters/noop/NoopLogger.ts

@@ -0,0 +1,21 @@
+import type { Logger } from '../../Logger'
+
+class NoopLogger implements 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 { Severity } from '../../Severity';
+import type { Logger } from '../../Logger';
+declare class StdioLogger implements Logger {
+    private readonly logger;
+    private readonly context;
+    constructor(params?: {
+        pretty?: boolean;
+        severity?: Severity;
+        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 getData;
+}
+export { StdioLogger, };