Words to know¶

Each word of API Maker in one or two sentences, with the page that tells more. The words are in the order you meet them.

The basics¶

API: An address (a URL) that an app calls to read or change data. API Maker answers in JSON : { "success": true, "statusCode": 200, "data": … }.
API Maker: The program that serves your APIs. It runs on your computer or on your servers. How it works
API Maker Launchpad: A free desktop app that installs and runs API Maker : on your computer (Local) or on your servers (Cloud). Install API Maker
Admin panel: The website where you set up everything : databases, tables, code, security. API Maker serves it. The admin panel
Account and user path: An admin account owns its databases, APIs and code. Its user path, like admin, is part of every URL of its APIs. A team adds developer accounts.
Root user: The user who manages the installation itself : the admin accounts and the settings of every server. You rarely need it.

Instance: One database server that API Maker connects to, like mongodb or postgres. Its connection string stays in the secret. Instances
Table, collection: A table of your database. MongoDB calls it a collection : the docs use both words.
Schema: The description of a table : its fields, their types, their rules, their default values, and the links to other tables. Table schema
Schema APIs, generated APIs: The ready-made APIs of every table. Schema APIs (/api/schema/…) check each write against the schema. Generated APIs (/api/gen/…) do not. All the APIs
Query params: The options of a read : find (which rows), select (which fields), sort, limit, deep. Query params
Deep populate: Reading the rows a field points to, in the same call : an order with its customer, inside. deep
Table Designer: A page to make and change tables with the mouse, on any database. Table designer
Migration script: Code that changes a database once, on each environment : add a column, fill it. Database migration

Custom API: Your own function behind a URL, in TypeScript, Python, PHP, C#, Go, Rust, Java or Kotlin. Your own code
The global object g: What your code receives : the request (g.req), the answer (g.res), and every API of API Maker (g.sys). Global object g
Pre hook, post hook: Code that runs before an API (it can change the request) or after it (it can change the answer). Pre hook
Event: Code that runs after something happened, like an order saved. Events
Scheduler: Code that runs on a timer : every five minutes, every night. Schedulers
WebSocket event: A live message to your apps when data changes, without asking again and again. WebSocket events
Utility class: Code shared by your other code : write a price calculation once, use it in ten APIs. Utility classes
Test case: Code that calls your APIs and checks their answers. Test cases
Sandbox: A Docker container that runs your code, apart from API Maker. Each language has its own. Sandbox settings
Native process: Code that runs on the machine itself, next to API Maker, without Docker. Faster, less isolated. Native process
API Testing: A page of the admin panel that calls any API for you, and shows the answer. Your first API

Secret: Your passwords and connection strings, kept encrypted by API Maker. They never go to Git. Secrets
API user: The login of one app : a username and a password. API user permission
Group: The list of what an API user may call : APIs, tables, fields. API group permission
Token: What an app sends on every call, in the header x-am-authorization. It gets it from the token API with its username and password.
Auth provider: Turns the sign-in of a person of your app into a second token, so your code knows who calls. Sign-in providers
Access type: Who may call an API : TOKEN_ACCESS (with a token, the default), IS_PUBLIC (anyone), NO_ACCESS (only your own code). Secure your APIs
Security report: A page that reads your whole account, says where data could leak, and fixes it. Security report

Environment: One API Maker with its own servers and data : DEV, QA, PROD. Put it on a server
Reverse proxy: The program in front of API Maker on a server, for HTTPS : Caddy, Ferron, Pingap, or the web server built into API Maker.
Local client: Keeps a folder of your computer in sync with an account, so you can code in your own editor. Developer tools
Git integration: Your schemas, APIs and code as files in Git : commit them, then pull them on another server. Git integration
Caching: Answers kept in Redis, so the same read is fast the next time. Automatic caching
Logs: What API Maker records about each call, to find a problem. Logs and dashboards