v3/packages/api/utils/kv.ts

export class WrappedKVNamespace {
    constructor(private kvNamespace: KVNamespace) {}

    async get<T>(key: string): Promise<T | null> {
        const data = await this.kvNamespace.get(key, 'text');
        if (!data) {
            return null;
        }

        return JSON.parse(data) as T;
    }

    async put<T>(key: string, value: T, ttlSeconds?: number) {
        await this.kvNamespace.put(key, JSON.stringify(value), {
            expirationTtl: ttlSeconds,
        });
    }

    list = this.kvNamespace.list;
    getWithMetadata = this.kvNamespace.getWithMetadata;
    delete = this.kvNamespace.delete;
}

class EmulatedKV implements KVNamespace {
    constructor() {
        console.warn('EmulatedKV used. Data will be lost.');
    }

    private data: Map<string, any> = new Map();

    async get<T>(key: string): Promise<T | null> {
        if (!this.data.has(key)) {
            return null;
        }

        return this.data.get(key);
    }

    async getWithMetadata<T, Metadata = unknown>(
        key: string
    ): KVValueWithMetadata<T, Metadata> {
        return {
            value: await this.get<T>(key),
            metadata: {} as Metadata,
        };
    }

    async put(key: string, value: string | ReadableStream<any> | ArrayBuffer | FormData) {
        this.data.set(key, value);
    }

    async delete(key: string) {
        this.data.delete(key);
    }

    async list(options?: {
        prefix?: string;
        limit?: number;
        cursor?: string;
    }): Promise<{
        keys: { name: string; expiration?: number; metadata?: unknown }[];
        list_complete: boolean;
        cursor: string;
    }> {
        let keys: { name: string }[] = [];

        for (let key of this.data.keys()) {
            if (options?.prefix && !key.startsWith(options.prefix)) {
                continue;
            }

            keys.push({ name: key });
        }

        return {
            keys,
            cursor: '0',
            list_complete: true,
        };
    }
}

const kvOrLocal = (namespace: KVNamespace | null): KVNamespace =>
    namespace || new EmulatedKV();

const self = (global as any) as Record<string, any>;

export const Sessions = new WrappedKVNamespace(kvOrLocal(self.KV_SESSIONS ?? null));
export const GuildData = new WrappedKVNamespace(kvOrLocal(self.KV_GUILD_DATA ?? null));
export const Guilds = new WrappedKVNamespace(kvOrLocal(self.KV_GUILDS ?? null));