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

package/config/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/config/errors/PropertyNameError.d.ts

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

package/config/errors/PropertyNameError.js

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

package/config/errors/PropertyNameError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class PropertyNameError extends BaseError {
+  public constructor(name: string) {
+    super(`invalid property name "${name}"`)
+  }
+}
+
+export {
+  PropertyNameError,
+}

package/config/errors/PropertyParseError.d.ts

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

package/config/errors/PropertyParseError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyParseError = void 0;
+const BaseError_1 = require("../../error/BaseError");
+class PropertyParseError extends BaseError_1.BaseError {
+    constructor(name, source, message) {
+        super(`failed parsing property "${name}" from ${source}: ${message}`);
+    }
+}
+exports.PropertyParseError = PropertyParseError;

package/config/errors/PropertyParseError.ts

@@ -0,0 +1,11 @@
+import { BaseError } from '../../error/BaseError'
+
+class PropertyParseError extends BaseError {
+  public constructor(name: string, source: string, message: string) {
+    super(`failed parsing property "${name}" from ${source}: ${message}`)
+  }
+}
+
+export {
+  PropertyParseError,
+}

package/config/getConfig.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from './Config';
+import type { Properties } from './Properties';
+import type { Args } from '../cli/Args';
+import type { Env } from '../env/Env';
+declare const getConfig: <Type extends Config>(params: {
+    properties: Properties<Type>;
+    file?: {
+        path: string;
+        required?: boolean;
+    };
+    env?: Env;
+    args?: Args;
+}) => Type;
+export { getConfig, };

package/config/getConfig.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = void 0;
+const getPropertyEnvVar_1 = require("./getPropertyEnvVar");
+const parseProperty_1 = require("./parseProperty");
+const readFile_1 = require("./readFile");
+const validatePropertyName_1 = require("./validatePropertyName");
+const getConfig = (params) => {
+    const file = params.file
+        ? (0, readFile_1.readFile)(params.file.path, params.file.required)
+        : {};
+    const env = params.env ?? {};
+    const args = params.args ?? { positional: [], optional: {} };
+    const config = {};
+    for (const name in params.properties) {
+        (0, validatePropertyName_1.validatePropertyName)(name);
+        config[name] = (0, parseProperty_1.parseProperty)(name, params.properties[name].parser, params.properties[name].default, file[name], env[(0, getPropertyEnvVar_1.getPropertyEnvVar)(name)], args.optional[name]);
+    }
+    return config;
+};
+exports.getConfig = getConfig;

package/config/getConfig.ts

@@ -0,0 +1,47 @@
+import { getPropertyEnvVar } from './getPropertyEnvVar'
+import { parseProperty } from './parseProperty'
+import { readFile } from './readFile'
+import { validatePropertyName } from './validatePropertyName'
+import type { Config } from './Config'
+import type { Properties } from './Properties'
+import type { Args } from '../cli/Args'
+import type { Env } from '../env/Env'
+
+const getConfig = <Type extends Config>(params: {
+  properties: Properties<Type>,
+  file?: {
+    path: string,
+    required?: boolean,
+  },
+  env?: Env,
+  args?: Args,
+}): Type => {
+  const file = params.file
+    ? readFile(params.file.path, params.file.required)
+    : {}
+
+  const env: Env = params.env ?? {}
+
+  const args: Args = params.args ?? { positional: [], optional: {} }
+
+  const config: Config = {}
+
+  for (const name in params.properties) {
+    validatePropertyName(name)
+
+    config[name] = parseProperty(
+      name,
+      params.properties[name].parser,
+      params.properties[name].default,
+      file[name],
+      env[getPropertyEnvVar(name)],
+      args.optional[name],
+    )
+  }
+
+  return config as Type
+}
+
+export {
+  getConfig,
+}

package/config/getPropertyEnvVar.d.ts

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

package/config/getPropertyEnvVar.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPropertyEnvVar = void 0;
+const capitalLetterRegex = /[A-Z]/gu;
+const capitalLetterReplacer = (letter) => {
+    return `_${letter}`;
+};
+const getPropertyEnvVar = (name) => {
+    return name
+        .replace(capitalLetterRegex, capitalLetterReplacer)
+        .toUpperCase();
+};
+exports.getPropertyEnvVar = getPropertyEnvVar;

package/config/getPropertyEnvVar.ts

@@ -0,0 +1,15 @@
+const capitalLetterRegex = /[A-Z]/gu
+
+const capitalLetterReplacer = (letter: string): string => {
+  return `_${letter}`
+}
+
+const getPropertyEnvVar = (name: string): string => {
+  return name
+    .replace(capitalLetterRegex, capitalLetterReplacer)
+    .toUpperCase()
+}
+
+export {
+  getPropertyEnvVar,
+}

package/config/parseProperty.d.ts

@@ -0,0 +1,3 @@
+import type { Parser } from '../parser/Parser';
+declare const parseProperty: <Type>(name: string, parser: Parser<Type>, defaultValue: any, fileValue: any, envValue: any, argsValue: any) => Type;
+export { parseProperty, };

package/config/parseProperty.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProperty = void 0;
+const PropertyParseError_1 = require("./errors/PropertyParseError");
+const parseProperty = (name, parser, defaultValue, fileValue, envValue, argsValue) => {
+    const sources = [
+        {
+            name: 'command line arguments',
+            value: argsValue,
+        },
+        {
+            name: 'environment variables',
+            value: envValue,
+        },
+        {
+            name: 'configuration file',
+            value: fileValue,
+        },
+        {
+            name: 'default value',
+            value: defaultValue,
+        },
+    ];
+    const source = sources.find((s) => {
+        return s.value !== undefined;
+    }) || {
+        name: 'undefined value',
+        value: undefined,
+    };
+    try {
+        return parser(source.value);
+    }
+    catch (error) {
+        throw new PropertyParseError_1.PropertyParseError(name, source.name, error.message);
+    }
+};
+exports.parseProperty = parseProperty;

package/config/parseProperty.ts

@@ -0,0 +1,47 @@
+import { PropertyParseError } from './errors/PropertyParseError'
+import type { Parser } from '../parser/Parser'
+
+const parseProperty = <Type>(
+  name: string,
+  parser: Parser<Type>,
+  defaultValue: any,
+  fileValue: any,
+  envValue: any,
+  argsValue: any,
+): Type => {
+  const sources = [
+    {
+      name: 'command line arguments',
+      value: argsValue,
+    },
+    {
+      name: 'environment variables',
+      value: envValue,
+    },
+    {
+      name: 'configuration file',
+      value: fileValue,
+    },
+    {
+      name: 'default value',
+      value: defaultValue,
+    },
+  ]
+
+  const source = sources.find((s) => {
+    return s.value !== undefined
+  }) || {
+    name: 'undefined value',
+    value: undefined,
+  }
+
+  try {
+    return parser(source.value)
+  } catch (error) {
+    throw new PropertyParseError(name, source.name, (error as Error).message)
+  }
+}
+
+export {
+  parseProperty,
+}

package/config/readFile.d.ts

@@ -0,0 +1,2 @@
+declare const readFile: (path: string, required?: boolean) => Record<string, any>;
+export { readFile, };

package/config/readFile.js

@@ -0,0 +1,31 @@
+"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 fs_extra_1 = __importDefault(require("fs-extra"));
+const FileReadError_1 = require("./errors/FileReadError");
+const readFile = (path, required = false) => {
+    let json = {};
+    let fileExists;
+    try {
+        fileExists = fs_extra_1.default.existsSync(path);
+        if (fileExists) {
+            json = fs_extra_1.default.readJsonSync(path);
+        }
+    }
+    catch (error) {
+        throw new FileReadError_1.FileReadError(path, error.message);
+    }
+    if (required && !fileExists) {
+        throw new FileReadError_1.FileReadError(path, 'missing file');
+    }
+    if (typeof json !== 'object'
+        || Array.isArray(json)
+        || json === null) {
+        throw new FileReadError_1.FileReadError(path, 'invalid content');
+    }
+    return json;
+};
+exports.readFile = readFile;

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;