https://api.azion.com/v4/workspace/kv/namespaces

{
  "name": "meu-namespace",
  "created_at": "2025-01-24T14:15:22Z",
  "last_modified": "2025-01-24T14:15:22Z"
}

// Usando o namespace padrão
const kv = new Azion.KV();

// Usando um namespace específico
const kv = new Azion.KV("meu-namespace");

// Usando o método open
const kv = await Azion.KV.open("meu-namespace");

async function handleRequest(request) {
    const kv = new Azion.KV();
    const key = "sessao-usuario";

    // Armazenar um valor string
    await kv.put(key, "dados-da-sessao-aqui");

    // Armazenar um objeto JSON
    await kv.put(key, { userId: 123, role: "admin" });

    // Armazenar um ArrayBuffer
    const encoder = new TextEncoder();
    const buffer = encoder.encode("dados binários").buffer;
    await kv.put(key, buffer);

    // Armazenar com opções (metadados e expiração)
    await kv.put(key, "valor", {
        metadata: { created_by: "user-42" },
        expiration: Math.floor(Date.now() / 1000) + 3600, // expira em 1 hora
        expirationTtl: 3600 // alternativa: TTL em segundos
    });

    return new Response("Dados armazenados", { status: 200 });
}

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const kv = new Azion.KV();
    const key = "arquivo-grande";
    const dataSizeInKB = 500;
    const totalSize = dataSizeInKB * 1024;
    const chunkSize = 64 * 1024; // chunks de 64KB

    const stream = new ReadableStream({
        async start(controller) {
            const encoder = new TextEncoder();
            const numChunks = Math.ceil(totalSize / chunkSize);

            for (let i = 0; i < numChunks; i++) {
                const currentChunkSize = Math.min(chunkSize, totalSize - i * chunkSize);
                const chunk = "a".repeat(currentChunkSize);
                controller.enqueue(encoder.encode(chunk));
            }
            controller.close();
        },
    });

    await kv.put(key, stream);

    return new Response("Dados grandes armazenados", { status: 200 });
}

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const kv = new Azion.KV();
    const key = "sessao-usuario";

    // Obter como texto (padrão)
    const textValue = await kv.get(key, "text");

    // Obter como JSON
    const jsonValue = await kv.get(key, "json");
    console.log(`User ID: ${jsonValue.userId}`);

    // Obter como ArrayBuffer
    const bufferValue = await kv.get(key, "arrayBuffer");
    const decoder = new TextDecoder("utf-8");
    const decodedString = decoder.decode(bufferValue);

    // Obter como ReadableStream
    const streamValue = await kv.get(key, "stream");

    // Tratar chaves inexistentes (retorna null)
    const missing = await kv.get("chave-inexistente", "text");
    if (missing === null) {
        console.log("Chave não encontrada");
    }

    return new Response(textValue, { status: 200 });
}

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const kv = new Azion.KV();

    const keys = ["usuario-1", "usuario-2", "usuario-3"];
    const data = await kv.get(keys, "text");

    // Retorna um objeto com pares chave-valor
    // Chaves inexistentes têm valores null
    console.log(JSON.stringify(data));

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

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const kv = new Azion.KV();
    const key = "sessao-usuario";

    // Armazenar com metadados
    await kv.put(key, "valor-sessao", {
        metadata: { created_by: "user-42", version: 1 }
    });

    // Recuperar com metadados
    const data = await kv.getWithMetadata(key, "text");
    console.log(`Valor: ${data.value}`);
    console.log(`Metadados: ${JSON.stringify(data.metadata)}`);

    // Funciona com múltiplas chaves também
    const keys = ["chave1", "chave2"];
    const multiData = await kv.getWithMetadata(keys, "text");

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

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const kv = new Azion.KV();
    const key = "arquivo-grande";

    const stream = await kv.get(key, "stream");

    if (stream instanceof ReadableStream) {
        const decoder = new TextDecoder();
        let text = "";

        for await (const chunk of stream) {
            text += decoder.decode(chunk, { stream: true });
        }
        text += decoder.decode();

        console.log(`Recuperados ${text.length} caracteres`);
    }

    // Ou retorne o stream diretamente na resposta
    return new Response(stream);
}

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const kv = new Azion.KV();
    const key = "sessao-usuario";

    await kv.delete(key);

    return new Response("Chave excluída", { status: 200 });
}

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const kv = new Azion.KV();

    // Chave UTF-16 (Chinês: "Minha Chave")
    const key = "我的钥匙";

    // Valor UTF-16 com emojis
    const value = "🌍🌎🌏 Hello World 你好 世界";

    await kv.put(key, value);

    const retrieved = await kv.get(key, "text");
    console.log(`Chave: ${key}, Valor: ${retrieved}`);

    return new Response("OK", { status: 200 });
}

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});

async function handleRequest(request) {
    const namespaceName = "meu-namespace";

    // Excluir o namespace
    await Azion.KV.delete(namespaceName);

    return new Response("Namespace excluído", { status: 200 });
}

addEventListener("fetch", (event) => {
    event.respondWith(handleRequest(event.request));
});