API Maker v4 Full Demo: Six Databases, One Backend, Every API

Intro

0:02 API Maker Launchpad is a desktop app that installs API Maker : on this computer in Local mode, or on your own servers in Cloud mode. New project, in a folder. Step one, the architecture. Step two, the version. Step three, the ports. Step four, a review of what will run. Install and start : API Maker downloads, MongoDB and Redis start in Docker, and API Maker runs, with its admin panel.

Cloud mode: one example

0:34 Cloud mode, on your own servers. The production of Calm Home : a gateway, an API Maker server and a data server. Review and deploy shows what will change, server by server. Deploy : every stage, with the output of each server, live. Production is up.

Calm Home, six databases

0:55 Calm Home, the shop of this demo, keeps its data in six databases : MongoDB, MySQL, PostgreSQL, SQL Server, Oracle and MariaDB. API Maker stands in front of all six. To connect a database : pick its engine, give its connection string, test it, and save the instance. Its tables are listed, and Bulk Schema Creation writes the schema of every table, in one click. A new table? Design it in the panel, with the types of its engine.

1:28 The SQL is shown before it runs.

The APIs of every table

1:31 Every table gets its APIs at once : thirty four for this MongoDB collection. Get all, get by id, save, update, count, aggregate and more, checked against the schema, or straight to the table.

One envelope

1:45 Every API answers the same envelope : success, a status code, and the data. Errors have one shape too : a type, a field and a message for each problem.

One call, six databases

1:59 One call, on the orders of MySQL. The customer comes from PostgreSQL, the coupon from MariaDB, the employee from Oracle, the products from MongoDB, and the shipments from SQL Server. One request, one answer, six databases.

How it runs

2:15 Underneath, one query reads the orders, then one query per related table, with all the ids at once : eight queries for twenty orders, instead of one hundred and seventy three, row by row. Each read goes through the API of its table, with its permissions and its cache.

A small custom API

2:35 Your own logic is a custom API. Here, one getAll on the orders of MySQL, saved, and it is live. Send : the code on the left, its answer on the right.

What every custom API gets

2:47 And every custom API gets all of this, with no extra code : authorization, validation of its input, the APIs of every database, caching, translated errors and logs, utility classes, typed tables, versions, packages, and eight languages.

The timeline of a custom API

3:06 How does a custom API spend its time? API Testing draws every run on a timeline, one bar for each database call. Here, three small APIs count the events of the orders. One by one, each count waits for the one before it : a staircase. With Promise dot all, the three run together, and the run ends far sooner. Mixed : one count first, then the other two together.

3:32 You see how your code loads its data, call by call.

The security report

3:39 The APIs Security Report scans every API of the account. Zero out of a hundred : this account was left open on purpose. Each finding comes with its evidence and its fix. Fixes are one click, and the score climbs.

WebSockets: the hook

3:57 Realtime. A WebSocket event declares what clients may follow, with the token they bring. Its code is the hook : a customer follows only his own orders. In the app of Kabir : a saved order is pushed at once, a status is pushed from code, and the orders of another customer are refused by the hook. One gigabyte of memory holds tens of thousands of clients.

WebSockets: the app

4:22 And in the app, a few lines of JavaScript. One WebSocket, on the port of the APIs, with the token of the app and the token of the person. Then register what to follow : the status of his orders. Each push arrives in onmessage, as it happens. And the hook on the server still decides who may follow what. Schedulers run code on a clock : a name, every minute, and a few lines of code.

4:47 Saved, a server runs it, and every run is on record.

Caching

4:52 Caching is one setting per table. The first read comes from MySQL, the next one from the cache, in a few milliseconds. A write to the table clears it.

Index Maker

5:05 Index Maker records the shape of every query, and suggests the index a slow one needs. Created in one click, the same call runs many times faster.

Index Maker on its own

5:16 Or let Index Maker do it on its own, with the automatic mode. Every six hours, it records half an hour of the real queries of your APIs. A query without an index gets one when its table holds at least ten thousand rows, and the query is slower than a hundred milliseconds, or runs fifty times. Small indexes only : three fields at most. Switch it on, and each index becomes a line of a migration script : development, staging and production get the same indexes.

Analytics

5:48 Analytics judges the health of every server. Calls, errors, latencies, cache hits and the rows read from six databases, down to each API. The same numbers sit beside the code : the speed, the calls and the data of every custom API, the slowest first.

Benchmarks on a $5 server

6:08 Benchmarks, on a five dollar server : one virtual CPU and one gigabyte. A get all, read from the database every time : over two thousand requests per second. Many times more with caching. API Maker at rest : under a hundred megabytes. WebSockets : tens of thousands of clients at once, and a notification in a few milliseconds.

Local client and AI

6:34 Developers keep their own tools. With the local client, the account is a folder on their computer, in sync with the panel, both ways. The folder also holds the security report and the types of every table, so AI assistants write code that fits the standard.

Git

6:51 The account lives in Git : a branch, the change side by side, a commit. On another server, one pull makes it live, on every server of the cluster. For the whole team : an account for each developer, test cases in the same eight languages, and Swagger documents written from the APIs.

SEO-friendly websites

7:13 Websites too : this storefront is rendered on the server by API Maker, so every page arrives finished. One product page reads four databases : the product from MongoDB, its orders from MySQL, its stock from SQL Server, and its reviewers from PostgreSQL. And that makes it friendly to search engines. A crawler gets the title, the description, the Open Graph tags and the canonical address, the product itself in the HTML, and a sitemap of every product.

7:45 No API was written for any of it.

Upgrades from the panel

7:50 Upgrades come from the panel : upload a release, or pick a version on npm. Each server checks the new version, and goes back on its own if it does not start. More users, more servers : no sticky sessions.

Recap

8:05 To sum up : installed in one click, six databases and their APIs, one call across them, custom APIs in eight languages with every run on a timeline, security that fixes itself, realtime and jobs built in, indexes that make themselves, SEO-friendly websites, and a Rust core that goes far on a small server. API Maker. Build faster, spend smarter, deliver better.