PlayerStorageAdapter

namespace: string;

The namespace of the storage.

console.log(storage.namespace); // "hoshimiplayer"

readonly guildId: string;

the guild id of the player storage adapter. This is used to identify the player storage adapter.

console.log(storage.guildId); // "123456789012345678"

get prefix(): string;

Get the prefix for the storage keys. This is used to prevent key collisions between different player storage adapters.

console.log(storage.prefix); // "hoshimiplayer:123456789012345678"

const key = storage.buildKey("key");
console.log(key); // "hoshimiplayer:123456789012345678:key"

constructor(guildId: string);

strip(key: string): string;

Strip the prefix from the key. This is used to get the original key from the stored key.

const key = storage.buildKey("key");
console.log(key); // "hoshimiplayer:123456789012345678:key"

const originalKey = storage.strip(key);
console.log(originalKey); // "key"

isInternal(key: string): boolean;

Check if the key is an internal key. Internal keys are used to store internal data for the player storage adapter and should not be exposed to the user.

const internalKey = "internal_key";
console.log(storage.isInternal(internalKey)); // true

const userKey = "user_key";
console.log(storage.isInternal(userKey)); // false

abstract get<K extends StorageKeys, V extends StorageValues<K>>(key: K): Awaitable<V | undefined>;

Get the value using the key.

const value = await storage.get("key");
console.log(value); // "value"

abstract set<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): Awaitable<void>;

Set the value using the key.

await storage.set("key", "value");

abstract delete<K extends StorageKeys>(key: K): Awaitable<boolean>;

Delete the value using the key.

const success = await storage.delete("key");
console.log(success); // true

abstract clear(): Awaitable<void>;

Clear the storage.

await storage.clear();

abstract has<K extends StorageKeys>(key: K): Awaitable<boolean>;

Check if the storage has the key.

const exists = await storage.has("key");
console.log(exists); // true

abstract keys<K extends StorageKeys[]>(): Awaitable<K[]>;

Get all keys in the storage.

const keys = await storage.keys();
console.log(keys); // ["key1", "key2"]

abstract values<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<V[]>;

Get all values in the storage.

const values = await storage.values();
console.log(values); // ["value1", "value2"]

abstract entries<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<[    K,    V][]>;

Get all entries in the storage.

const entries = await storage.entries();
console.log(entries); // [["key1", "value1"], ["key2", "value2"]]

abstract all<K extends StorageKeys[], V extends StorageValues<K[number]>>(): Awaitable<Record<K[number], V>>;

Get all key-value pairs in the storage.

const all = await storage.all();
console.log(all); // { key1: "value1", key2: "value2" }

abstract size(): Awaitable<number>;

Get the size of the storage.

const size = await storage.size();
console.log(size); // 2

abstract destroy(): Awaitable<void>;

Destroy the storage. This is called when the player is destroyed.

await storage.destroy();

abstract setIfAbsent<K extends StorageKeys, V extends StorageValues<K>>(key: K, value: V): Awaitable<boolean>;

Set the value if the key does not exist in the storage.

const success = await storage.setIfAbsent("key", "value");
console.log(success); // true

const success2 = await storage.setIfAbsent("key", "newValue");
console.log(success2); // false

const value = await storage.get("key");
console.log(value); // "value"

buildKey(...parts: RestOrArray<string>): string;

Build a key from the given parts.

const key = storage.buildKey("part1", "part2", "part3");