apeframework 0.0.0-dev.3 → 0.0.0-dev.4

package/README.md

@@ -11,17 +11,3 @@ GitHub repository: [ApeFramework/apeframework](https://github.com/ApeFramework/a
 ```
 npm install apeframework
 ```
-
-## Development
-
-Deploy dev stack:
-
-```
-docker compose up
-```
-
-Get a shell from the Node.js container:
-
-```
-docker compose exec node bash
-```

package/api/Api.d.ts

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

package/api/Api.js

@@ -0,0 +1,72 @@
+"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"));
+class Api {
+    host;
+    port;
+    server;
+    constructor(params) {
+        this.host = params.host;
+        this.port = params.port;
+        this.server = (0, fastify_1.default)();
+        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?.title ?? '',
+                    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);
+        }
+        params.endpoints.forEach((e) => {
+            this.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,
+            });
+        });
+    }
+    async start() {
+        return this.server.listen({
+            host: this.host,
+            port: this.port,
+        });
+    }
+}
+exports.Api = Api;

package/api/Api.ts

@@ -0,0 +1,104 @@
+import cors from '@fastify/cors'
+import responseValidation from '@fastify/response-validation'
+import swagger from '@fastify/swagger'
+import fastify from 'fastify'
+import type { Endpoint } from './Endpoint'
+import type { ErrorHandler } from './ErrorHandler'
+import type { Handler } from './Handler'
+import type { FastifyInstance } from 'fastify'
+
+class Api {
+  private readonly host: string
+
+  private readonly port: number | undefined
+
+  private readonly server: FastifyInstance
+
+  public constructor(params: {
+    host: string,
+    port?: number,
+    endpoints: Endpoint[],
+    onRequest?: Handler,
+    onResponse?: Handler,
+    onNotFound?: Handler,
+    onError?: ErrorHandler,
+    openapi?: {
+      title?: string,
+      version?: string,
+    },
+    cors?: {
+      enable?: boolean,
+      origin?: string[],
+    },
+    responseValidation?: boolean,
+  }) {
+    this.host = params.host
+    this.port = params.port
+
+    this.server = fastify()
+
+    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?.title ?? '',
+          version: params.openapi?.version ?? '',
+        },
+      },
+    })
+
+    if (params.cors?.enable) {
+      this.server.register(cors, {
+        origin: params.cors.origin,
+      })
+    }
+
+    if (params.responseValidation) {
+      this.server.register(responseValidation)
+    }
+
+    params.endpoints.forEach((e) => {
+      this.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,
+      })
+    })
+  }
+
+  public async start(): Promise<string> {
+    return this.server.listen({
+      host: this.host,
+      port: this.port,
+    })
+  }
+}
+
+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/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/cipher/Cipher.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cipher = void 0;
 const crypto_1 = __importDefault(require("crypto"));
-const CipherDecryptError_1 = require("./errors/CipherDecryptError");
+const DecryptError_1 = require("./errors/DecryptError");
 const validateSecretLength_1 = require("./validateSecretLength");
 class Cipher {
     algorithm;
@@ -31,7 +31,7 @@ class Cipher {
                 + decipher.final('utf8');
         }
         catch (error) {
-            throw new CipherDecryptError_1.CipherDecryptError(error.message);
+            throw new DecryptError_1.DecryptError(error.message);
         }
     }
 }

package/cipher/Cipher.ts

@@ -1,5 +1,5 @@
 import crypto from 'crypto'
-import { CipherDecryptError } from './errors/CipherDecryptError'
+import { DecryptError } from './errors/DecryptError'
 import { validateSecretLength } from './validateSecretLength'
 import type { Algorithm } from './Algorithm'
 
@@ -36,7 +36,7 @@ class Cipher {
       return decipher.update(buffer.subarray(16), undefined, 'utf8')
         + decipher.final('utf8')
     } catch (error) {
-      throw new CipherDecryptError((error as Error).message)
+      throw new DecryptError((error as Error).message)
     }
   }
 }

package/cipher/errors/{CipherDecryptError.d.ts → DecryptError.d.ts}

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

package/cipher/errors/{CipherDecryptError.js → DecryptError.js}

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

package/cipher/errors/{CipherDecryptError.ts → DecryptError.ts}

@@ -1,11 +1,11 @@
 import { BaseError } from '../../error/BaseError'
 
-class CipherDecryptError extends BaseError {
+class DecryptError extends BaseError {
   public constructor(message: string) {
     super(`failed decrypting string: ${message}`)
   }
 }
 
 export {
-  CipherDecryptError,
+  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/{jwt/errors/JwtSecretLengthError.js → cipher/errors/SecretLengthError.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtSecretLengthError = void 0;
+exports.SecretLengthError = void 0;
 const BaseError_1 = require("../../error/BaseError");
-class JwtSecretLengthError extends BaseError_1.BaseError {
+class SecretLengthError extends BaseError_1.BaseError {
     constructor() {
         super('invalid secret length');
     }
 }
-exports.JwtSecretLengthError = JwtSecretLengthError;
+exports.SecretLengthError = SecretLengthError;

package/{jwt/errors/JwtSecretLengthError.ts → cipher/errors/SecretLengthError.ts}

@@ -1,11 +1,11 @@
 import { BaseError } from '../../error/BaseError'
 
-class JwtSecretLengthError extends BaseError {
+class SecretLengthError extends BaseError {
   public constructor() {
     super('invalid secret length')
   }
 }
 
 export {
-  JwtSecretLengthError,
+  SecretLengthError,
 }

package/cipher/validateSecretLength.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateSecretLength = void 0;
 const Algorithm_1 = require("./Algorithm");
-const CipherSecretLengthError_1 = require("./errors/CipherSecretLengthError");
+const SecretLengthError_1 = require("./errors/SecretLengthError");
 const secretLength = {
     [Algorithm_1.Algorithm.AES128]: 16,
     [Algorithm_1.Algorithm.AES192]: 24,
@@ -10,7 +10,7 @@ const secretLength = {
 };
 const validateSecretLength = (algorithm, secret) => {
     if (Buffer.from(secret).length !== secretLength[algorithm]) {
-        throw new CipherSecretLengthError_1.CipherSecretLengthError();
+        throw new SecretLengthError_1.SecretLengthError();
     }
 };
 exports.validateSecretLength = validateSecretLength;

package/cipher/validateSecretLength.ts

@@ -1,5 +1,5 @@
 import { Algorithm } from './Algorithm'
-import { CipherSecretLengthError } from './errors/CipherSecretLengthError'
+import { SecretLengthError } from './errors/SecretLengthError'
 
 const secretLength = {
   [Algorithm.AES128]: 16,
@@ -9,7 +9,7 @@ const secretLength = {
 
 const validateSecretLength = (algorithm: Algorithm, secret: string): void => {
   if (Buffer.from(secret).length !== secretLength[algorithm]) {
-    throw new CipherSecretLengthError()
+    throw new SecretLengthError()
   }
 }
 

package/cli/utils/print.d.ts

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

package/cli/utils/{write.js → print.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.write = void 0;
-const write = (s) => {
+exports.print = void 0;
+const print = (s) => {
     process.stdout.write(s);
 };
-exports.write = write;
+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/{writeLn.js → printLn.js}

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

package/cli/utils/{writeLn.ts → printLn.ts}

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

package/{env/errors/EnvFileReadError.d.ts → config/errors/FileReadError.d.ts}

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

package/{tls/errors/TlsFileReadError.js → config/errors/FileReadError.js}

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

package/{env/errors/EnvFileReadError.ts → config/errors/FileReadError.ts}

@@ -1,11 +1,11 @@
 import { BaseError } from '../../error/BaseError'
 
-class EnvFileReadError extends BaseError {
+class FileReadError extends BaseError {
   public constructor(path: string, message: string) {
     super(`failed reading file "${path}": ${message}`)
   }
 }
 
 export {
-  EnvFileReadError,
+  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/{ConfigPropertyNameError.js → PropertyNameError.js}

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

package/config/errors/{ConfigPropertyNameError.ts → PropertyNameError.ts}

@@ -1,11 +1,11 @@
 import { BaseError } from '../../error/BaseError'
 
-class ConfigPropertyNameError extends BaseError {
+class PropertyNameError extends BaseError {
   public constructor(name: string) {
     super(`invalid property name "${name}"`)
   }
 }
 
 export {
-  ConfigPropertyNameError,
+  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,
+}