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

package/README.md

@@ -1,55 +1,13 @@
 # Ape Framework
 
-[Node.js](https://nodejs.org) API framework.
+[Node.js](https://nodejs.org) app framework.
 
-NPM package: [apeframework](https://www.npmjs.com/package/apeframework)
+NPM package: [apeframework](https://www.npmjs.com/package/apeframework).
 
-GitHub repository: [ApeCommerce/ape-framework](https://github.com/ApeCommerce/ape-framework)
+GitHub repository: [ApeFramework/apeframework](https://github.com/ApeFramework/apeframework).
 
 ## Installation
 
 ```
-npm install apeframework
-```
-
-## Hello Ape!
-
-Let's make an API serving a `/hello` endpoint, in TypeScript.
-
-Create a `boot.ts` file at the root of the project:
-
-```ts
-import type { Boot, Bundle } from 'apeframework/app';
-
-const welcome: Bundle = {
-  bundleId: 'welcome',
-  name: 'Welcome',
-  routes: async () => [
-    {
-      endpoint: {
-        method: 'GET',
-        path: '/hello',
-      },
-      handler: async (request, reply) => reply.send('Hello Ape!'),
-    },
-  ],
-};
-
-const boot: Boot = {
-  bundles: async () => [welcome],
-};
-
-export default boot;
-```
-
-Start the API using Ape Framework's CLI:
-
-```
-npx ape-cli-ts api start
-```
-
-Request the API:
-
-```
-curl http://localhost:3000/hello
+yarn add apeframework
 ```

package/cipher/Algorithm.d.ts

@@ -0,0 +1,6 @@
+declare enum Algorithm {
+    AES128 = "aes-128-cbc",
+    AES192 = "aes-192-cbc",
+    AES256 = "aes-256-cbc"
+}
+export { Algorithm, };

package/cipher/Algorithm.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Algorithm = void 0;
+var Algorithm;
+(function (Algorithm) {
+    Algorithm["AES128"] = "aes-128-cbc";
+    Algorithm["AES192"] = "aes-192-cbc";
+    Algorithm["AES256"] = "aes-256-cbc";
+})(Algorithm || (exports.Algorithm = Algorithm = {}));

package/cipher/Algorithm.ts

@@ -0,0 +1,9 @@
+enum Algorithm {
+  AES128 = 'aes-128-cbc',
+  AES192 = 'aes-192-cbc',
+  AES256 = 'aes-256-cbc',
+}
+
+export {
+  Algorithm,
+}

package/cipher/Cipher.d.ts

@@ -0,0 +1,12 @@
+import type { Algorithm } from './Algorithm';
+declare class Cipher {
+    private readonly algorithm;
+    private readonly secret;
+    constructor(params: {
+        algorithm: Algorithm;
+        secret: string;
+    });
+    encrypt(string: string): string;
+    decrypt(string: string): string;
+}
+export { Cipher, };

package/cipher/Cipher.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cipher = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const DecryptError_1 = require("./errors/DecryptError");
+const validateSecretLength_1 = require("./validateSecretLength");
+class Cipher {
+    algorithm;
+    secret;
+    constructor(params) {
+        (0, validateSecretLength_1.validateSecretLength)(params.algorithm, params.secret);
+        this.algorithm = params.algorithm;
+        this.secret = Buffer.from(params.secret, 'utf8');
+    }
+    encrypt(string) {
+        const iv = crypto_1.default.randomBytes(16);
+        const cipher = crypto_1.default.createCipheriv(this.algorithm, this.secret, iv);
+        return iv.toString('hex')
+            + cipher.update(string, 'utf8', 'hex')
+            + cipher.final('hex');
+    }
+    decrypt(string) {
+        const buffer = Buffer.from(string, 'hex');
+        const iv = buffer.subarray(0, 16);
+        const decipher = crypto_1.default.createDecipheriv(this.algorithm, this.secret, iv);
+        try {
+            return decipher.update(buffer.subarray(16), undefined, 'utf8')
+                + decipher.final('utf8');
+        }
+        catch (error) {
+            throw new DecryptError_1.DecryptError(error.message);
+        }
+    }
+}
+exports.Cipher = Cipher;

package/cipher/Cipher.ts

@@ -0,0 +1,46 @@
+import crypto from 'crypto'
+import { DecryptError } from './errors/DecryptError'
+import { validateSecretLength } from './validateSecretLength'
+import type { Algorithm } from './Algorithm'
+
+class Cipher {
+  private readonly algorithm: Algorithm
+
+  private readonly secret: Buffer
+
+  public constructor(params: {
+    algorithm: Algorithm,
+    secret: string,
+  }) {
+    validateSecretLength(params.algorithm, params.secret)
+
+    this.algorithm = params.algorithm
+    this.secret = Buffer.from(params.secret, 'utf8')
+  }
+
+  public encrypt(string: string): string {
+    const iv = crypto.randomBytes(16)
+    const cipher = crypto.createCipheriv(this.algorithm, this.secret, iv)
+
+    return iv.toString('hex')
+      + cipher.update(string, 'utf8', 'hex')
+      + cipher.final('hex')
+  }
+
+  public decrypt(string: string): string {
+    const buffer = Buffer.from(string, 'hex')
+    const iv = buffer.subarray(0, 16)
+    const decipher = crypto.createDecipheriv(this.algorithm, this.secret, iv)
+
+    try {
+      return decipher.update(buffer.subarray(16), undefined, 'utf8')
+        + decipher.final('utf8')
+    } catch (error) {
+      throw new DecryptError((error as Error).message)
+    }
+  }
+}
+
+export {
+  Cipher,
+}

package/cipher/errors/DecryptError.d.ts

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

package/cipher/errors/DecryptError.js

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

package/cipher/errors/DecryptError.ts

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

package/cipher/errors/SecretLengthError.d.ts

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

package/cipher/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/cipher/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/cipher/validateSecretLength.d.ts

@@ -0,0 +1,3 @@
+import { Algorithm } from './Algorithm';
+declare const validateSecretLength: (algorithm: Algorithm, secret: string) => void;
+export { validateSecretLength, };

package/cipher/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 secretLength = {
+    [Algorithm_1.Algorithm.AES128]: 16,
+    [Algorithm_1.Algorithm.AES192]: 24,
+    [Algorithm_1.Algorithm.AES256]: 32,
+};
+const validateSecretLength = (algorithm, secret) => {
+    if (Buffer.from(secret).length !== secretLength[algorithm]) {
+        throw new SecretLengthError_1.SecretLengthError();
+    }
+};
+exports.validateSecretLength = validateSecretLength;

package/cipher/validateSecretLength.ts

@@ -0,0 +1,18 @@
+import { Algorithm } from './Algorithm'
+import { SecretLengthError } from './errors/SecretLengthError'
+
+const secretLength = {
+  [Algorithm.AES128]: 16,
+  [Algorithm.AES192]: 24,
+  [Algorithm.AES256]: 32,
+}
+
+const validateSecretLength = (algorithm: Algorithm, secret: string): void => {
+  if (Buffer.from(secret).length !== secretLength[algorithm]) {
+    throw new SecretLengthError()
+  }
+}
+
+export {
+  validateSecretLength,
+}

package/cli/Args.d.ts

@@ -0,0 +1,5 @@
+interface Args {
+    positional: string[];
+    optional: Record<string, boolean | string | undefined>;
+}
+export { type Args, };

package/cli/Args.ts

@@ -0,0 +1,8 @@
+interface Args {
+  positional: string[],
+  optional: Record<string, boolean | string | undefined>,
+}
+
+export {
+  type Args,
+}

package/cli/Command.d.ts

@@ -0,0 +1,3 @@
+import type { Args } from './Args';
+type Command = (args: Args) => Promise<void>;
+export { type Command, };

package/cli/Command.ts

@@ -0,0 +1,7 @@
+import type { Args } from './Args'
+
+type Command = (args: Args) => Promise<void>
+
+export {
+  type Command,
+}

package/cli/getArgs.d.ts

@@ -0,0 +1,3 @@
+import type { Args } from './Args';
+declare const getArgs: () => Args;
+export { getArgs, };

package/cli/getArgs.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgs = void 0;
+const parseArgs_1 = require("./parseArgs");
+const getArgs = () => {
+    return (0, parseArgs_1.parseArgs)(process.argv.slice(2));
+};
+exports.getArgs = getArgs;

package/cli/getArgs.ts

@@ -0,0 +1,10 @@
+import { parseArgs } from './parseArgs'
+import type { Args } from './Args'
+
+const getArgs = (): Args => {
+  return parseArgs(process.argv.slice(2))
+}
+
+export {
+  getArgs,
+}

package/cli/parseArgs.d.ts

@@ -0,0 +1,3 @@
+import type { Args } from './Args';
+declare const parseArgs: (args: string[]) => Args;
+export { parseArgs, };

package/cli/parseArgs.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.parseArgs = void 0;
+const yargs_parser_1 = __importDefault(require("yargs-parser"));
+const parseArgs = (args) => {
+    const parsed = (0, yargs_parser_1.default)(args, {
+        configuration: {
+            'boolean-negation': false,
+            'camel-case-expansion': true,
+            'dot-notation': false,
+            'duplicate-arguments-array': false,
+            'flatten-duplicate-arrays': false,
+            'greedy-arrays': false,
+            'parse-numbers': false,
+            'parse-positional-numbers': false,
+            'short-option-groups': true,
+            'strip-dashed': true,
+        },
+    });
+    const positional = parsed._;
+    const optional = parsed;
+    delete optional._;
+    return {
+        positional,
+        optional,
+    };
+};
+exports.parseArgs = parseArgs;

package/cli/parseArgs.ts

@@ -0,0 +1,34 @@
+import yargsParser from 'yargs-parser'
+import type { Args } from './Args'
+
+const parseArgs = (args: string[]): Args => {
+  const parsed = yargsParser(args, {
+    configuration: {
+      'boolean-negation': false,
+      'camel-case-expansion': true,
+      'dot-notation': false,
+      'duplicate-arguments-array': false,
+      'flatten-duplicate-arrays': false,
+      'greedy-arrays': false,
+      'parse-numbers': false,
+      'parse-positional-numbers': false,
+      'short-option-groups': true,
+      'strip-dashed': true,
+    },
+  })
+
+  const positional = parsed._ as string[]
+
+  const optional = parsed as Record<string, boolean | string | undefined>
+
+  delete optional._
+
+  return {
+    positional,
+    optional,
+  }
+}
+
+export {
+  parseArgs,
+}

package/cli/utils/exit.d.ts

@@ -0,0 +1,2 @@
+declare const exit: (code?: number) => void;
+export { exit, };

package/cli/utils/exit.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exit = void 0;
+const exit = (code) => {
+    process.exit(code);
+};
+exports.exit = exit;

package/cli/utils/exit.ts

@@ -0,0 +1,7 @@
+const exit = (code?: number): void => {
+  process.exit(code)
+}
+
+export {
+  exit,
+}

package/cli/utils/formatList.d.ts

@@ -0,0 +1,2 @@
+declare const formatList: (list: string[]) => string;
+export { formatList, };

package/cli/utils/formatList.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatList = void 0;
+const os_1 = require("os");
+const formatList = (list) => {
+    return list
+        .map((item) => { return `  ${item}`; })
+        .join(os_1.EOL);
+};
+exports.formatList = formatList;

package/cli/utils/formatList.ts

@@ -0,0 +1,11 @@
+import { EOL } from 'os'
+
+const formatList = (list: string[]): string => {
+  return list
+    .map((item) => { return `  ${item}` })
+    .join(EOL)
+}
+
+export {
+  formatList,
+}

package/cli/utils/formatTable.d.ts

@@ -0,0 +1,2 @@
+declare const formatTable: (table: string[][]) => string;
+export { formatTable, };

package/cli/utils/formatTable.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatTable = void 0;
+const os_1 = require("os");
+const formatTable = (table) => {
+    const colLength = [];
+    table.forEach((row) => {
+        ['', ...row].forEach((col, i) => {
+            colLength[i] = col.length > (colLength[i] ?? 0)
+                ? col.length
+                : colLength[i] ?? 0;
+        });
+    });
+    return table
+        .map((row) => {
+        return ['', ...row]
+            .map((col, i) => { return col.padEnd(colLength[i], ' '); })
+            .join('  ');
+    })
+        .join(os_1.EOL);
+};
+exports.formatTable = formatTable;

package/cli/utils/formatTable.ts

@@ -0,0 +1,25 @@
+import { EOL } from 'os'
+
+const formatTable = (table: string[][]): string => {
+  const colLength: number[] = []
+
+  table.forEach((row) => {
+    ['', ...row].forEach((col, i) => {
+      colLength[i] = col.length > (colLength[i] ?? 0)
+        ? col.length
+        : colLength[i] ?? 0
+    })
+  })
+
+  return table
+    .map((row) => {
+      return ['', ...row]
+        .map((col, i) => { return col.padEnd(colLength[i], ' ') })
+        .join('  ')
+    })
+    .join(EOL)
+}
+
+export {
+  formatTable,
+}

package/cli/utils/formatText.d.ts

@@ -0,0 +1,2 @@
+declare const formatText: (text: string[]) => string;
+export { formatText, };

package/cli/utils/formatText.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatText = void 0;
+const os_1 = require("os");
+const formatText = (text) => {
+    return text.join(os_1.EOL);
+};
+exports.formatText = formatText;

package/cli/utils/formatText.ts

@@ -0,0 +1,9 @@
+import { EOL } from 'os'
+
+const formatText = (text: string[]): string => {
+  return text.join(EOL)
+}
+
+export {
+  formatText,
+}

package/cli/utils/print.d.ts

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

package/cli/utils/print.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.print = void 0;
+const print = (s) => {
+    process.stdout.write(s);
+};
+exports.print = print;

package/cli/utils/print.ts

@@ -0,0 +1,7 @@
+const print = (s: string): void => {
+  process.stdout.write(s)
+}
+
+export {
+  print,
+}

package/cli/utils/printLn.d.ts

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

package/cli/utils/printLn.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printLn = void 0;
+const os_1 = require("os");
+const printLn = (s) => {
+    process.stdout.write(`${s}${os_1.EOL}`);
+};
+exports.printLn = printLn;

package/cli/utils/printLn.ts

@@ -0,0 +1,9 @@
+import { EOL } from 'os'
+
+const printLn = (s: string): void => {
+  process.stdout.write(`${s}${EOL}`)
+}
+
+export {
+  printLn,
+}

package/config/Config.d.ts

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

package/config/Config.ts

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

package/config/Properties.d.ts

@@ -0,0 +1,8 @@
+import type { Parser } from '../parser/Parser';
+type Properties<Type> = {
+    [Property in keyof Type]: {
+        parser: Parser<Type[Property]>;
+        default?: any;
+    };
+};
+export { type Properties, };

package/config/Properties.ts

@@ -0,0 +1,12 @@
+import type { Parser } from '../parser/Parser'
+
+type Properties<Type> = {
+  [Property in keyof Type]: {
+    parser: Parser<Type[Property]>,
+    default?: any,
+  }
+}
+
+export {
+  type Properties,
+}

package/config/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/config/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;