This page View Markdown Open in ChatGPT Open in Claude

The global object `g`¶

Every piece of code you write in API Maker, a custom API, a hook, an event listener, a scheduler, a migration, a process initializer, a test case, is a function of one argument, g. In TypeScript :

TypeScriptPythonPHPC#GoRustJavaKotlin

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

async function main(g: T.IAMGlobal) {
    const rows = await g.sys.db.getAll<db.mongodb.shop.IProducts>({ instance: 'mongodb', database: 'shop', collection: 'products' });
    g.logger.log(rows.length, 'products');
    return rows;
}
module.exports = main;

from am import G


async def main(g: G):
    rows = await g.sys.db.get_all('mongodb', 'shop', 'products')
    g.logger.log(len(rows), 'products')
    return rows

<?php
function main(AmG $g)
{
    $rows = $g->sys->db->getAll('mongodb', 'shop', 'products');
    $g->logger->log(count($rows), 'products');
    return $rows;
}

file static class Api
{
    public static async Task<object?> Main(G g)
    {
        var rows = await g.Sys.Db.GetAll(new GetAll("mongodb", "shop", "products"));
        g.Logger.Log(rows.Count, "products");
        return rows;
    }
}

package code

import "apimaker/am"

func Main(g *am.G) (any, error) {
    rows, err := g.Sys.Db.GetAll(am.GetAll{Instance: "mongodb", Database: "shop", Collection: "products"})
    if err != nil {
        return nil, err
    }
    g.Logger.Log(len(rows), "products")
    return rows, nil
}

use am::{Errors, G, GetAll, Value, json};

pub fn main(g: &mut G) -> Result<Value, Errors> {
    let rows = g.sys.db.get_all(GetAll::new("mongodb", "shop", "products"))?;
    g.logger.log(format!("{} products", rows.len()));
    Ok(json!(rows))
}

import am.G;
import am.GetAll;
import am.JsonObject;
import java.util.List;

class Api {
    static Object main(G g) {
        List<JsonObject> rows = g.sys.db.getAll(new GetAll("mongodb", "shop", "products"));
        g.logger.log(rows.size(), "products");
        return rows;
    }
}

import am.G
import am.GetAll

fun main(g: G): Any? {
    val rows = g.sys.db.getAll(GetAll("mongodb", "shop", "products"))
    g.logger.log(rows.size, "products")
    return rows
}


`g.req`	What came in : headers, params, query, body, event data, the opened tokens.
`g.res`	What goes out : status code, content type, output, headers, errors, warnings.
`g.sys`	The APIs of API Maker from code : `db`, `db.gen`, `system`, `cache`, and `test` inside a test case.
`g.logger`	`debug`, `log`, `info`, `warn`, `error` : shown with the response on the testing pages, kept by the log profiles.
`g.shared`	Values every request of the same runner shares, for as long as it runs : a cache, a counter.

In every language¶

Custom APIs, hooks, schedulers and event listeners can also be written in Python, PHP, C#, Go, Rust, Java and Kotlin. They get the same g, in the words of their language :

	Request	Answer	Database	Logger	Shared	Refuse
TypeScript	`g.req.body.id`	`g.res.statusCode = 201`	`await g.sys.db.getAll({…})`	`g.logger.log('a')`	`g.shared.n`	`throw [{ code: 400, message }]`
Python	`g.req.body.id`	`g.res.status_code = 201`	`await g.sys.db.get_all('mysql_8', 'inventory', 'customers', limit=10)`	`g.logger.log('a')`	`g.shared.get('n')`	`raise g.Errors(message, code=400)`
PHP	`$g->req->body->id`	`$g->res->statusCode = 201`	`$g->sys->db->getAll('mysql_8', 'inventory', 'customers', limit: 10)`	`$g->logger->log('a')`	`$g->shared->n`	`throw new AmErrors($message, 400)`
C#	`g.Req.Body["id"]`	`g.Res.StatusCode = 201`	`await g.Sys.Db.GetAll(new GetAll("mysql_8", "inventory", "customers") { Limit = 10 })`	`g.Logger.Log("a")`	`g.Shared.GetValueOrDefault("n")`	`throw new AmErrors(message, 400)`
Go	`g.Req.Body().Get("id")`	`g.Res.SetStatusCode(201)`	`g.Sys.Db.GetAll(am.GetAll{Instance: "mysql_8", Database: "inventory", Collection: "customers", Limit: 10})`	`g.Logger.Log("a")`	`g.Shared.Get("n")`	`return nil, am.Fail(400, message)`
Rust	`g.req.body()["id"]`	`g.res.set_status_code(201)`	`g.sys.db.get_all(GetAll::new("mysql_8", "inventory", "customers").limit(10))?`	`g.logger.log("a")`	`g.shared.get("n")`	`Err(am::fail(400, message))`
Java	`g.req.getBody().get("id")`	`g.res.setStatusCode(201)`	`g.sys.db.getAll(new GetAll("mysql_8", "inventory", "customers").limit(10))`	`g.logger.log("a")`	`g.shared.get("n")`	`throw new AmErrors(message, 400)`
Kotlin	`g.req.body["id"]`	`g.res.statusCode = 201`	`g.sys.db.getAll(GetAll("mysql_8", "inventory", "customers").limit(10))`	`g.logger.log("a")`	`g.shared["n"]`	`throw AmErrors(message, 400)`

Each language page has the full reference and examples : TypeScript · Python · PHP · C# · Go · Rust · Java · Kotlin.

The code editor completes g in each of them, and offers the columns of your tables on the rows a call answers : the code editor in every language.

g.req¶

Key	Holds
`headers`	The request headers, editable : a pre hook can set `x-am-content-type-response` for the whole call.
`params`	The path parameters : `instanceName`, `database`, `collection`, `id`, `primaryKey`, `field` and `order` of distinct, `tenantUsername` for a multi-tenant request…
`query`	The query parameters as an object : `find`, `select`, `limit`… editable in a pre hook, which is how row level security is done.
`body`	The body, editable.
`eventData`	The data of the event, in an event listener.
`auth`	The opened tokens : `authAMUser` (the API user), `authAMDB` (the person, from a DB auth provider), `authCustom`, `authGoogle`, `authAWS`, `authAzure`.
`reqInfo`	`url`, `apiCategory`, `reqMethod` and `apiInfo` (`id`, `name`, `schemaType`) : which API is running.
`isApiRequestFromUser`	`true` for an HTTP request, `false` for a call made from code.

TypeScriptPythonPHPC#GoRustJavaKotlin

Who is calling

const person = g.req.auth.authAMDB;      // the row of your users table, minus its password
const apiUser = g.req.auth.authAMUser;   // name and groups of the API user

Who is calling

person = g.req.auth.authAMDB       # the row of your users table, minus its password
api_user = g.req.auth.authAMUser   # name and groups of the API user

Who is calling

$person = $g->req->auth->authAMDB;       // the row of your users table, minus its password
$apiUser = $g->req->auth->authAMUser;    // name and groups of the API user

Who is calling

var person = g.Req.Auth.GetObject("authAMDB");       // the row of your users table, minus its password
var apiUser = g.Req.Auth.GetObject("authAMUser");    // name and groups of the API user

Who is calling

person := g.Req.Auth().Map("authAMDB")    // the row of your users table, minus its password
apiUser := g.Req.Auth().Map("authAMUser") // name and groups of the API user

Who is calling

let person = &g.req.auth()["authAMDB"];       // the row of your users table, minus its password
let api_user = &g.req.auth()["authAMUser"];   // name and groups of the API user

Who is calling

JsonObject person = g.req.getAuth().getObject("authAMDB");       // the row of your users table, minus its password
JsonObject apiUser = g.req.getAuth().getObject("authAMUser");    // name and groups of the API user

Who is calling

val person = g.req.auth.getObject("authAMDB")       // the row of your users table, minus its password
val apiUser = g.req.auth.getObject("authAMUser")    // name and groups of the API user