Integrations

const response = await fetch("https://countries.trevorblades.com/", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    query: `{ countries { code name capital currency languages { code name native } continent { code name } states { code name } } }`,
  }),
});

const json = await response.json();
const country = json.data.countries.find((c) => c.code === "BR");

const GET_COUNTRY = `
  query GetCountry($code: ID!) {
    country(code: $code) {
      name
      capital
      currency

      languages {
        name
      }

      continent {
        name
      }
    }
  }
`;

async function fetchCountry(code) {
  const response = await fetch("https://countries.trevorblades.com/", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      query: GET_COUNTRY,
      variables: { code },
    }),
  });

  const { data, errors } = await response.json();
  const [firstError] = errors ?? [];
  if (firstError) throw new Error(firstError.message);

  const country = data.country;
  return country;
}

import { DOMParser } from "@xmldom/xmldom";

const doc = new DOMParser().parseFromString(xml, "text/xml");

// sem namespace: não encontra o nó em documento fiscal com prefixo nfe:
const invoiceNumber = doc.getElementsByTagName("nNF")[0].textContent;

import { DOMParser } from "@xmldom/xmldom";

const NS = "http://www.portalfiscal.inf.br/nfe";

function extractInvoiceNumber(xml) {
  const doc = new DOMParser().parseFromString(xml, "text/xml");

  const ide = doc.getElementsByTagNameNS(NS, "ide")[0];
  const invoiceNumber =
    ide?.getElementsByTagNameNS(NS, "nNF")[0]?.textContent ?? null;

  const hasInvoiceNumber = invoiceNumber !== null;
  if (!hasInvoiceNumber)
    throw new ValidationError({ message: "Invoice number not found in XML." });

  return invoiceNumber;
}

const fields = line.replace(/^\||\|$/g, "").split("|");

const companyRegistrationNumber = fields[6]; // CNPJ
const companyName = fields[5];
const periodStart = fields[3];

function parseRecord0000(line) {
  const fields = line.replace(/^\||\|$/g, "").split("|");

  const record = {
    periodStart: fields[3],
    periodEnd: fields[4],
    companyName: fields[5],
    companyRegistrationNumber: fields[6], // CNPJ
  };

  return record;
}

const bankCode = line.slice(0, 3);
const serviceBatch = line.slice(3, 7);
const recordType = line.slice(7, 8);
const companyRegistrationNumber = line.slice(18, 32); // CNPJ

const CNAB240_HEADER = {
  bankCode: { pos: 0, len: 3 },
  serviceBatch: { pos: 3, len: 4 },
  recordType: { pos: 7, len: 1 },
  companyRegistrationNumber: { pos: 18, len: 14 }, // CNPJ
};

function extractField(line, { pos, len }) {
  const field = line.slice(pos, pos + len);
  return field;
}

const bankCode = extractField(line, CNAB240_HEADER.bankCode);
const companyRegistrationNumber = extractField(
  line,
  CNAB240_HEADER.companyRegistrationNumber,
); // CNPJ

const zpl =
  "^XA^FO50,50^A0N,30,30^FD" +
  product.name +
  "^FS" +
  "^FO50,100^BCN,80,Y,N,N^FD" +
  product.barcode +
  "^FS" +
  "^FO50,200^A0N,20,20^FDLote: " +
  product.lot +
  "^FS^XZ";

port.write(zpl);

function buildProductLabel({ name: productName, barcode, lot: lotNumber }) {
  const label = [
    "^XA",
    `^FO50,50^A0N,30,30^FD${productName}^FS`,
    `^FO50,100^BCN,80,Y,N,N^FD${barcode}^FS`,
    `^FO50,200^A0N,20,20^FDLote: ${lotNumber}^FS`,
    "^XZ",
  ].join("\n");

  return label;
}

const label = buildProductLabel(product);
port.write(label);

import { SerialPort } from "serialport";
import { ReadlineParser } from "@serialport/parser-readline";

const port = new SerialPort({ path: "COM3", baudRate: 9600 });
const parser = port.pipe(new ReadlineParser({ delimiter: "\r\n" }));

parser.on("data", (rawLine) => {
  const weight = parseWeight(rawLine);
});

import { SerialPort } from "serialport";
import { ReadlineParser } from "@serialport/parser-readline";

function readWeight(path = "COM3") {
  const weightReading = new Promise((resolve, reject) => {
    const port = new SerialPort({ path, baudRate: 9600 });
    const parser = port.pipe(new ReadlineParser({ delimiter: "\r\n" }));

    const responseTimeout = setTimeout(() => {
      port.close();
      reject(new Error("Balança não respondeu no tempo esperado."));
    }, 2000);

    parser.once("data", (rawLine) => {
      clearTimeout(responseTimeout);
      port.close();

      const weight = parseWeight(rawLine);
      resolve(weight);
    });

    port.on("error", (serialError) => {
      clearTimeout(responseTimeout);
      reject(serialError);
    });
  });

  return weightReading;
}

const client = new Anthropic({ apiKey: "sk-ant-..." });

const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [{ role: "user", content: prompt }],
});

console.log(message.content[0].text);

const stream = client.messages.stream({
  model: "claude-sonnet-4-6",
  max_tokens: 1024,
  messages: [{ role: "user", content: prompt }],
});

for await (const chunk of stream) {
  if (chunk.type === "content_block_delta") {
    process.stdout.write(chunk.delta.text);
  }
}

const response = await fetch(apiUrl, options);

if (!response.ok) {
  throw new Error("API error");
}

async function callWithRetry(requestFn, maxAttempts = 3) {
  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
    const response = await requestFn();

    if (response.status !== 429) {
      return response;
    }

    const delayMs = Math.pow(2, attempt) * 1000;
    await new Promise((resolve) => setTimeout(resolve, delayMs));
  }

  throw new Error("Rate limit exceeded after retries");
}