Skip to content
This page View Markdown Open in ChatGPT Open in Claude

All APIs at a glance

Everything API Maker serves sits behind one base URL and the same token header. This page is the map ; every operation has its own page with examples.

This page opens the Build tab : the APIs, then your code, its languages, schema and data and SSR websites. Running them is in the Operate tab.

The API families : one base URL, one token, four HTTP families, your code in any language and the code API Maker runs for you https://api.example.com/api/… one host, one token header, every family below Schema APIs /api/schema/… 17 per table · types, rules, encryption, ids from the schema Generated APIs /api/gen/… 17 per table · schemaless, data passes as it is Custom APIs /api/custom-api/… your function, in any language, any path and method System APIs /api/system-api/… 23 ready APIs : tokens, encrypt, cache, events, indexes, checks Your code TypeScript on Node.js or Bun Python · PHP · C# · Go · Rust Java · Kotlin one g in every language Run by API Maker, not called over HTTP Events after an API hit or from your code · Schedulers on intervals and cron · WebSocket events pushed to clients Process initializers when a sandbox starts · Migration scripts on deploy · Hooks around every API · Test cases

The URL of a table

Anatomy of a database API URL : /api/schema/admin/mysql8/inventory/customers/get-by-id/42 /api /schema /admin /mysql8 /inventory /customers /get-by-id/42 prefix always family schema or gen user path of the account (admin, dev1…) instance a database server crm::acme for a tenant database table / collection operation and its params nothing = get all · get-by-id/:id/:primaryKey query · count · distinct/:field · save-single-or-multiple … Query params follow the URL : ?find={…}&select=…&limit=10&deep=[…]
Segment Meaning
/api/schema or /api/gen The family : schema APIs apply the schema of the table, generated APIs are schemaless.
user-path The API path of the admin or developer account which owns the instance (admin for the first admin). It is shown on the profile of the account.
instance The name of the instance (the database server) in API Maker. For a tenant of a multi-tenant instance : instance::tenant.
database The database on that server.
table The table or collection.

Generated (/api/gen) or schema (/api/schema) ?

Both families offer the same operations on the same URL pattern. The schema APIs read the schema of the table : values are converted to their types, validated, encrypted, defaulted and numbered before they reach the database. The generated APIs are schemaless : they pass your data as it is, so a number sent as "22" stays a string. Use the schema APIs for the tables your application writes to, and the generated APIs for quick reads and for tables without a schema.

Instances, databases and tables

APIs & Logic → Instance API (DB API) has four panels, left to right : instances, databases, tables, APIs. Pick one in each and the next panel fills.

  • Instances : a connection to a database server (MongoDB, MySQL with TiDB and Percona, MariaDB, SQL Server, PostgreSQL, Oracle). Its name is part of every URL and can not change later. Its connection string is a key of the secret.
  • Databases and tables : what the connection sees, with their settings and schemas.
  • APIs : the operations below, each with its settings and Test API.

Every button of these panels is on the table designer page : adding an instance, making, editing and deleting databases and tables, and keeping the schemas in step.

The operations of a table

17 on a MongoDB collection, 14 on a table of the SQL databases.

The paths below follow /api/schema/<user-path>/<instance>/<database>/<table> (and the same under /api/gen). [/:primaryKey] names another column to use as the key.

Operation Method and path Body Page
Get all GET / query params Get all
Get all by stream GET /stream query params Get all by stream
Get by id GET /get-by-id/:id[/:primaryKey] Get by id
Save single or multiple POST /save-single-or-multiple one object or an array Save single or multiple
Master save POST /master-save objects with nested related objects Master save
Update by id PUT /update-by-id/:id[/:primaryKey] the fields to change Update by id
Update many PUT /update-many { find, updateData } Update many
Replace by id MongoDB PUT /replace-by-id/:id[/:primaryKey] the whole document Replace by id
Array operations MongoDB PUT /array-operations { find, operations } Array operations
Remove by id DELETE /:id[/:primaryKey] Remove by id
Remove by query POST /query/delete { find } Remove by query
Query for get data POST /query { find, select, sort, skip, limit, deep, getTotalCount } Query for get data
Query for get data by stream POST /query-stream same as query Query for get data by stream
Aggregate MongoDB POST /aggregate a pipeline array Aggregate
Count POST /count { find } Count
Distinct GET /distinct/:field[/:order] Distinct
Distinct with query POST /distinct/:field[/:order] { find } Distinct with query
  • MongoDB gets all 17. MySQL, MariaDB, SQL Server, PostgreSQL, Oracle, TiDB and Percona get 14 : replace by id, array operations and aggregate are MongoDB only.
  • The schema operations exist for a table only once it has an active schema. The generated ones are always there.
  • Their id in settings, groups, hooks and WebSocket subscriptions is SCHEMA_GET_ALL, GEN_POST_BULK_INSERT… : the full list is under API ids.

Shared by every read
Query params find, skip, limit, sort, select, deep, getTotalCount, and any column name as a filter. In the body for the query APIs.
Request headers Tokens, x-am-response-case, x-am-content-type-response, x-am-response-object-type, x-am-cache-control, x-am-get-encrypted-data, x-am-internationalization, x-am-tenant-username…
Response format { success, statusCode, data, totalCount, errors, warnings, logs, meta }

Your own APIs

Family Method and path Page
Custom API ANY /api/custom-api/<user-path>/<path> : the method and path of its settings Custom APIs
Pre and post hooks run around every API of the account Pre hook · Post hook
Events emitted by an API hit or by code, with listeners Events
WebSocket events pushed to subscribed clients WebSocket events
Schedulers intervals and cron Schedulers
Utility classes shared code, import * as x from 'utils/X' Utility classes

System APIs

All under /api/system-api/<user-path>/…, all POST, and all available in code as g.sys.system.* or g.sys.cache.*.

Group APIs
Security /token · /encrypt-data · /decrypt-data · /hash-data · /get-secret-by-name
Redis and cache /get-redis-key · /set-redis-key · /remove-redis-key · /reset-redis-cache-db · /reset-redis-cache-custom-apis · /reset-redis-cache-system-apis
Databases /get-table-meta · /create-indexes · /drop-indexes · /get-indexes · /multi-tenant-instance-updated · /execute-plain-query · executeQuery from code
Events /emit-event · /emit-event-ws
Validation /is-valid-data-for-table · /is-valid-data-for-custom-api · /is-valid-connection-string
Outside /call-external-api

From your code

Every API above is a method of the global object g : g.sys.db.getAll, g.sys.db.gen.queryGen, g.sys.system.encrypt, g.sys.cache.setKey… with the same headers and query params, and an example for each one.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
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.mongodb.shop.IProducts>({
        instance: 'mongodb', database: 'shop', collection: 'products',
        queryParams: { find: { status: 'ACTIVE' }, limit: 10, deep: [{ s_key: 'category' }] },
    });
    return products;
}
module.exports = main;

1
2
3
4
5
6
from am import DeepItem, G


async def main(g: G):
    products = await g.sys.db.get_all('mongodb', 'shop', 'products', find={'status': 'ACTIVE'}, limit=10, deep=[DeepItem('category')])
    return products

1
2
3
4
5
6
<?php
function main(AmG $g)
{
    $products = $g->sys->db->getAll('mongodb', 'shop', 'products', find: ['status' => 'ACTIVE'], limit: 10, deep: [new DeepItem('category')]);
    return $products;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
file static class Api
{
    public static async Task<object?> Main(G g)
    {
        var products = await g.Sys.Db.GetAll(new GetAll("mongodb", "shop", "products")
        {
            Find = new JsonObject { ["status"] = "ACTIVE" }, Limit = 10, Deep = new[] { new DeepItem("category") },
        });
        return products;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package code

import "apimaker/am"

func Main(g *am.G) (any, error) {
    products, err := g.Sys.Db.GetAll(am.GetAll{
        Instance: "mongodb", Database: "shop", Collection: "products",
        Find: am.M{"status": "ACTIVE"}, Limit: 10, Deep: []am.DeepItem{am.DeepItem{SKey: "category"}},
    })
    return products, err
}

1
2
3
4
5
6
7
8
use am::{DeepItem, Errors, G, GetAll, Value, json};

pub fn main(g: &mut G) -> Result<Value, Errors> {
    let products = g.sys.db.get_all(
        GetAll::new("mongodb", "shop", "products").find(json!({ "status": "ACTIVE" })).limit(10).deep(vec![DeepItem::new("category")]),
    )?;
    Ok(json!(products))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
import am.DeepItem;
import am.G;
import am.GetAll;
import am.JsonObject;
import java.util.List;
import java.util.Map;

class Api {
    static Object main(G g) {
        List<JsonObject> products = g.sys.db.getAll(new GetAll("mongodb", "shop", "products")
            .find(Map.of("status", "ACTIVE")).limit(10).deep(List.of(new DeepItem("category"))));
        return products;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import am.DeepItem
import am.G
import am.GetAll

fun main(g: G): Any? {
    val products = g.sys.db.getAll(
        GetAll("mongodb", "shop", "products").find(mapOf("status" to "ACTIVE")).limit(10).deep(listOf(DeepItem("category"))),
    )
    return products
}

API ids

The ids used in groups, settings, hooks, events and WebSocket subscriptions.

Schema APIs

  • SCHEMA_GET_ALL
  • SCHEMA_GET_ALL_STREAM
  • SCHEMA_GET_BY_ID
  • SCHEMA_POST_BULK_INSERT
  • SCHEMA_MASTER_SAVE
  • SCHEMA_ARRAY_OPERATIONS
  • SCHEMA_UPDATE_MANY
  • SCHEMA_PUT_UPDATE_BY_ID
  • SCHEMA_PUT_REPLACE_BY_ID
  • SCHEMA_DEL_DELETE_BY_ID
  • SCHEMA_POST_QUERY
  • SCHEMA_POST_QUERY_STREAM
  • SCHEMA_POST_QUERY_DELETE
  • SCHEMA_POST_AGGREGATE
  • SCHEMA_POST_COUNT
  • SCHEMA_GET_DISTINCT
  • SCHEMA_POST_DISTINCT_QUERY

Generated APIs

  • GEN_GET_ALL
  • GEN_GET_ALL_STREAM
  • GEN_GET_BY_ID
  • GEN_POST_BULK_INSERT
  • GEN_MASTER_SAVE
  • GEN_ARRAY_OPERATIONS
  • GEN_UPDATE_MANY
  • GEN_PUT_UPDATE_BY_ID
  • GEN_PUT_REPLACE_BY_ID
  • GEN_DEL_DELETE_BY_ID
  • GEN_POST_QUERY
  • GEN_POST_QUERY_STREAM
  • GEN_POST_QUERY_DELETE
  • GEN_POST_AGGREGATE
  • GEN_POST_COUNT
  • GEN_GET_DISTINCT
  • GEN_POST_DISTINCT_QUERY

System APIs

  • EXECUTE_PLAIN_QUERY
  • ENCRYPT_DATA
  • DECRYPT_DATA
  • HASH_DATA
  • GET_TOKEN
  • CALL_EXTERNAL_API
  • GET_SECRET
  • GET_REDIS_KEY
  • SET_REDIS_KEY
  • REMOVE_REDIS_KEY
  • CUSTOM_USER_CACHING
  • RESET_REDIS_CACHE_DB
  • RESET_REDIS_CACHE_CUSTOM_APIS
  • RESET_REDIS_CACHE_SYSTEM_APIS
  • GET_TABLE_META
  • CREATE_INDEXES
  • DROP_INDEXES
  • GET_INDEXES
  • EMIT_EVENT
  • EMIT_EVENT_WS
  • IS_VALID_DATA_FOR_TABLE
  • IS_VALID_DATA_FOR_CUSTOM_API
  • MULTI_TENANT_INSTANCE_UPDATED
  • IS_VALID_CONNECTION_STRING