minimonolith 0.11.0 → 0.12.1

package/README.md

@@ -1,3 +1,131 @@
 # minimonolith
 
-[![codecov](https://codecov.io/gh/DeepHackDev/minimonolith-lib/branch/master/graph/badge.svg?token=ORFNKKJRSE)](https://codecov.io/gh/DeepHackDev/minimonolith-lib)
+`minimonolith` is a lightweight library designed to help you build serverless APIs using AWS Lambda, with a focus on simplicity and ease of use. The library provides a straightforward structure to organize your API's services, methods, validation, and models while handling common tasks like database connection and request validation.
+
+In addition to its simplicity, `minimonolith` enables seamless inter-service communication within your API. This allows services to call one another's functionality without directly importing them, fostering a modular design. For example, you can call the get method of the todo service from the todoList service using SERVICES.todo.get({ id }). By registering services within the API, you can easily call their methods from other services, which not only promotes a clean architecture but also paves the way for future support of automated end-to-end testing.
+
+## Project Structure
+
+A typical project using `minimonolith` will have the following structure:
+
+```go
+.
+├── package.json
+├── .gitignore
+├── .env
+├── server.js                  // For local development
+├── index.js                   // Root of the code in a deployed AWS Lambda
+└── service1
+    ├── index.js               // Service1 method handlers are declared here
+    ├── model.js               // Optional: Sequelize model for Service1 is declared here
+    └── method1
+        ├── index.js           // Service1 Method1 handler is declared here
+        └── valid.js           // Optional: Method1 handler body validation, if not empty
+```
+
+## Example Project
+
+Here's an example project using `minimonolith`:
+
+```go
+.
+├── package.json
+├── .gitignore
+├── .env
+├── server.js                  // For local development
+├── index.js                   // Root of the code in a deployed AWS Lambda
+└── todo
+    ├── index.js               // Todo method handlers are declared here
+    ├── model.js               // Todo Sequelize model is declared here
+    └── get
+        ├── index.js           // /todo/get/ handler
+        └── valid.js           // /todo/get/index.js body validation
+```
+
+### server.js
+
+This file is used for local development. It runs a local server using `minimonolith`'s `runLambdaServer` function:
+
+```js
+// server.js
+import { runLambdaServer, loadEnvFile } from 'minimonolith';
+loadEnvFile(); // .env file loaded by default
+
+const lambdaRootFile = await import('./index.js');
+runLambdaServer(lambdaRootFile.lambdaHandler, 8080);
+```
+
+### index.js
+
+This file serves as the root of the code in a deployed AWS Lambda:
+
+```js
+// index.js
+'use strict';
+
+import { createAPI } from 'minimonolith';
+
+const API = createAPI();
+
+await API.registerHealthService(); // Adds health check service to route /
+await API.registerService('todo'); // Registers all /todo routes with respective method handlers
+await API.registerDatabaseService(); // Sets up the database connection
+
+export const lambdaHandler = await API.handler(); // Synchronizes Sequelize models with the database
+```
+
+### todo/index.js
+
+Here, we declare the method handlers for the `todo` service:
+
+```js
+// todo/index.js
+export const methods = ['getAll', 'get:id', 'post', 'patch:id', 'delete:id'];
+```
+
+### todo/model.js
+
+In this file, we define a Sequelize model for the `todo` service:
+
+```js
+// todo/model.js
+export const modelSchema = serviceName => (orm, types) => {
+  const schema = orm.define(serviceName, {
+    name: {
+      type: types.STRING,
+      allowNull: false
+    },
+  });
+
+  schema.associate = MODELS => {}; // e.g. MODELS.todo.belongsTo(MODELS.todoList, {...});
+
+  return schema;
+};
+```
+
+### todo/get/index.js
+
+This file contains the `get:id` method handler for the `todo` service. It retrieves a todo item by its ID:
+
+```js
+// todo/get/index.js
+export default async ({ body, MODELS }) =>  {
+  const id = parseInt(body.id);
+  return await MODELS.todo.findOne({ where: { id } });
+}
+```
+
+### todo/get/valid.js
+
+This file validates the `get:id` method's input, ensuring that the provided `id` is a string and exists in the `todo` model:
+
+```js
+// todo/get/valid.js
+import { z, DB_VALIDATION } from 'minimonolith';
+
+export default (MODELS, ROUTE_CODE) => ({
+  id: z.string().superRefine(
+    DB_VALIDATION.exists(MODELS.todo, 'id', { parseInt: true })
+  ),
+})
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "minimonolith",
   "type": "module",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "main": "index.js",
   "license": "MIT",
   "scripts": {
@@ -10,7 +10,6 @@
   },
   "dependencies": {
     "lambda-api": "^1.0.1",
-    "mysql2": "^3.2.0",
     "sequelize": "^6.30.0",
     "zod": "^3.21.4"
   },
@@ -19,6 +18,7 @@
     "@aws-sdk/s3-request-presigner": "^3.304.0",
     "dotenv": "^16.0.3",
     "jest": "^29.5.0",
+    "mysql2": "^3.2.0",
     "sqlite3": "^5.1.6"
   }
 }

package/src/database/validation.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 
 const DB_VALIDATION = {
   exists: (model, field, options=undefined) => async (rawValue, ctx) => {
-    const value = options?.parseInt ? parseInt(rawValue) : value;
+    const value = options?.parseInt ? parseInt(rawValue) : rawValue;
     const valueCount = await model.count({ where: { [field]: value } });
     if (valueCount == 0) {
       ctx.addIssue({
@@ -13,7 +13,7 @@ const DB_VALIDATION = {
   },
 
   notExists: (model, field, options=undefined) => async (rawValue, ctx) => {
-    const value = options?.parseInt ? parseInt(rawValue) : value;
+    const value = options?.parseInt ? parseInt(rawValue) : rawValue;
     const valueCount = await model.count({ where: { [field]: value } });
     if (valueCount > 0) {
       ctx.addIssue({