Skip to main content

Overview

How does it work?​

Codehooks is a "no-setup", quick and simple to use backend service, bundling essential features like serverless JavaScript/TypeScript code, a NoSQL database, a Key-Value store, scheduled jobs, queue workers and more.

Everything in Codehooks is organized through Teams (or personal accounts) which again manages projects containing one or more environments (we call them 'spaces').

Each space contains its own separate code and data storage. To manage teams, projects and data, you can use the web-based UI or the CLI - which you install with: npm install -g codehooks

Codehooks conceptual overview

Codehooks Studio​

The Studio dashboard shows an overview of your application API traffic and details from the deployed REST API routes. Each API has examples from popular programming languages with easy copy to clipboard.
Codehooks Studio data view

codehooks-js​

The codehooks-js library is the foundation for all Codehooks JavaScript development. This library contains a set of 6 specific APIs which simplifies and accelerates backend development.

API development

REST, CRUD or custom APIs

NoSQL & Key-Value

Code triggered by CRON

Long running processes

File System

Serve static content

Data Aggregation

Groups & sums

API development​

Get a flying start with an automatic CRUD REST API

Consider a Codehooks project, for example myproject-fafb. Under the hood, Codehooks deploys an automatic REST API which is made up of the following really short - but complete application code:
import {app} from 'codehooks-js'
// Use Crudlify to create a REST API for any database collection
app.crudlify()
// bind to serverless runtime
export default app.init();
It's just 3 lines of code 🔥, and it delivers a fully secure CRUD REST API with a NoSQL database for JSON queries and updates. Client apps can instantly connect to your data API, for example from a JavaScript app like the example code snippet shown below:
const URL = 'https://myproject-fafb.api.codehooks.io/dev/orders';
response = await fetch(URL+'?status=OPEN', /* options */)
const result = await response.json()

Learn more

NoSQL and Key-Value Datastores​

Easy database API inspired by MongoDB

Sometimes a standard CRUD REST API isn't enough. With custom JavaScript functions you can create logic that integrates directly to the NoSQL datastore. No need to think about drivers, versions, protocol or security, the database is just there, available as an intrinsic object in every serverless function.
import {app, datastore} from 'codehooks-js'
// REST API route
app.get('/sales', async (req, res) => {
  const conn = await datastore.open();  
  const query = { status: "OPEN" };
  const options = { sort: { date: 1 } }
  conn.getMany('orders', query, options).json(res); // stream JSON to client
})
// bind to serverless runtime
export default app.init();

Learn more

Speed up your application with a Key-Value cache

The Codehooks data engine includes a simple key-value datastore. A key-value datastore has many use-cases, and is ideal for caching due to the swift data access and simple, maintenance-friendly architecture. A simple example is shown below, where a string is stored for 60 seconds with the ttl option.
import {app, datastore} from 'codehooks-js'
// REST API route
app.post('/cacheit', async (req, res) => {  
  const conn = await Datastore.open();
  const opt = {ttl: 60*1000};
  await conn.set('my_cache_key', '1 min value', opt);
  res.send('Look dad, I have my own cache now!');
})
// bind to serverless runtime
export default app.init();

Learn more

Background Jobs​

CRON expressions + your function keeps running

Use simple CRON expressions to automate and manage the execution of routine tasks. You can schedule a job to run at multiple, disparate times. For example, you can schedule a task to run at 2 AM on Sundays and 4 PM on Wednesdays with the same CRON job.

In the simple example below, the CRON expression */5 * * * * will trigger a JavaScript function each 5 minutes.

import app from 'codehooks-js'
// Trigger a function with a CRON expression
app.job('*/5 * * * *', (_, job) => {
  console.log('Hello every 5 minutes')
  // Do stuff ...
  job.end()
});
export default app.init();

Learn more

Queues​

Scale workloads with queues and worker functions

Use persistent queues and "worker" functions to create robust, efficient, and highly responsive back-end systems. Queues scales processing across multiple nodes and will restore and continue working in case of errors and system failures.
Check out the example below, where a REST API request starts a complex task by adding it to the Queue for later processing.
import { app, Datastore } from 'codehooks-js'

// register a Queue task worker
app.worker('ticketToPDF', (req, res) => {
    const { email, ticketid } = req.body.payload;
    //TODO: implement code to fetch ticket data, produce PDF
    // and send email with attachment using Mailgun, Sendgrid or Amazon SES
    // ...and implement error handling
    res.end(); // done processing queue item
})

// REST API
app.post('/createticket', async (req, res) => {
    const { email, ticketid } = req.body;
    const conn = await Datastore.open();
    await conn.enqueue("ticketToPDF", { email, ticketid });
    res.status(201).json({"message": `Check email ${email}`});
})

export default app.init();

Learn more

File System​

Serve any static content

Codehooks has a built-in file system to support streaming file uploads and downloads. You can serve files via a static fileserver or via JavaScript functions using the File API. The example CLI command below shows how to upload a directory of files to the dev space (environment) of the project.
$ coho file-upload --projectname 'myproject-fafc' --space 'dev' --src './app'
Furthermore, the example below shows how to serve the same directory under the /static/* route, e.g. https://myproject-fafb.api.codehooks.io/dev/static/index.html
import {app} from 'codehooks-js'
// serve a direcory of files
app.static({route:"/static", directory: "/app"})
// CRUD REST API
crudlify(app)
// bind to serverless runtime
export default app.init();

Learn more

Data Aggregation​

Easy to use data aggregation format

Transform your live data streams into insights with just a few lines of code. Codehooks has a simple but powerful JSON-based aggregation expression language to specify data transformations. Groups and sums can be nested to create both simple and advanced data outputs. The aggregation API can process input from any JSON data-stream, for example the query output from the NoSQL datastore. 🔥
import { app, Datastore, aggregation } from 'codehooks-js'
... // collapsed code
const spec = {
  $group: {
    $field: "month",
    $max: ["sales", "winback"],
    $sum: "sales"
  }
}
const db = await datastore.open();
const dbstream = db.getMany('salesData');
const result = await aggregation(dbstream, spec)
... // collapsed code
The example aggreagation transformation produces JSON output similar to the example below.
{
    "oct": {
      "sales": {
        "max": 1477.39,
        "sum": 1234.05
      },
      "winback": {
        "max": 22.0
      }
    },
    "nov": {
      "sales": {
        "max": 2357.00,
        "sum": 5432.00
      },
      "winback": {
        "max": 91.0
      }
    },  
}

Learn more

Next Steps​

Read this far? Great 🙌

It's time to get your feet wet 💦. Why don't you start thinking about how codehooks' toolbox can help you build your solution. You can get started with the quickstart for developers or just sign up and create your project and space using the web UI. You can easily upload some CSV data and immediately test your new API.

The documentation or tutorials are great places to start. If you need more help, feel free to contact us on the chat.