This page View Markdown Open in ChatGPT Open in Claude

Developer tools¶

What API Maker gives a developer besides the APIs : docs for the people who call them, types for your code, a page to try every API, a debugger, and your own editor in sync with the server.

In short

Swagger docs for each API user : only the APIs it may call.
API Testing tries every API, with its hooks, and shows the logs and the database calls.
The local client keeps a folder of your computer in sync, for VS Code, WebStorm or an AI agent.

Developer Tools: Swagger, Redis Dashboard, Typed Rows and Shortcuts10 chapters and the transcript

Swagger docs per API user¶

Open an API user, enable Swagger docs and generate a Swagger Token. View Swagger JSON opens its URL.
The docs list only the APIs that the API user can call, like its database, custom and system APIs.
Share the URL with the team or partner that uses that API user.
The URL answers an OpenAPI 3.0 document. Paste it in the Swagger Docs page of the dashboard to read the APIs and try them, or give it to any tool which reads OpenAPI, like a generator of clients.
An API which asks for several tokens says so in the document : a call has to carry all of them. An API which takes files gets a form with its fields of files.
The URL answers only while Swagger docs are enabled for that API user. Disable them, or generate a new token, to stop an old URL from working.

TypeScript interfaces from your schemas¶

Your table schemas become TypeScript interfaces, grouped by instance and database : db.<instance>.<database>.I<Table>. See them in APIs & Logic → Generated Interfaces.
Import them from db-interfaces in your code.

import * as T from 'types';
import * as db from 'db-interfaces';

async function main(g: T.IAMGlobal) {
    const products = await g.sys.db.getAll<db.shop.main.IProducts>({
        instance: 'shop', database: 'main', collection: 'products',
    });
    return products.map(p => p.name); // p is typed
}
module.exports = main;

In Python, PHP, C#, Go, Rust, Java and Kotlin the code editor offers the same columns on the rows a call answers, without interfaces to import : the code editor in every language.

API testing page¶

API Testing in the Panel: Call, Debug, Export and Share Any API11 chapters and the transcript

Every API of your account in one place: pick an API, get a sample payload, set the headers and tokens, send it and read the response.
APIs & Logic → API Testing, or Test API on the DB API, Custom API, System API, Events and Schedulers pages. On a listener the body holds the event data; on a scheduler, sending runs the code now.
The request: Headers, Params, Query Params, Body (Generate Data builds a sample payload from the schema), Code (the code of a custom API, listener, scheduler or migration, with its versions), Pre Hooks and Post Hooks of the API : for an API of a table, the hooks of its instance, its database and its table are listed too, in the order they run (marked Instance, Database, Table : they are changed in their own categories). On a multi-tenant instance, Select tenant.
The response: the answer or the errors, with the status code, the time taken and whether it came from the cache; the TypeScript interface of the answer; Logs with every g.logger line of the code which ran, hooks included.
Index Maker, for code (a custom API, a listener, a scheduler, a hook...): every database call of the run. What to look at first (a query reading a whole table, a query in a loop, a query asked twice, a slow or big call), a timeline of the calls, every query shape with its index use, and the indexes to create : one run from the API testing page.
A scheduler, a listener, a migration script or a process initializer is sent with the time it runs with (the header x-am-sandbox-timeout) : time of a run.
Show Utility Classes next to the code opens the utility classes the code uses : the ones of its language, on its runtime.
Every Send is recorded. Save a request as a state to run it again later, star it as a favourite. States go to Git with the project.
Copy the same request as client code from Integrations: C, C#, cURL, Dart, Go, HTTP, Java, JavaScript, Kotlin, Node.js, Objective-C, OCaml, PHP, Postman CLI, PowerShell, Python, R, Ruby, Rust, Shell and Swift, with their variants.

Debugger¶

Stop the code of every language at breakpoints, in the sandboxes and on the native process. The admin panel is the debugger : nothing to install.
Turn it on in Debug Settings, set a breakpoint in the margin of the editor, and send the request from API Testing. See Debugging.

IDE¶

Every file of your code in one editor : search in all the files, go to file, tabs, go to definition in every language, the debugger, and the history of each file in git with its lines annotated. Open it from the dashboard, or with the IDE button of any code editor.
Learn more IDE.

Your own editor¶

Code Your Backend in VS Code: Two-Way Sync with the Local Client12 chapters and the transcript

localClient.js in your Git repository syncs your files with API Maker both ways.
Generate a sync token in your user profile and set it in local-client.config.js.
npm install once : the packages your code uses and the declarations of Node.js (@types/node), which tsconfig.json names for VS Code and WebStorm.
npm run start keeps the folder in sync, npm run test runs the test cases of the account from the terminal and writes their code coverage to coverage/lcov.info for VS Code and WebStorm. Learn more Test cases.
A file you save is sent at once, a tenth of a second after your editor wrote it, and what the panel or another developer saves is written to your disk as soon as the server saved it. The files the local client writes are not sent back ; a change you type right after them is sent like any other.
While it is connected, API Maker also scans the account on its own, and writes a changed report to src/api_security_report/ on your disk. So an AI assistant working in the folder reads a fresh report. API Maker commits nothing : you commit when you want. Learn more APIs Security Report & Actions.
An AI agent (Codex, Claude Code, Cursor, Copilot) working in the folder reads AGENTS.md at its root : every commit writes the guide of API Maker into it. Learn more AGENTS.md in your repository.

module.exports = () => {
    return {
        webSocketURL: 'wss://ws.example.com', // WebSocket URL of your API Maker
        syncToken: '...', // generate it in your user profile
        adminUserPath: 'admin',
        name: 'Alice', // optional : how the others see this local client (else its user and computer)
    };
};

Several developers, one sync token¶

Every developer of the account runs the local client with the same sync token, each in a clone of their own : up to 50 at a time. What one of them saves reaches the others, and the admin panel, within a second.
The others get what the server saved, written again from the database, never the files as they were sent. A file a developer takes out of a folder (a page of an SSR website) is taken out on the other computers too, unless it was changed there.
Each line of the terminal says where a change comes from, and what happened :

👥 Joined : [10:32:05] : Bob (bob@ThinkPad, shop-api) · 2 local clients sync this account
✓ Send : [10:32:41] : [change] : src/custom_apis/Cart_Quote/Cart_Quote.ts
✓ Saved on server : [10:32:41] : src/custom_apis/Cart_Quote
✓ Receive : [10:33:02] : src/schemas/products ← the admin panel (Mayur)
✓ Receive : [10:33:15] : src/ssr/shop ← the local client of Bob (bob@ThinkPad, shop-api)
✓ Remove : [10:33:15] : src/ssr/shop/pages/old.tsx ← the local client of Bob (bob@ThinkPad, shop-api)
✅ Full Sync : [10:34:00] ← a git pull

The bar of the admin panel shows who is connected : the faces of the local clients and their count. Its menu lists each one with its computer, its folder, its address and since when, and links to the sync token : a new token disconnects every local client.

A channel nobody can read or take over¶

The local client connects inside the encrypted channel of the admin panel : the keys of each connection are agreed on (ECDH P-256), and the address of the socket and every message are sealed (AES-256-GCM), each in its order.
The sync token never travels. The local client proves that it knows it with a proof bound to its connection, and the server proves it in its turn : nothing is sent to a server which does not. Who stands between the two reads nothing, and can not use what it saw elsewhere. The token never shows in the logs of a proxy either.
Whatever the server sends, the local client writes inside its folder only : src/ and tsconfig.json.
An address which gives 20 wrong sync tokens is refused for 15 minutes. A localClient.js of before still connects, with the token in the clear : the panel marks it with an open lock until it is updated from git.
Over the internet, keep HTTPS / WSS in front of API Maker all the same. The handshake goes to the same address as webSocketURL (wss:// → https://) : point it at API Maker, whose APIs and web sockets share one port.