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

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

// Using the default namespace
const kv = new Azion.KV();

// Using a specific namespace
const kv = new Azion.KV("my-namespace");

// Using the open method
const kv = await Azion.KV.open("my-namespace");

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

    // Store a string value
    await kv.put(key, "session-data-here");

    // Store a JSON object
    await kv.put(key, { userId: 123, role: "admin" });

    // Store an ArrayBuffer
    const encoder = new TextEncoder();
    const buffer = encoder.encode("binary data").buffer;
    await kv.put(key, buffer);

    // Store with options (metadata and expiration)
    await kv.put(key, "value", {
        metadata: { created_by: "user-42" },
        expiration: Math.floor(Date.now() / 1000) + 3600, // expires in 1 hour
        expirationTtl: 3600 // alternative: TTL in seconds
    });

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

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

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

    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("Large data stored", { status: 200 });
}

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

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

    // Get as text (default)
    const textValue = await kv.get(key, "text");

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

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

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

    // Handle non-existent keys (returns null)
    const missing = await kv.get("non-existent-key", "text");
    if (missing === null) {
        console.log("Key not found");
    }

    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 = ["user-1", "user-2", "user-3"];
    const data = await kv.get(keys, "text");

    // Returns an object with key-value pairs
    // Non-existent keys have null values
    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 = "user-session";

    // Store with metadata
    await kv.put(key, "session-value", {
        metadata: { created_by: "user-42", version: 1 }
    });

    // Retrieve with metadata
    const data = await kv.getWithMetadata(key, "text");
    console.log(`Value: ${data.value}`);
    console.log(`Metadata: ${JSON.stringify(data.metadata)}`);

    // Works with multiple keys too
    const keys = ["key1", "key2"];
    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 = "large-file";

    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(`Retrieved ${text.length} characters`);
    }

    // Or return the stream directly in a response
    return new Response(stream);
}

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

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

    await kv.delete(key);

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

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

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

    // UTF-16 key (Chinese: "My Key")
    const key = "我的钥匙";

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

    await kv.put(key, value);

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

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

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

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

    // Delete the namespace
    await Azion.KV.delete(namespaceName);

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

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