apeframework 0.0.0-dev.2 → 0.0.0-dev.21

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2023 Matthieu Symoens
+Copyright (c) 2024 Matthieu Symoens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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,7 @@
+var Algorithm;
+(function (Algorithm) {
+    Algorithm["AES128"] = "aes-128-cbc";
+    Algorithm["AES192"] = "aes-192-cbc";
+    Algorithm["AES256"] = "aes-256-cbc";
+})(Algorithm || (Algorithm = {}));
+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,32 @@
+import crypto from 'crypto';
+import { DecryptError } from './errors/DecryptError';
+import { validateSecretLength } from './validateSecretLength';
+class Cipher {
+    algorithm;
+    secret;
+    constructor(params) {
+        validateSecretLength(params.algorithm, params.secret);
+        this.algorithm = params.algorithm;
+        this.secret = Buffer.from(params.secret, 'utf8');
+    }
+    encrypt(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');
+    }
+    decrypt(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.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,7 @@
+import { BaseError } from '../../error/BaseError';
+class DecryptError extends BaseError {
+    constructor(message) {
+        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,7 @@
+import { BaseError } from '../../error/BaseError';
+class SecretLengthError extends BaseError {
+    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,13 @@
+import { Algorithm } from './Algorithm';
+import { SecretLengthError } from './errors/SecretLengthError';
+const secretLength = {
+    [Algorithm.AES128]: 16,
+    [Algorithm.AES192]: 24,
+    [Algorithm.AES256]: 32,
+};
+const validateSecretLength = (algorithm, secret) => {
+    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.js

@@ -0,0 +1 @@
+export {};

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.js

@@ -0,0 +1 @@
+export {};

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,5 @@
+import { parseArgs } from './parseArgs';
+const getArgs = () => {
+    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,25 @@
+import yargsParser from 'yargs-parser';
+const parseArgs = (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._;
+    const optional = parsed;
+    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,4 @@
+const exit = (code) => {
+    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,7 @@
+import { EOL } from 'os';
+const formatList = (list) => {
+    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,19 @@
+import { EOL } from '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(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,5 @@
+import { EOL } from 'os';
+const formatText = (text) => {
+    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,4 @@
+const print = (s) => {
+    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,5 @@
+import { EOL } from 'os';
+const printLn = (s) => {
+    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.js

@@ -0,0 +1 @@
+export {};

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.js

@@ -0,0 +1 @@
+export {};

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,7 @@
+import { BaseError } from '../../error/BaseError';
+class FileReadError extends BaseError {
+    constructor(path, message) {
+        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,7 @@
+import { BaseError } from '../../error/BaseError';
+class PropertyNameError extends BaseError {
+    constructor(name) {
+        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,7 @@
+import { BaseError } from '../../error/BaseError';
+class PropertyParseError extends BaseError {
+    constructor(name, source, message) {
+        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,18 @@
+import { getPropertyEnvVar } from './getPropertyEnvVar';
+import { parseProperty } from './parseProperty';
+import { readFile } from './readFile';
+import { validatePropertyName } from './validatePropertyName';
+const getConfig = (params) => {
+    const file = params.file
+        ? 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) {
+        validatePropertyName(name);
+        config[name] = parseProperty(name, params.properties[name].parser, params.properties[name].default, file[name], env[getPropertyEnvVar(name)], args.optional[name]);
+    }
+    return config;
+};
+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,10 @@
+const capitalLetterRegex = /[A-Z]/gu;
+const capitalLetterReplacer = (letter) => {
+    return `_${letter}`;
+};
+const getPropertyEnvVar = (name) => {
+    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,34 @@
+import { PropertyParseError } from './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(name, source.name, 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,25 @@
+import fs from 'fs-extra';
+import { FileReadError } from './errors/FileReadError';
+const readFile = (path, required = false) => {
+    let json = {};
+    let fileExists;
+    try {
+        fileExists = fs.existsSync(path);
+        if (fileExists) {
+            json = fs.readJsonSync(path);
+        }
+    }
+    catch (error) {
+        throw new FileReadError(path, 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;
+};
+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,8 @@
+import { PropertyNameError } from './errors/PropertyNameError';
+const propertyNameRegex = /^[a-z](?:[0-9A-Za-z])*$/u;
+const validatePropertyName = (name) => {
+    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.js

@@ -0,0 +1 @@
+export {};

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,7 @@
+import { BaseError } from '../../error/BaseError';
+class FileReadError extends BaseError {
+    constructor(path, message) {
+        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,12 @@
+import { readFile } from './readFile';
+const getEnv = (params) => {
+    let file = {};
+    if (params?.file) {
+        file = readFile(params.file.path, params.file.required);
+    }
+    return {
+        ...file,
+        ...process.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,18 @@
+import dotenv from 'dotenv';
+import fs from 'fs-extra';
+import { FileReadError } from './errors/FileReadError';
+const readFile = (path, required = false) => {
+    try {
+        if (fs.existsSync(path)) {
+            return dotenv.parse(fs.readFileSync(path));
+        }
+    }
+    catch (error) {
+        throw new FileReadError(path, 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,9 @@
+class BaseError extends Error {
+    constructor(message) {
+        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,7 @@
+var Algorithm;
+(function (Algorithm) {
+    Algorithm["HS256"] = "HS256";
+    Algorithm["HS384"] = "HS384";
+    Algorithm["HS512"] = "HS512";
+})(Algorithm || (Algorithm = {}));
+export { Algorithm, };