# Compatibilidade APIs Node.js - Process

O módulo `process` no Node.js é um objeto global que fornece informações e controle sobre o processo Node.js atual. É essencial para interagir com o ambiente de execução e gerenciar a execução de aplicações Node.js. Este módulo está disponível no Azion Runtime através da compatibilidade com Node.js, onde um caso de uso frequente é ler variáveis de ambiente, como `process.env`, ou agendar trabalho com `nextTick` dentro de uma function.

---

## Exemplo: Variáveis de ambiente e nextTick

O exemplo abaixo mostra como usar o módulo `process` em uma function:

```javascript
/**
 * An example of using the Node.js Process API in an Azion Function.
 * Support:
 *  - Extended by library `process`
 *    Portions of this file Copyright Roman Shtylman, licensed under the MIT license.
 * @module runtime-apis/nodejs/process/main
 * @example
 * // Execute with Azion Bundler:
 * npx edge-functions build
 * npx edge-functions dev
 */
import { env, nextTick } from "node:process";

/**
 * Example of using the process api
 * @param {*} event
 */
const main = async (event) => {
  console.log(process.env.NODE_ENV);

  nextTick(() => {
    console.log("Hello, Next Tick!");
    // Hello, Next Tick!
  });

  return new Response(`NODE_ENV: ${process.env.NODE_ENV}`, { status: 200 });
};

export default main;
```

---

## Exemplo: Lendo configuração de variáveis de ambiente

Acesse valores de configuração armazenados em variáveis de ambiente:

```javascript
import process from "node:process";

const main = async (event) => {
  // Read environment variables
  const nodeEnv = process.env.NODE_ENV || "development";
  const apiKey = process.env.API_KEY;
  const debug = process.env.DEBUG === "true";
  const maxRetries = parseInt(process.env.MAX_RETRIES || "3", 10);

  console.log("Environment:", nodeEnv);
  console.log("Debug mode:", debug);
  console.log("Max retries:", maxRetries);

  // Check if required variables are set
  if (!apiKey) {
    console.warn("API_KEY not configured");
  }

  // Build configuration object
  // Security: Never expose sensitive env vars in responses
  // Use boolean flags instead of actual values
  const config = {
    environment: nodeEnv,
    debug,
    maxRetries,
    hasApiKey: !!apiKey  // Boolean only, not the actual key
  };

  return new Response(JSON.stringify(config), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

---

## Exemplo: Usando nextTick para execução adiada

Agende trabalho para executar após a operação atual ser concluída:

```javascript
import { nextTick } from "node:process";
import { setTimeout } from "node:timers/promises";

const main = async (event) => {
  const executionOrder = [];

  executionOrder.push("Start");

  // Schedule with nextTick - runs after current code
  // Note: nextTick execution order may differ from standard Node.js
  // in edge runtime environments
  nextTick(() => {
    executionOrder.push("NextTick callback");
    console.log("Deferred execution completed");
  });

  executionOrder.push("After nextTick call");

  // Multiple nextTick calls execute in order
  nextTick(() => {
    executionOrder.push("Second nextTick");
  });

  // Wait for nextTick callbacks to execute
  await setTimeout(10);

  executionOrder.push("End");

  console.log("Execution order:", executionOrder.join(" -> "));

  return new Response(JSON.stringify({ executionOrder }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

---

## Exemplo: Informações do processo e detecção de plataforma

Acesse informações de runtime sobre o processo:

```javascript
import process from "node:process";

const main = async (event) => {
  // Note: In Azion Runtime, some process properties may return
  // fixed or environment-specific values:
  // - process.pid may always return a fixed value
  // - process.arch reflects the edge node architecture
  // - process.versions may not include all Node.js version fields

  // Platform information
  const platform = process.platform;
  const arch = process.arch;
  const versions = process.versions;

  // Process identification
  const pid = process.pid;
  const ppid = process.ppid;

  // Runtime information
  const nodeVersion = process.version;
  const v8Version = versions.v8;

  console.log("Platform:", platform);
  console.log("Architecture:", arch);
  console.log("Node version:", nodeVersion);
  console.log("V8 version:", v8Version);
  console.log("Process ID:", pid);

  // Build info object with fallbacks for potentially undefined values
  const processInfo = {
    platform,
    arch,
    pid,
    ppid,
    nodeVersion,
    v8Version,
    versions: {
      node: versions.node || "unknown",
      v8: versions.v8 || "unknown",
      openssl: versions.openssl || "unknown"
    }
  };

  return new Response(JSON.stringify(processInfo, null, 2), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

---

## Exemplo: Monitoramento de uso de memória

Monitore o consumo de memória durante a execução:

```javascript
import process from "node:process";

const main = async (event) => {
  // Get initial memory usage
  const initialMemory = process.memoryUsage();

  // Simulate some work
  const data = [];
  for (let i = 0; i < 1000; i++) {
    data.push({ id: i, data: "x".repeat(100) });
  }

  // Get memory usage after work
  const finalMemory = process.memoryUsage();

  // Calculate memory delta
  const memoryDelta = {
    rss: finalMemory.rss - initialMemory.rss,
    heapTotal: finalMemory.heapTotal - initialMemory.heapTotal,
    heapUsed: finalMemory.heapUsed - initialMemory.heapUsed,
    external: finalMemory.external - initialMemory.external
  };

  console.log("Initial heap used:", initialMemory.heapUsed, "bytes");
  console.log("Final heap used:", finalMemory.heapUsed, "bytes");
  console.log("Memory delta:", memoryDelta.heapUsed, "bytes");

  return new Response(JSON.stringify({
    initial: {
      rss: initialMemory.rss,
      heapTotal: initialMemory.heapTotal,
      heapUsed: initialMemory.heapUsed
    },
    final: {
      rss: finalMemory.rss,
      heapTotal: finalMemory.heapTotal,
      heapUsed: finalMemory.heapUsed
    },
    delta: memoryDelta
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

export default main;
```

---

## Exemplo: Uptime e temporização

Acompanhe o uptime do processo para monitoramento de saúde:

```javascript
import process from "node:process";
import { setTimeout } from "node:timers/promises";

const main = async (event) => {
  // Get process uptime in seconds
  const uptime = process.uptime();

  // Get high-resolution time
  const hrtime = process.hrtime();
  const hrtimeBigint = process.hrtime.bigint();

  console.log("Process uptime:", uptime, "seconds");
  console.log("High-res time:", hrtime);
  console.log("High-res time (bigint):", hrtimeBigint.toString(), "nanoseconds");

  // Calculate elapsed time for an operation
  const start = process.hrtime.bigint();

  // Simulate work
  await setTimeout(100);

  const end = process.hrtime.bigint();
  const elapsedNs = Number(end - start);
  const elapsedMs = elapsedNs / 1_000_000;

  console.log("Operation took:", elapsedMs.toFixed(2), "ms");

  return new Response(JSON.stringify({
    uptime: {
      seconds: uptime,
      formatted: formatUptime(uptime)
    },
    hrtime: {
      seconds: hrtime[0],
      nanoseconds: hrtime[1]
    },
    operationTime: {
      nanoseconds: elapsedNs,
      milliseconds: elapsedMs
    }
  }), {
    headers: { "Content-Type": "application/json" }
  });
};

// Helper function defined before export
function formatUptime(seconds) {
  const hours = Math.floor(seconds / 3600);
  const minutes = Math.floor((seconds % 3600) / 60);
  const secs = Math.floor(seconds % 60);
  return `${hours}h ${minutes}m ${secs}s`;
}

export default main;
```

---

## APIs com suporte

| API | Status |
|-----|--------|
| `process.env` | 🟢 Com suporte |
| `process.nextTick()` | 🟢 Com suporte |
| `process.platform` | 🟢 Com suporte |
| `process.arch` | 🟢 Com suporte |
| `process.version` | 🟢 Com suporte |
| `process.versions` | 🟢 Com suporte |
| `process.pid` | 🟢 Com suporte |
| `process.ppid` | 🟢 Com suporte |
| `process.uptime()` | 🟢 Com suporte |
| `process.hrtime()` | 🟢 Com suporte |
| `process.hrtime.bigint()` | 🟢 Com suporte |
| `process.memoryUsage()` | 🟢 Com suporte |
| `process.cwd()` | 🟡 Parcialmente suportado |
| `process.exit()` | 🟡 Parcialmente suportado |
| `process.on()` | 🟡 Parcialmente suportado |
| `process.argv` | 🟡 Parcialmente suportado |
| `process.title` | 🟡 Parcialmente suportado |

:::note
APIs marcadas como 🟡 Parcialmente suportado têm funcionalidade limitada em comparação com a implementação completa do Node.js. No Azion Runtime, `process.cwd()` retorna um caminho fixo em vez do diretório de trabalho atual, `process.exit()` não termina o processo do runtime, `process.argv` retorna um array fixo ou vazio, e `process.on()` tem suporte limitado de eventos. Para configuração de ambiente, prefira `process.env` que tem suporte completo.
:::

---

## Recursos relacionados

- [Documentação do `process` no Node.js](https://nodejs.org/api/process.html)