minimonolith 0.25.24 → 0.26.3

package/README.md

@@ -18,12 +18,10 @@ Here's an example project using `minimonolith`:
 ├── server.js                  // For local development
 ├── index.js                   // Root of the code in a deployed AWS Lambda
 └── todo
-    ├── services.js            // Module 'todo' exported services  are declared here
-    ├── model.js               // Optional: Sequelize model for module 'todo' is declared here
+    ├── index.js               // Service 'todo' exported method handlers are declared here
+    ├── model.js               // Optional: Sequelize model for service 'todo' is declared here
     └── get
-        ├── handler.js         // Module 'todo' service 'get' handler
-        └── in.js           // Optional: Service 'get' input validation, if body not empty
-        └── out.js           // Optional: Service 'get' output validation, if body not empty
+        └─── handler.js         // Service 'todo' method 'get' handler
 ```
 
 ### server.js
@@ -34,10 +32,15 @@ This file is used for local development. It runs a local server using `minimonol
 // server.js
 import { getServerFactory } from 'minimonolith';
 
-const getServer = await getServerFactory()(;
+import dotenv from 'dotenv';
+dotenv.config({ path: './.env' })
+
 const { lambdaHandler } = await import('./index.js');
 
-getServer(lambdaHandler).listen(8080);
+const serverFactory = await getServerFactory();
+
+const server = serverFactory(lambdaHandler);
+server.listen(8080);
 ```
 
 ### index.js
@@ -46,17 +49,16 @@ This file serves as the root of the code in a deployed AWS Lambda:
 
 ```js
 // index.js
+
 'use strict';
 
 import { getNewAPI } from 'minimonolith';
 
-const API = getNewAPI({
-  PROD_ENV: process.env.PROD_ENV,
-  DEV_ENV: process.env.DEV_ENV,
-});
+import todo from './todo/index.js';
 
-await API.postHealthService();
-await API.postModule('todo');
+const API = await getNewAPI();
+
+await API.postService(todo.name, todo.service, todo.model);
 await API.postDatabaseService({
   DB_DIALECT: process.env.DB_DIALECT,
   DB_HOST: process.env.DB_HOST,
@@ -64,6 +66,7 @@ await API.postDatabaseService({
   DB_DB: process.env.DB_DB,
   DB_USER: process.env.DB_USER,
   DB_PASS: process.env.DB_PASS,
+  DB_STORAGE: process.env.DB_STORAGE,
 });
 
 export const lambdaHandler = await API.getSyncedHandler();
@@ -71,28 +74,52 @@ export const lambdaHandler = await API.getSyncedHandler();
 
 ### todo/index.js
 
-Here, we declare the service routes for the `todo` module:
+Here, we declare the method handlers for the `todo` service:
 
 ```js
-// todo/services.js
-export default ['getAll', 'get:id', 'post', 'patch:id', 'delete:id'];
+// todo/index.js
+
+import get from './get/handler.js';
+import getOne from './getOne/handler.js';
+import post from './post/handler.js';
+import patch from './patch/handler.js';
+import deleteTodo from './delete/handler.js';
+import model from './model.js';
+
+export default {
+    name: 'todo',
+    service: {
+        'get': get,
+        'post': post,
+        'patch:id': patch,·
+        'delete:id': deleteTodo,
+    },
+    model,
+};
 ```
 
 ### todo/model.js
 
-In this file, we define a Sequelize model for the `todo` module:
+In this file, we define a Sequelize model for the `todo` service:
 
 ```js
 // todo/model.js
-export default moduleName => (orm, types) => {
-  const schema = orm.define(moduleName, {
+export default serviceName => (orm, types) => {
+  const schema = orm.define(serviceName, {
     name: {
       type: types.STRING,
       allowNull: false
     },
   });
 
-  schema.associate = MODELS => {}; // e.g. MODELS.todo.belongsTo(MODELS.todoList, {...});
+  schema.associate = MODELS => {
+    /*
+    schema.belongsTo(MODELS.todoList, {
+      foreignKey: 'todoListId',
+      as: 'todoList'
+    });
+    */
+  };
 
   return schema;
 };
@@ -100,29 +127,19 @@ export default moduleName => (orm, types) => {
 
 ### todo/get/index.js
 
-This file contains the `get:id` route for the `todo` module. It retrieves a todo item by its ID:
+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 }) =>  {
-  return await MODELS.todo.findOne({ where: { id: body.id } });
-}
-```
 
-### todo/get/in.js
+export default async ({ body, MODELS }) =>  {
+  const id = body.id;
 
-This file validates the `get:id` service's input, ensuring that the provided `id` is a string and exists in the `todo` model:
+  const todo = await MODELS.todo.findOne({ where: { id } });
+  const todoJSON = todo.toJSON();
 
-```js
-// todo/get/in.js
-import { z, zdb } from 'minimonolith';
-
-export default ({ MODELS }) => ({
-  id: z.string()
-    .superRefine(zdb.getIsSafeInt('id'))
-    .transform(id => parseInt(id))
-    .superRefine(zdb.getExists(MODELS.todo, 'id')),
-})
+  return { body: todoJSON };
+}
 ```
 
 ## Response Codes
@@ -132,45 +149,12 @@ export default ({ MODELS }) => ({
 - POST -> 201
 - DELETE -> 204
 - Everything else -> 200
-
-### Invalid Request
-
-- ANY -> 400
+- Custom -> status value in handler.js return statement
 
 ### Runtime Error
 
 - ANY -> 500
 
-## App Environments
-
-There are 4 possible environments:
-1. DEV=TRUE + PROD=FALSE: This is the standard DEV environment
-2. DEV=FALSE + PROD=FALSE: This is the standard QA environment
-3. DEV=FALSE + PROD=TRUE: This is the stnadard PROD environment
-4. DEV=TRUE + PROD=TRUE: This allows to test the behavior of PROD within the "new concept" of DEV environment
-
-To better understand their relevance:
-1. The "new concept" DEV environments (DEV=TRUE) aim to make the api crash if an "important" error happens
-  - Its current only difference is it makes it crash on error at service registration phase
-  - Some may think QA should also fail on "important" errors They can use DEV=TRUE there But some do training activities on QA that must be minimally disrupted
-2. The "new concept" QA environments (PROD=FALSE) aim at logging data about the system which on production environments would be forbiden personal information
-  - This is relevant because replication of QA activities (even security QA activities) depend heavily on this
-
-The current App environment is determined on the values of DEV ENV [TRUE/FALSE] and PROD_ENV [TRUE/FALSE]
-Assuming using same env variables as used at index.js above
-
-```makefile
-# .env standard dev environment
-DEV_ENV=TRUE
-PROD_ENV=FALSE
-TEST_ENV=FALSE
-[...]
-```
-
-*NOTICE*: Default environment it is assumed standard PROD environment (DEV=FLASE + PROD=TRUE)
-- This means that sequelize will not alter automatically tables having mismatches with defined model.js files
-- Database dialect/credentials detected will not be printed
-- Critical errors will not make the app crash
 
 ## Database Authentication
 
@@ -193,17 +177,7 @@ DB_PASS=<your_database_password>
 For SQLite in memory:
 
 ```makefile
-DEV_ENV=TRUE
-PROD_ENV=FALSE
 DB_DIALECT=sqlite
 DB_DB=<your_database_name>
 DB_STORAGE=:memory: # Need to also pass to API.postDatabaseService()
 ```
-
-Make sure to replace the placeholders with your actual database credentials.
-- `DEV_ENV=TRUE` allows Sequelize to alter table structure automatically when working locally
-- `PROD_ENV=FALSE` allows logging of DB credentials for debugging purposes in non-production environments
-  - We consider high quality logging important for app performance and evolution
-  - However we recommend automatic DB credentials updates (daily) High quality logging does not mean
-    giving away your infraestructure to hackers
-  - At the risk of stating the obvious do not store personal information at the QA database

package/backtest/back.js

@@ -0,0 +1,54 @@
+import { jest } from '@jest/globals';
+import { postTestEnvironment, getTestServer } from '../index.js';
+
+test('todo ok', async () => {
+  postTestEnvironment();
+  const { lambdaHandler } = await import('./handler.js');
+
+  const testMethod = async params => {
+    const event = {
+      path: params.path, httpMethod: params.method,
+      body: params.body ? JSON.stringify(params.body) : undefined,
+      querySgringParameters: params.queryStringParameters,
+      requestContext: {}, headers: {},
+    };
+
+    const response = await lambdaHandler(event);
+    expect(response.statusCode).toBe(200);
+  }
+
+  await testMethod({ path: '/', method: 'GET' });
+  await testMethod({ path: '/postSeed/todo', method: 'POST' });
+  await testMethod({ path: '/todo/get', method: 'GET' });
+  await testMethod({ path: '/todo/post', method: 'POST', body:{name:'n'}});
+  await testMethod({ path: '/todo/getOne/1', method: 'GET', queryStringParameters:{id:'1'}});
+  await testMethod({ path: '/todo/patch/1', method: 'PATCH', queryStringParameters:{id:'1'}, body:{name: 'm'}});
+  await testMethod({ path: '/todo/delete/1', method: 'DELETE', queryStringParameters:{id:'1'}});
+});
+
+test('todo invalid', async () => {
+  postTestEnvironment();
+  const { lambdaHandler } = await import('./handler.js');
+
+  const testMethod = async params => {
+    const event = {
+      path: params.path, httpMethod: params.method,
+      body: params.body ? JSON.stringify(params.body) : undefined,
+      querySgringParameters: params.queryStringParameters,
+      requestContext: {}, headers: {},
+    };
+
+    const response = await lambdaHandler(event);
+    expect(response.statusCode).toBe(400);
+  }
+
+  await testMethod({ path: '/todo/post', method: 'POST', body:{name:1}});
+});
+
+test('todo compiletime error', async () => {
+  postTestEnvironment();
+
+  await expect(async () => {
+    await import('./handlerCompiletimeError.js')
+  }).rejects.toThrow();
+});

package/backtest/backtest.js

@@ -0,0 +1,131 @@
+import { jest } from '@jest/globals';
+import http from 'http';
+import url from 'url';
+import path from 'path';
+
+import { getServerFactory, getMethodTest } from '../index.js';
+import postConnection from '../src/database/postConnection/index.js';
+
+beforeEach(() => {
+  jest.spyOn(console, 'log').mockImplementation(() => {});
+  jest.spyOn(console, 'error').mockImplementation(() => {});
+});
+
+afterEach(() => {
+  console.log.mockRestore();
+  console.error.mockRestore();
+});
+
+describe('postConnection', () => {
+  const mockORMSuccess = { authenticate: jest.fn().mockResolvedValue(true) };
+  const mockORMFail = { authenticate: jest.fn().mockRejectedValue(new Error('AUTHENTICATION_FAILED')) };
+
+  test('successfully authenticates', async () => {
+    const retries = await postConnection(mockORMSuccess);
+
+    expect(mockORMSuccess.authenticate).toHaveBeenCalledTimes(1);
+    expect(retries).toBe(0);
+  });
+
+  test('retries when authentication fails', async () => {
+    const retries = await postConnection(mockORMFail);
+
+    expect(mockORMFail.authenticate).toHaveBeenCalledTimes(5);
+    expect(retries).toBe(5);
+  });
+});
+
+describe('end-to-end requests', () => {
+  let getServer, server;
+
+  beforeAll(async () => {
+    getServer = await getServerFactory(path.join('test', '.env.test'), 'src' + path.sep);
+  });
+
+  beforeEach(async () => {
+    const { lambdaHandler } = await import('./handler.js');
+    server = getServer(lambdaHandler);
+    server.listen(0);
+  });
+
+  afterEach(async () => {
+    server.close();
+  });
+
+  test('successful codes', async () => {
+
+    const testMethod = await getMethodTest(server);
+    await testMethod({ path: '/', method: 'OPTIONS', expectedCode: 200,
+      headers: { 'authorization': 'Bearer '+ [
+        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
+        'eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ',
+        'SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
+      ].join('.') } });
+
+    await testMethod({ path: '/', method: 'GET', expectedCode: 200 });
+    await testMethod({ path: '/postSeed/todo', method: 'POST', expectedCode: 201 });
+    await testMethod({ path: '/todo/get', method: 'GET', expectedCode: 200 });
+    await testMethod({ path: '/todo/getAttributes?name=n', method: 'GET', expectedCode: 200 });
+    await testMethod({ path: '/todo/post', method: 'POST', expectedCode: 201,
+      headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 'n' }) });
+    await testMethod({ path: '/todo/getAttributes', method: 'GET', expectedCode: 200 });
+    await testMethod({ path: '/todo/getAttributes?name=n', method: 'GET', expectedCode: 200 });
+    await testMethod({ path: '/todo/getOne/1', method: 'GET', expectedCode: 200 });
+    await testMethod({ path: '/todo/getOneAlias/1', method: 'GET', expectedCode: 200 });
+    await testMethod({ path: '/todo/patch/1', method: 'PATCH', expectedCode: 200,
+      headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 'm' }) });
+    await testMethod({ path: '/todo/delete/1', method: 'DELETE', expectedCode: 204 });
+  });
+
+  test('invalid requests', async () => {
+    const testMethod = await getMethodTest(server);
+    await testMethod({ path: '/postSeed/todo', method: 'POST', expectedCode: 400,
+      headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 1 }) });
+    await testMethod({ path: '/todo/post', method: 'POST', expectedCode: 400,
+      headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 1 }) });
+    await testMethod({ path: '/todo/delete/1', method: 'DELETE', expectedCode: 400 });
+    await testMethod({ path: '/todo/delete/n', method: 'DELETE', expectedCode: 400});
+
+    const testMethodSuccess = await getMethodTest(server);
+    await testMethodSuccess({ path: '/todo/post', method: 'POST', expectedCode: 201,
+      headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 'i' }) });
+    await testMethod({ path: '/todo/post', method: 'POST', expectedCode: 400,
+      headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name: 'i' }) });
+  });
+
+  test('wrong header error code', async () => {
+    const testMethod = await getMethodTest(server);
+    //await testMethod({ path: '/todo/get', method: 'GET', headers: { accept: {} } });
+    await testMethod({ path: '/', method: 'OPTIONS', expectedCode: 500,
+      headers: { 'x-trigger-error': 'TRUE' } });
+  });
+
+  test('wrong jwt error code', async () => {
+    const testMethod = await getMethodTest(server);
+    await testMethod({ path: '/', method: 'OPTIONS', expectedCode: 500,
+      headers: { authorization: 'Bearer ERROR' } });
+  });
+});
+
+
+test('throwing method runtime error', async () => {
+  const getServer = await getServerFactory(path.join('test', '.env.test'), 'src' + path.sep);
+  const { lambdaHandler } = await import('./indexRuntimeError.js');
+  const server = getServer(lambdaHandler);
+  server.listen(0);
+
+  const methodWithError = (await import('./todoRuntimeError/get/handler.js')).default;
+  await expect(methodWithError()).rejects.toThrow();
+  const testMethod = await getMethodTest(server);
+  await testMethod({ path: '/todoRuntimeError/get', method: 'GET', expectedCode: 500 });
+
+  server.close();
+});
+
+test('not existent method type compiletime error', async () => {
+  await expect(async () => { await import('./indexCompiletimeError.js') }).rejects.toThrow();
+})
+
+test('not existent module folder compiletime error', async () => {
+  await expect(async () => { await import('./indexCompiletimeError2.js') }).rejects.toThrow();
+})

package/backtest/handler.js

@@ -0,0 +1,23 @@
+'use strict';
+
+import { getNewAPI } from '../index.js';
+import path from 'path';
+
+const API = await getNewAPI({
+  PROD_ENV: process.env.PROD_ENV,
+  DEV_ENV: process.env.DEV_ENV,
+});
+
+await API.postHealthService();
+await API.postService('todo', 'test' + path.sep, 'src' + path.sep);
+await API.postDatabaseService({
+  DB_DIALECT: process.env.DB_DIALECT,
+  DB_HOST: process.env.DB_HOST,
+  DB_PORT: process.env.DB_PORT,
+  DB_DB: process.env.DB_DB,
+  DB_USER: process.env.DB_USER,
+  DB_PASS: process.env.DB_PASS,
+  DB_STORAGE: process.env.DB_STORAGE,
+});
+
+export const lambdaHandler = await API.getSyncedHandler();

package/backtest/handlerCompiletimeError.js

@@ -0,0 +1,10 @@
+'use strict';
+
+import { getNewAPI } from '../index.js';
+import path from 'path';
+
+const API = await getNewAPI({
+  PROD_ENV: process.env.PROD_ENV,
+  DEV_ENV: process.env.DEV_ENV,
+});
+await API.postService('todoCompiletimeError', 'test'+path.sep, 'src'+path.sep);

package/backtest/handlerCompiletimeError2.js

@@ -0,0 +1,10 @@
+'use strict';
+
+import { getNewAPI } from '../index.js';
+import path from 'path';
+
+const API = await getNewAPI({
+  PROD_ENV: process.env.PROD_ENV,
+  DEV_ENV: process.env.DEV_ENV,
+});
+await API.postService('todoCompiletimeError', 'test' + path.sep, 'src2' + path.sep);

package/backtest/handlerRuntimeError.js

@@ -0,0 +1,24 @@
+'use strict';
+
+import { getNewAPI } from '../index.js';
+import path from 'path';
+
+const API = await getNewAPI({
+  PROD_ENV: process.env.PROD_ENV,
+  DEV_ENV: process.env.DEV_ENV,
+});
+
+await API.postHealthService();
+await API.postService('todoRuntimeError', 'test' + path.sep, 'src' + path.sep);
+
+await API.postDatabaseService({
+  DB_DIALECT: process.env.DB_DIALECT,
+  DB_HOST: process.env.DB_HOST,
+  DB_PORT: process.env.DB_PORT,
+  DB_DB: process.env.DB_DB,
+  DB_USER: process.env.DB_USER,
+  DB_PASS: process.env.DB_PASS,
+  DB_STORAGE: process.env.DB_STORAGE,
+});
+
+export const lambdaHandler = await API.getSyncedHandler();

package/backtest/localDocker/Dockerfile

@@ -0,0 +1,11 @@
+FROM node:12-alpine
+WORKDIR /usr/src
+
+COPY package.json ./
+COPY yarn.lock ./
+
+RUN yarn install
+
+COPY . .
+
+CMD [ "yarn", "start:development" ]

package/backtest/localDocker/docker-compose.yml

@@ -0,0 +1,34 @@
+version: '3'
+
+services:
+  db:
+    container_name: ${DB_CONTAINER_NAME}
+    image: mysql:5.7
+    restart: always
+    environment:
+      MYSQL_ROOT_PASSWORD: ${MM_API_DB_PASS}
+      MYSQL_DATABASE: ${MM_API_DB_DB}
+    ports: ["${MM_API_DB_PORT}:3306"]
+    networks: [todo]
+    command: mysqld --sql_mode=""
+  api:
+    container_name: ${API_CONTAINER_NAME}
+    build: { context: .., dockerfile: ./localDocker/Dockerfile }
+    volumes: [..:/usr/src, /usr/src/node_modules]
+    ports: [8080:8080, 9229:9229]
+    environment:
+      MM_API_DB_HOST: ${MM_API_DB_HOST}
+      MM_API_DB_DB: ${MM_API_DB_DB}
+      MM_API_DB_USER: ${MM_API_DB_USER}
+      MM_API_DB_PASS: ${MM_API_DB_PASS}
+      MM_API_DEV_ENV: ${MM_API_DEV_ENV}
+      MM_API_PROD_ENV: ${MM_API_PROD_ENV}
+    command: >
+      sh -c "yarn install && yarn run start"
+    networks: [todo]
+    depends_on: [db]
+
+networks:
+  todo:
+    driver: bridge
+    name: todo

package/backtest/localDocker/run.sh

@@ -0,0 +1,4 @@
+#docker-compose -f "localDocker/docker-compose.yml" --env-file .env up -d
+#docker-compose -f "localDocker/docker-compose.yml" --env-file .env up
+docker-compose -f "localDocker/docker-compose.yml" --env-file .env up db
+#docker-compose up

package/backtest/localDocker/shutdown.sh

@@ -0,0 +1,2 @@
+docker-compose -f "localDocker/docker-compose.yml" --env-file .env down
+#docker-compose up

package/backtest/localDocker/update.sh

@@ -0,0 +1,2 @@
+docker-compose -f "localDocker/docker-compose.yml" --env-file .env build
+docker image prune

package/backtest/server.js

@@ -0,0 +1,7 @@
+import { getServerFactory } from '../index.js';
+import path from 'path';
+
+const serverFactory = await getServerFactory(path.join('test','.env'), 'src' + path.sep);
+const { lambdaHandler } = await import('./handler.js');
+
+serverFactory(lambdaHandler, 8080, path.join('..', 'src') + path.sep);

package/backtest/todo/delete/index.js

@@ -0,0 +1,7 @@
+export default async ({ body, MODELS }) => {
+  
+  const todo = await MODELS.todo.findOne({ where: { id: body.id } });
+  await todo.destroy();
+
+  return undefined;
+}

package/backtest/todo/delete/valid.js

@@ -0,0 +1,8 @@
+import { z, zdb } from '../../../index.js';
+
+export default ({ MODELS }) => ({
+  id: z.string()
+    .superRefine(zdb.isSafeInt('id'))
+    .transform(id => parseInt(id))
+    .superRefine(zdb.exists(MODELS.todo, 'id')),
+});

package/backtest/todo/get/index.js

@@ -0,0 +1,3 @@
+export default async ({ MODELS }) =>  {
+  return await MODELS.todo.findAll();
+}

package/backtest/todo/getAttributes/index.js

@@ -0,0 +1,5 @@
+export default async ({ body, MODELS }) =>  {
+  const query = body && body.name ? { where: { name: body.name } } : {};
+  const todo = await MODELS.todo.findOne(query);
+  return todo ? todo.toJSON() : null;
+}

package/backtest/todo/getAttributes/valid.js

@@ -0,0 +1,5 @@
+import { z } from '../../../index.js';
+
+export default () => ({
+  name: z.string().optional(),
+});

package/backtest/todo/getOne/index.js

@@ -0,0 +1,3 @@
+export default async ({ body, MODELS }) =>  {
+  return (await MODELS.todo.findOne({ where: { id: body.id } })).toJSON();
+}

package/backtest/todo/getOne/valid.js

@@ -0,0 +1,8 @@
+import { z, zdb } from '../../../index.js';
+
+export default ({ MODELS }) => ({
+  id: z.string()
+    .superRefine(zdb.isSafeInt('id'))
+    .transform(id => parseInt(id))
+    .superRefine(zdb.exists(MODELS.todo, 'id')),
+});

package/backtest/todo/getOneAlias/index.js

@@ -0,0 +1,3 @@
+export default async ({ body, SERVICES }) =>  {
+  return await SERVICES.todo.getOne({ id: body.id });
+}

package/backtest/todo/getOneAlias/valid.js

@@ -0,0 +1,3 @@
+import { z, zdb } from '../../../index.js';
+
+export default ({ VALIDATORS }) => VALIDATORS.todo.getOne();

package/backtest/todo/index.js

@@ -0,0 +1 @@
+export default ['get', 'getAttributes', 'getOne:id', 'getOneAlias:id', 'post', 'patch:id', 'delete:id', '!postSeed'];

package/backtest/todo/model.js

@@ -0,0 +1,19 @@
+export default serviceName => (orm, types) => {
+  const schema = orm.define(serviceName, {
+    name: {
+      type: types.STRING,
+      allowNull: false
+    },
+  });
+
+  schema.associate = MODELS => {
+    /*
+    schema.belongsTo(MODELS.todoList, {
+      foreignKey: 'todoListId',
+      as: 'todoList'
+    });
+    */
+  };
+
+  return schema;
+};

package/backtest/todo/patch/index.js

@@ -0,0 +1,6 @@
+export default async ({ body, MODELS }) =>  {
+  const todo = await MODELS.todo.findOne({ where: { id: body.id } });
+  await todo.update({ name: body.name });
+
+  return todo.toJSON();
+}

package/backtest/todo/patch/valid.js

@@ -0,0 +1,12 @@
+import { z, zdb } from '../../../index.js';
+
+export default ({ MODELS }) => ({
+  id: z.string()
+    .superRefine(zdb.isSafeInt('id'))
+    .transform(id => parseInt(id))
+    .superRefine(zdb.exists(MODELS.todo, 'id')),
+  name: z.string()
+    .superRefine(zdb.notExists(MODELS.todo, 'name')
+  ),
+});
+

package/backtest/todo/post/index.js

@@ -0,0 +1,5 @@
+export default async ({ body, MODELS }) =>  {
+  const todo = await MODELS.todo.create({ name: body.name });
+
+  return todo.toJSON();
+}