Dados e armazenamento

## g.store.* — armazenamento persistente

Armazenamento de documentos com escopo de espaço de trabalho, baseado em LiteDB. Exige um espaço de trabalho aberto.

Método	Assinatura	Async	Descrição
put	(collection, key, data)	Não	Armazena um documento
get	(collection, key) → StoreDoc | null	Não	Recupera um documento
list	(collection, options?) → StoreDoc[]	Não	Lista documentos de uma coleção
search	(collection, query, options?) → StoreDoc[]	Não	Pesquisa texto dentro de uma coleção
delete	(collection, key) → boolean	Não	Exclui um documento
count	(collection) → number	Não	Conta documentos
clear	(collection)	Não	Exclui todos os documentos de uma coleção
collections	() → string[]	Não	Lista todos os nomes de coleções

StoreDoc:

{
  key: string
  data: any
  createdAt: string
  updatedAt: string
}

Exemplo

async function main() {
  g.store.put("products", "item-1", {
    name: "Widget",
    price: 9.99,
    inStock: true
  });

  const doc = g.store.get("products", "item-1");
  if (doc) g.log("Encontrado: " + doc.data.name);

  const results = g.store.search("products", "Widget");
  g.log("Correspondências: " + results.length);
}

---

## g.queue.* — fila de trabalho

Fila persistente com escopo de espaço de trabalho, níveis de prioridade e suporte a fila de rejeitos. Exige um espaço de trabalho aberto.

Método	Assinatura	Async	Descrição
enqueue	(name, data, options?)	Não	Adiciona um item à fila
dequeue	(name) → QueueItem | null	Não	Retira o próximo item da fila
commit	(checkoutId)	Não	Marca um item retirado como concluído
abort	(checkoutId, error?) → boolean	Não	Retorna um item à fila ou envia para a fila de rejeitos se exceder tentativas
peek	(name) → QueueItem | null	Não	Visualiza o próximo item sem retirá-lo
count	(name) → number	Não	Conta itens pendentes
clear	(name)	Não	Exclui todos os itens de uma fila
list	(name, options?) → QueueItem[]	Não	Lista itens pendentes
queues	() → string[]	Não	Lista todos os nomes de filas
deadLetter	(name, options?) → DeadLetterItem[]	Não	Lista itens da fila de rejeitos
retry	(name, deadLetterId)	Não	Reenfileira um item rejeitado
waitForItem	(name, options?) → Promise<QueueItem | null>	Sim	Bloqueia até um item estar disponível

QueueEnqueueOptions:

{
  priority?: number
  maxRetries?: number
}

QueueItem:

{
  id: number
  data: any
  priority: number
  attempts: number
  maxRetries: number
  enqueuedAt: string
  lastAttemptAt?: string
  lastError?: string
}

Exemplo

async function main() {
  g.queue.enqueue("urls", { url: "https://example.com/page1" });
  g.queue.enqueue("urls", { url: "https://example.com/page2" }, { priority: 2 });

  const item = g.queue.dequeue("urls");
  if (!item) return g.log("Fila vazia");

  await g.nav.navigateToUrl(item.data.url);
  const html = await g.page.getDom();

  g.queue.commit(item.id);
}

---

## g.search.* — pesquisa de texto completo

Índice Lucene.NET com escopo de espaço de trabalho. Suporta operadores booleanos, wildcards, correspondência fuzzy e consultas por campo. Exige um espaço de trabalho aberto.

Método	Assinatura	Async	Descrição
index	(fields)	Não	Indexa um documento; deve incluir _key e _collection
query	(queryString, options?) → SearchResult[]	Não	Pesquisa usando sintaxe Lucene
delete	(collection, key)	Não	Remove um documento do índice
deleteByCollection	(collection) → number	Não	Remove todos os documentos de uma coleção
count	(collection?) → number	Não	Conta documentos indexados
clear	()	Não	Limpa todo o índice

---

## g.s3.* — armazenamento de objetos compatível com S3

Armazenamento compatível com S3 via MinIO SDK. Funciona com AWS S3, MinIO e serviços compatíveis. O parâmetro conn é o nome de uma credencial com a string de conexão. Bloqueado para scripts originados por MCP.

Método	Assinatura	Async	Descrição
listBuckets	(conn) → Promise<S3BucketInfo[]>	Sim	Lista buckets acessíveis
bucketExists	(conn, bucket) → Promise<boolean>	Sim	Verifica se o bucket existe
listObjects	(conn, bucket, options?) → Promise<S3ObjectInfo[]>	Sim	Lista objetos em um bucket
getObjectText	(conn, bucket, key) → Promise<string>	Sim	Baixa objeto como texto UTF-8
getObject	(conn, bucket, key, localPath) → Promise	Sim	Baixa objeto para arquivo local
putObjectText	(conn, bucket, key, content, contentType?) → Promise	Sim	Envia texto como objeto
putObject	(conn, bucket, key, localPath, contentType?) → Promise	Sim	Envia arquivo local como objeto
deleteObject	(conn, bucket, key) → Promise	Sim	Exclui um objeto
objectExists	(conn, bucket, key) → Promise<boolean>	Sim	Verifica se um objeto existe
createBucket	(conn, bucket, region?) → Promise	Sim	Cria um bucket
copyObject	(conn, srcBucket, srcKey, dstBucket, dstKey) → Promise	Sim	Cópia server-side sem passar dados pelo cliente
getPresignedUrl	(conn, bucket, key, options?) → Promise<string>	Sim	Gera URL pré-assinada com tempo limitado

---

## g.mongodb.* — MongoDB

Operações MongoDB via MongoDB.Driver. O parâmetro conn é o nome de uma credencial com a string de conexão. Usa agrupamento automático de conexões. Bloqueado para scripts originados por MCP.

Método	Assinatura	Async	Descrição
find	(conn, db, collection, filter?, options?) → Promise<object[]>	Sim	Encontra documentos correspondentes a um filtro
findOne	(conn, db, collection, filter?) → Promise<object | null>	Sim	Encontra o primeiro documento correspondente
insertOne	(conn, db, collection, document) → Promise<MongoInsertResult>	Sim	Insere um documento
insertMany	(conn, db, collection, documents) → Promise<MongoInsertManyResult>	Sim	Insere vários documentos
updateOne	(conn, db, collection, filter, update) → Promise<MongoUpdateResult>	Sim	Atualiza o primeiro documento correspondente
updateMany	(conn, db, collection, filter, update) → Promise<MongoUpdateResult>	Sim	Atualiza todos os documentos correspondentes
deleteOne	(conn, db, collection, filter) → Promise<MongoDeleteResult>	Sim	Exclui o primeiro documento correspondente
deleteMany	(conn, db, collection, filter) → Promise<MongoDeleteResult>	Sim	Exclui todos os documentos correspondentes
replaceOne	(conn, db, collection, filter, replacement) → Promise<MongoUpdateResult>	Sim	Substitui o primeiro documento correspondente
countDocuments	(conn, db, collection, filter?) → Promise<number>	Sim	Conta documentos correspondentes
listDatabases	(conn) → Promise<string[]>	Sim	Lista nomes de bancos
listCollections	(conn, db) → Promise<string[]>	Sim	Lista coleções em um banco
aggregate	(conn, db, collection, pipeline) → Promise<object[]>	Sim	Executa um fluxo de agregação
createIndex	(conn, db, collection, keys, options?) → Promise<string>	Sim	Cria índice e retorna o nome
dropCollection	(conn, db, collection) → Promise	Sim	Remove uma coleção
distinct	(conn, db, collection, fieldName, filter?) → Promise<any[]>	Sim	Obtém valores distintos de um campo
bulkWrite	(conn, db, collection, operations) → Promise<MongoBulkWriteResult>	Sim	Executa várias escritas em lote

Exemplo

async function main() {
  const conn = "my-mongo";

  const result = await g.mongodb.insertOne(conn, "extracao", "products", {
    name: "Widget", price: 9.99, category: "tools"
  });
  g.log("Inserido: " + result.insertedId);

  const docs = await g.mongodb.find(conn, "extracao", "products",
    { price: { $lt: 20 } },
    { sort: { price: 1 }, limit: 10 }
  );
  g.log("Encontrados " + docs.length + " produtos baratos");
}

---

## g.postgres.* — PostgreSQL

Operações PostgreSQL via Npgsql. Use parâmetros posicionais $1, $2, …; nunca interpole valores em strings SQL. O parâmetro conn é o nome de uma credencial com a string de conexão. Usa agrupamento automático de conexões. Bloqueado para scripts originados por MCP.

Método	Assinatura	Async	Descrição
query	(conn, sql, params?) → Promise<object[]>	Sim	SELECT retornando todas as linhas
queryOne	(conn, sql, params?) → Promise<object | null>	Sim	SELECT retornando a primeira linha
execute	(conn, sql, params?) → Promise<PgExecuteResult>	Sim	INSERT/UPDATE/DELETE
scalar	(conn, sql, params?) → Promise<any>	Sim	Retorna a primeira coluna da primeira linha
transaction	(conn, callback) → Promise<any>	Sim	Executa callback em uma transação (JS apenas)
executeBatch	(conn, statements) → Promise<PgBatchResult>	Sim	Várias instruções em uma transação
copyFrom	(conn, table, rows, options?) → Promise<PgCopyResult>	Sim	Inserção em lote via protocolo COPY
copyTo	(conn, query, options?) → Promise<string[][]>	Sim	Exportação em lote via protocolo COPY
listDatabases	(conn) → Promise<string[]>	Sim	Lista bancos não-template
listSchemas	(conn, options?) → Promise<string[]>	Sim	Lista esquemas
listTables	(conn, schema?) → Promise<PgTableInfo[]>	Sim	Lista tabelas e visões com estimativa de linhas
describeTable	(conn, table, schema?) → Promise<PgColumnInfo[]>	Sim	Metadados de colunas
listIndexes	(conn, table, schema?) → Promise<PgIndexInfo[]>	Sim	Metadados de índices
listConstraints	(conn, table, schema?) → Promise<PgConstraintInfo[]>	Sim	Metadados de restrições

Exemplo

async function main() {
  const conn = "my-postgres";

  const rows = await g.postgres.query(conn,
    "SELECT id, name, price FROM products WHERE price < $1 ORDER BY price",
    [20.00]
  );
  g.log("Encontrados " + rows.length + " produtos");

  const copyResult = await g.postgres.copyFrom(conn, "products", [
    ["Widget A", 9.99, 100],
    ["Widget B", 14.99, 50]
  ], { columns: ["name", "price", "stock"] });
  g.log("Importadas " + copyResult.rowsCopied + " linhas");
}

---

## g.elasticsearch.* — Elasticsearch

Suporte nativo para consultar e indexar dados em clusters Elasticsearch externos usando Elastic.Clients.Elasticsearch. O parâmetro conn é o nome de uma credencial contendo o objeto JSON de conexão (url e apiKey ou username/password opcionais). Bloqueado para scripts originados por MCP.

Método	Assinatura	Async	Descrição
ping	(conn) → Promise<boolean>	Sim	Verifica conexão com o cluster
info	(conn) → Promise<ElasticsearchInfoResult>	Sim	Obtém metadados do cluster
createIndex	(conn, indexName, mappingJson?) → Promise<boolean>	Sim	Cria índice com mapping JSON opcional
deleteIndex	(conn, indexName) → Promise<boolean>	Sim	Exclui índice existente
index	(conn, indexName, id, document) → Promise<boolean>	Sim	Indexa um objeto JS no cluster
get	(conn, indexName, id) → Promise<any>	Sim	Obtém documento por ID
bulk	(conn, indexName, documents, chunkSize?) → Promise<ElasticsearchBulkResult>	Sim	Ingestão de alto throughput com chunking automático
search	(conn, indexName, queryDsl) → Promise<any>	Sim	Executa Query DSL JSON bruto ou objeto JS

Exemplo

async function main() {
  const conn = "my-elastic";

  const isUp = await g.elasticsearch.ping(conn);
  if (!isUp) return g.log("Conexão falhou");

  const docs = [{ id: 1, text: "A" }, { id: 2, text: "B" }];
  const bulkRes = await g.elasticsearch.bulk(conn, "products", docs, 1000);
  g.log(`Indexados ${bulkRes.successful} de ${bulkRes.total}`);

  const searchRes = await g.elasticsearch.search(conn, "products", {
    query: { match_all: {} }
  });
  g.log(`Total de hits: ${searchRes.hits.total.value}`);
}