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

package/config/readFile.ts

@@ -0,0 +1,34 @@
+import fs from 'fs-extra'
+import { FileReadError } from './errors/FileReadError'
+
+const readFile = (path: string, required = false): Record<string, any> => {
+  let json: any = {}
+  let fileExists: boolean
+
+  try {
+    fileExists = fs.existsSync(path)
+    if (fileExists) {
+      json = fs.readJsonSync(path)
+    }
+  } catch (error) {
+    throw new FileReadError(path, (error as Error).message)
+  }
+
+  if (required && !fileExists) {
+    throw new FileReadError(path, 'missing file')
+  }
+
+  if (
+    typeof json !== 'object'
+    || Array.isArray(json)
+    || json === null
+  ) {
+    throw new FileReadError(path, 'invalid content')
+  }
+
+  return json as Record<string, any>
+}
+
+export {
+  readFile,
+}

package/config/validatePropertyName.d.ts

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

package/config/validatePropertyName.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePropertyName = void 0;
+const PropertyNameError_1 = require("./errors/PropertyNameError");
+const propertyNameRegex = /^[a-z](?:[0-9A-Za-z])*$/u;
+const validatePropertyName = (name) => {
+    if (!propertyNameRegex.test(name)) {
+        throw new PropertyNameError_1.PropertyNameError(name);
+    }
+};
+exports.validatePropertyName = validatePropertyName;

package/config/validatePropertyName.ts

@@ -0,0 +1,13 @@
+import { PropertyNameError } from './errors/PropertyNameError'
+
+const propertyNameRegex = /^[a-z](?:[0-9A-Za-z])*$/u
+
+const validatePropertyName = (name: string): void => {
+  if (!propertyNameRegex.test(name)) {
+    throw new PropertyNameError(name)
+  }
+}
+
+export {
+  validatePropertyName,
+}

package/env/Env.d.ts

@@ -0,0 +1,2 @@
+type Env = Record<string, string>;
+export { type Env, };

package/env/Env.ts

@@ -0,0 +1,5 @@
+type Env = Record<string, string>
+
+export {
+  type Env,
+}

package/env/errors/FileReadError.d.ts

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

package/env/errors/FileReadError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileReadError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class FileReadError extends BaseError_1.BaseError {
+    constructor(path, message) {
+        super(`failed reading file "${path}": ${message}`);
+    }
+}
+exports.FileReadError = FileReadError;

package/env/errors/FileReadError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class FileReadError extends BaseError {
+  public constructor(path: string, message: string) {
+    super(`failed reading file "${path}": ${message}`)
+  }
+}
+
+export {
+  FileReadError,
+}

package/env/getEnv.d.ts

@@ -0,0 +1,8 @@
+import type { Env } from './Env';
+declare const getEnv: (params?: {
+    file?: {
+        path: string;
+        required?: boolean;
+    };
+}) => Env;
+export { getEnv, };

package/env/getEnv.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnv = void 0;
+const readFile_1 = require("./readFile");
+const getEnv = (params) => {
+    let file = {};
+    if (params?.file) {
+        file = (0, readFile_1.readFile)(params.file.path, params.file.required);
+    }
+    return {
+        ...file,
+        ...process.env,
+    };
+};
+exports.getEnv = getEnv;

package/env/getEnv.ts

@@ -0,0 +1,24 @@
+import { readFile } from './readFile'
+import type { Env } from './Env'
+
+const getEnv = (params?: {
+  file?: {
+    path: string,
+    required?: boolean,
+  },
+}): Env => {
+  let file: Env = {}
+
+  if (params?.file) {
+    file = readFile(params.file.path, params.file.required)
+  }
+
+  return {
+    ...file,
+    ...process.env as Env,
+  }
+}
+
+export {
+  getEnv,
+}

package/env/readFile.d.ts

@@ -0,0 +1,3 @@
+import type { Env } from './Env';
+declare const readFile: (path: string, required?: boolean) => Env;
+export { readFile, };

package/env/readFile.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFile = void 0;
+const dotenv_1 = __importDefault(require("dotenv"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const FileReadError_1 = require("./errors/FileReadError");
+const readFile = (path, required = false) => {
+    try {
+        if (fs_extra_1.default.existsSync(path)) {
+            return dotenv_1.default.parse(fs_extra_1.default.readFileSync(path));
+        }
+    }
+    catch (error) {
+        throw new FileReadError_1.FileReadError(path, error.message);
+    }
+    if (required) {
+        throw new FileReadError_1.FileReadError(path, 'missing file');
+    }
+    return {};
+};
+exports.readFile = readFile;

package/env/readFile.ts

@@ -0,0 +1,24 @@
+import dotenv from 'dotenv'
+import fs from 'fs-extra'
+import { FileReadError } from './errors/FileReadError'
+import type { Env } from './Env'
+
+const readFile = (path: string, required = false): Env => {
+  try {
+    if (fs.existsSync(path)) {
+      return dotenv.parse(fs.readFileSync(path))
+    }
+  } catch (error) {
+    throw new FileReadError(path, (error as Error).message)
+  }
+
+  if (required) {
+    throw new FileReadError(path, 'missing file')
+  }
+
+  return {}
+}
+
+export {
+  readFile,
+}

package/error/BaseError.d.ts

@@ -0,0 +1,4 @@
+declare class BaseError extends Error {
+    constructor(message: string);
+}
+export { BaseError, };

package/error/BaseError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseError = void 0;
+class BaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = new.target.name;
+        Error.captureStackTrace(this, new.target);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.BaseError = BaseError;

package/error/BaseError.ts

@@ -0,0 +1,12 @@
+class BaseError extends Error {
+  public constructor(message: string) {
+    super(message)
+    this.name = new.target.name
+    Error.captureStackTrace(this, new.target)
+    Object.setPrototypeOf(this, new.target.prototype)
+  }
+}
+
+export {
+  BaseError,
+}

package/jwt/Algorithm.d.ts

@@ -0,0 +1,6 @@
+declare enum Algorithm {
+    HS256 = "HS256",
+    HS384 = "HS384",
+    HS512 = "HS512"
+}
+export { Algorithm, };

package/jwt/Algorithm.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Algorithm = void 0;
+var Algorithm;
+(function (Algorithm) {
+    Algorithm["HS256"] = "HS256";
+    Algorithm["HS384"] = "HS384";
+    Algorithm["HS512"] = "HS512";
+})(Algorithm || (exports.Algorithm = Algorithm = {}));

package/jwt/Algorithm.ts

@@ -0,0 +1,9 @@
+enum Algorithm {
+  HS256 = 'HS256',
+  HS384 = 'HS384',
+  HS512 = 'HS512',
+}
+
+export {
+  Algorithm,
+}

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,35 @@
+"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;
+    constructor(params) {
+        (0, validateSecretLength_1.validateSecretLength)(params.algorithm, params.secret);
+        this.algorithm = params.algorithm;
+        this.secret = new TextEncoder().encode(params.secret);
+    }
+    async createToken(payload) {
+        return new jose_1.SignJWT(payload)
+            .setProtectedHeader({
+            typ: 'JWT',
+            alg: this.algorithm,
+        })
+            .sign(this.secret);
+    }
+    async verifyToken(token, timestamp) {
+        try {
+            const { payload } = await (0, jose_1.jwtVerify)(token, this.secret, {
+                typ: 'JWT',
+                currentDate: new Date(timestamp * 1000),
+            });
+            return payload;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+}
+exports.Jwt = Jwt;

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, };