apeframework 0.0.0-dev.1 → 0.0.0-dev.10

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/api/Api.d.ts

@@ -0,0 +1,32 @@
+import type { Endpoint } from './Endpoint';
+import type { ErrorHandler } from './ErrorHandler';
+import type { Format } from './Format';
+import type { Handler } from './Handler';
+import type { OpenAPIV3 } from 'openapi-types';
+declare class Api {
+    private readonly host;
+    private readonly port;
+    private readonly server;
+    constructor(params: {
+        host: string;
+        port?: number;
+        endpoints: Endpoint[];
+        formats?: Format[];
+        openapi?: {
+            name?: string;
+            version?: string;
+        };
+        cors?: {
+            enable?: boolean;
+            origin?: string[];
+        };
+        responseValidation?: boolean;
+        onRequest?: Handler;
+        onResponse?: Handler;
+        onNotFound?: Handler;
+        onError?: ErrorHandler;
+    });
+    start(): Promise<string>;
+    openapi(): OpenAPIV3.Document;
+}
+export { Api, };

package/api/Api.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+const cors_1 = __importDefault(require("@fastify/cors"));
+const response_validation_1 = __importDefault(require("@fastify/response-validation"));
+const swagger_1 = __importDefault(require("@fastify/swagger"));
+const fastify_1 = __importDefault(require("fastify"));
+const getAjv_1 = require("./getAjv");
+class Api {
+    host;
+    port;
+    server;
+    constructor(params) {
+        this.host = params.host;
+        this.port = params.port;
+        this.server = (0, fastify_1.default)();
+        const ajv = (0, getAjv_1.getAjv)(params.formats);
+        this.server.setValidatorCompiler(({ schema }) => {
+            return ajv.compile(schema);
+        });
+        if (params.onRequest) {
+            this.server.addHook('onRequest', params.onRequest);
+        }
+        if (params.onResponse) {
+            this.server.addHook('onResponse', params.onResponse);
+        }
+        if (params.onNotFound) {
+            this.server.setNotFoundHandler(params.onNotFound);
+        }
+        if (params.onError) {
+            this.server.setErrorHandler(params.onError);
+        }
+        this.server.register(swagger_1.default, {
+            openapi: {
+                openapi: '3.1.0',
+                info: {
+                    title: params.openapi?.name ?? '',
+                    version: params.openapi?.version ?? '',
+                },
+            },
+        });
+        if (params.cors?.enable) {
+            this.server.register(cors_1.default, {
+                origin: params.cors.origin,
+            });
+        }
+        if (params.responseValidation) {
+            this.server.register(response_validation_1.default);
+        }
+        this.server.register((server, options, done) => {
+            params.endpoints.forEach((e) => {
+                server.route({
+                    url: e.path,
+                    method: e.method,
+                    schema: {
+                        summary: e.name ?? e.path,
+                        description: e.description,
+                        ...e.schema.params ? { params: e.schema.params } : {},
+                        ...e.schema.query ? { query: e.schema.query } : {},
+                        ...e.schema.headers ? { headers: e.schema.headers } : {},
+                        ...e.schema.body ? { body: e.schema.body } : {},
+                        ...e.schema.response ? { response: e.schema.response } : {},
+                    },
+                    handler: e.handler,
+                });
+            });
+            done();
+        });
+    }
+    async start() {
+        return this.server.listen({
+            host: this.host,
+            port: this.port,
+        });
+    }
+    openapi() {
+        return this.server.swagger();
+    }
+}
+exports.Api = Api;

package/api/Api.ts

@@ -0,0 +1,121 @@
+import cors from '@fastify/cors'
+import responseValidation from '@fastify/response-validation'
+import swagger from '@fastify/swagger'
+import fastify from 'fastify'
+import { getAjv } from './getAjv'
+import type { Endpoint } from './Endpoint'
+import type { ErrorHandler } from './ErrorHandler'
+import type { Format } from './Format'
+import type { Handler } from './Handler'
+import type { FastifyInstance } from 'fastify'
+import type { OpenAPIV3 } from 'openapi-types'
+
+class Api {
+  private readonly host: string
+
+  private readonly port: number | undefined
+
+  private readonly server: FastifyInstance
+
+  public constructor(params: {
+    host: string,
+    port?: number,
+    endpoints: Endpoint[],
+    formats?: Format[],
+    openapi?: {
+      name?: string,
+      version?: string,
+    },
+    cors?: {
+      enable?: boolean,
+      origin?: string[],
+    },
+    responseValidation?: boolean,
+    onRequest?: Handler,
+    onResponse?: Handler,
+    onNotFound?: Handler,
+    onError?: ErrorHandler,
+  }) {
+    this.host = params.host
+    this.port = params.port
+
+    this.server = fastify()
+
+    const ajv = getAjv(params.formats)
+
+    this.server.setValidatorCompiler(({ schema }) => {
+      return ajv.compile(schema)
+    })
+
+    if (params.onRequest) {
+      this.server.addHook('onRequest', params.onRequest)
+    }
+
+    if (params.onResponse) {
+      this.server.addHook('onResponse', params.onResponse)
+    }
+
+    if (params.onNotFound) {
+      this.server.setNotFoundHandler(params.onNotFound)
+    }
+
+    if (params.onError) {
+      this.server.setErrorHandler(params.onError)
+    }
+
+    this.server.register(swagger, {
+      openapi: {
+        openapi: '3.1.0',
+        info: {
+          title: params.openapi?.name ?? '',
+          version: params.openapi?.version ?? '',
+        },
+      },
+    })
+
+    if (params.cors?.enable) {
+      this.server.register(cors, {
+        origin: params.cors.origin,
+      })
+    }
+
+    if (params.responseValidation) {
+      this.server.register(responseValidation)
+    }
+
+    this.server.register((server, options, done) => {
+      params.endpoints.forEach((e) => {
+        server.route({
+          url: e.path,
+          method: e.method,
+          schema: {
+            summary: e.name ?? e.path,
+            description: e.description,
+            ...e.schema.params ? { params: e.schema.params } : {},
+            ...e.schema.query ? { query: e.schema.query } : {},
+            ...e.schema.headers ? { headers: e.schema.headers } : {},
+            ...e.schema.body ? { body: e.schema.body } : {},
+            ...e.schema.response ? { response: e.schema.response } : {},
+          },
+          handler: e.handler,
+        })
+      })
+      done()
+    })
+  }
+
+  public async start(): Promise<string> {
+    return this.server.listen({
+      host: this.host,
+      port: this.port,
+    })
+  }
+
+  public openapi(): OpenAPIV3.Document {
+    return this.server.swagger() as OpenAPIV3.Document
+  }
+}
+
+export {
+  Api,
+}

package/api/Endpoint.d.ts

@@ -0,0 +1,12 @@
+import type { Handler } from './Handler';
+import type { Method } from './Method';
+import type { Schema } from './Schema';
+interface Endpoint {
+    path: string;
+    method: Method;
+    name?: string;
+    description?: string;
+    schema: Schema;
+    handler: Handler;
+}
+export { type Endpoint, };

package/api/Endpoint.ts

@@ -0,0 +1,16 @@
+import type { Handler } from './Handler'
+import type { Method } from './Method'
+import type { Schema } from './Schema'
+
+interface Endpoint {
+  path: string,
+  method: Method,
+  name?: string,
+  description?: string,
+  schema: Schema,
+  handler: Handler,
+}
+
+export {
+  type Endpoint,
+}

package/api/ErrorHandler.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyError, FastifyReply, FastifyRequest } from 'fastify';
+type ErrorHandler = (error: FastifyError, request: FastifyRequest, response: FastifyReply) => Promise<void>;
+export { type ErrorHandler, };

package/api/ErrorHandler.ts

@@ -0,0 +1,11 @@
+import type { FastifyError, FastifyReply, FastifyRequest } from 'fastify'
+
+type ErrorHandler = (
+  error: FastifyError,
+  request: FastifyRequest,
+  response: FastifyReply,
+) => Promise<void>
+
+export {
+  type ErrorHandler,
+}

package/api/Format.d.ts

@@ -0,0 +1,9 @@
+import type { FormatDefinition } from 'ajv';
+type Format = NumberFormat | StringFormat;
+interface NumberFormat extends FormatDefinition<number> {
+    name: string;
+}
+interface StringFormat extends FormatDefinition<string> {
+    name: string;
+}
+export { type Format, };

package/api/Format.ts

@@ -0,0 +1,15 @@
+import type { FormatDefinition } from 'ajv'
+
+type Format = NumberFormat | StringFormat
+
+interface NumberFormat extends FormatDefinition<number> {
+  name: string,
+}
+
+interface StringFormat extends FormatDefinition<string> {
+  name: string,
+}
+
+export {
+  type Format,
+}

package/api/Handler.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyReply, FastifyRequest } from 'fastify';
+type Handler = (request: FastifyRequest, response: FastifyReply) => Promise<void>;
+export { type Handler, };

package/api/Handler.ts

@@ -0,0 +1,10 @@
+import type { FastifyReply, FastifyRequest } from 'fastify'
+
+type Handler = (
+  request: FastifyRequest,
+  response: FastifyReply,
+) => Promise<void>
+
+export {
+  type Handler,
+}

package/api/Method.d.ts

@@ -0,0 +1,8 @@
+declare enum Method {
+    DELETE = "DELETE",
+    GET = "GET",
+    PATCH = "PATCH",
+    POST = "POST",
+    PUT = "PUT"
+}
+export { Method, };

package/api/Method.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Method = void 0;
+var Method;
+(function (Method) {
+    Method["DELETE"] = "DELETE";
+    Method["GET"] = "GET";
+    Method["PATCH"] = "PATCH";
+    Method["POST"] = "POST";
+    Method["PUT"] = "PUT";
+})(Method || (exports.Method = Method = {}));

package/api/Method.ts

@@ -0,0 +1,11 @@
+enum Method {
+  DELETE = 'DELETE',
+  GET = 'GET',
+  PATCH = 'PATCH',
+  POST = 'POST',
+  PUT = 'PUT',
+}
+
+export {
+  Method,
+}

package/api/Schema.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPIV3 } from 'openapi-types';
+interface Schema {
+    params?: OpenAPIV3.SchemaObject;
+    query?: OpenAPIV3.SchemaObject;
+    headers?: OpenAPIV3.SchemaObject;
+    body?: OpenAPIV3.SchemaObject;
+    response?: Record<number, OpenAPIV3.SchemaObject>;
+}
+export { type Schema, };

package/api/Schema.ts

@@ -0,0 +1,13 @@
+import type { OpenAPIV3 } from 'openapi-types'
+
+interface Schema {
+  params?: OpenAPIV3.SchemaObject,
+  query?: OpenAPIV3.SchemaObject,
+  headers?: OpenAPIV3.SchemaObject,
+  body?: OpenAPIV3.SchemaObject,
+  response?: Record<number, OpenAPIV3.SchemaObject>,
+}
+
+export {
+  type Schema,
+}

package/api/getAjv.d.ts

@@ -0,0 +1,4 @@
+import { Ajv } from 'ajv';
+import type { Format } from './Format';
+declare const getAjv: (formats?: Format[]) => Ajv;
+export { getAjv, };

package/api/getAjv.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAjv = void 0;
+const ajv_1 = require("ajv");
+const fast_uri_1 = __importDefault(require("fast-uri"));
+const getAjv = (formats) => {
+    const ajv = new ajv_1.Ajv({
+        addUsedSchema: false,
+        allErrors: false,
+        coerceTypes: 'array',
+        removeAdditional: true,
+        uriResolver: fast_uri_1.default,
+        useDefaults: true,
+    });
+    if (formats) {
+        formats.forEach((format) => {
+            ajv.addFormat(format.name, format);
+        });
+    }
+    return ajv;
+};
+exports.getAjv = getAjv;

package/api/getAjv.ts

@@ -0,0 +1,26 @@
+import { Ajv } from 'ajv'
+import fastUri from 'fast-uri'
+import type { Format } from './Format'
+
+const getAjv = (formats?: Format[]): Ajv => {
+  const ajv = new Ajv({
+    addUsedSchema: false,
+    allErrors: false,
+    coerceTypes: 'array',
+    removeAdditional: true,
+    uriResolver: fastUri,
+    useDefaults: true,
+  })
+
+  if (formats) {
+    formats.forEach((format) => {
+      ajv.addFormat(format.name, format)
+    })
+  }
+
+  return ajv
+}
+
+export {
+  getAjv,
+}

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