lunibee 0.1.5 → 0.1.7

package/dist/managers/message.d.ts

@@ -1,25 +1,20 @@
 import { Collection } from "@lunibee/collection";
 import { REST } from "@lunibee/rest";
 import { Message, type ResourceContext } from "@lunibee/structures";
-/** Manages message resources belonging to a single channel with canonical identity. */
+export type MessageCreateOptions = Record<string, unknown> & {
+    content?: string;
+};
+export type MessageEditOptions = Record<string, unknown> & {
+    content?: string;
+};
 export declare class MessageManager {
     #private;
-    /** Canonical message cache for this channel. */
     readonly cache: Collection<string, Message>;
-    /** Creates a message manager. @param rest REST transport. @param context Structure resource context. @param channelId Channel identifier. @throws {TypeError} If channelId is empty. */
     constructor(rest: REST, context: ResourceContext, channelId: string);
-    /** Resolves a message from cache or REST. @param messageId Message identifier. @returns Canonical message. */
     resolve(messageId: string): Promise<Message>;
-    /** Sends a message and caches it canonically. @param options Message payload. @returns Canonical message. */
-    send(options: {
-        content?: string;
-    }): Promise<Message>;
-    /** Fetches one message and caches it canonically. @param messageId Message identifier. @returns Canonical message. */
+    send(options: MessageCreateOptions): Promise<Message>;
     fetch(messageId: string): Promise<Message>;
-    /** Fetches several messages by ID. @param messageIds Message identifiers. @returns Canonical messages. */
     fetchMany(messageIds: Iterable<string>): Promise<Message[]>;
-    /** Inserts or updates a message through the shared hydration path. @param data Discord message payload. @returns Canonical message. */
     upsert(data: ConstructorParameters<typeof Message>[0]): Message;
-    /** Removes a message from cache. @param messageId Message identifier. @returns Whether a cached message was removed. */
     delete(messageId: string): boolean;
 }

package/dist/managers/user.d.ts

@@ -0,0 +1,20 @@
+import { ResourceManager } from "./base.js";
+import { User } from "@lunibee/structures";
+import { type REST } from "@lunibee/rest";
+import type { APIChannel } from "@lunibee/types";
+export interface UserEditOptions {
+    username?: string;
+    avatar?: string | null;
+}
+export declare class UserManager extends ResourceManager<string, User> {
+    #private;
+    constructor(rest: REST);
+    /** Gets the currently logged-in bot user. */
+    fetchMe(): Promise<User>;
+    /** Modifies the currently logged-in bot user. */
+    editMe(options: UserEditOptions): Promise<User>;
+    /** Leaves a guild. */
+    leaveGuild(guildId: string): Promise<void>;
+    /** Creates a DM channel with a user. */
+    createDM(userId: string): Promise<APIChannel>;
+}

package/dist/rest/index.d.ts

@@ -1 +1,173 @@
-export * from "./../../packages/rest/src/index.ts";
+/** Error thrown when Discord rejects a REST request. */
+export declare class RESTError extends Error {
+    /** HTTP status returned by Discord. */ readonly status: number;
+    /** Discord API error code, when provided. */ readonly code?: number;
+    /** Raw Discord validation/error payload. */ readonly errors?: unknown;
+    /** HTTP method used for the failed request. */ readonly method?: string;
+    /** API path used for the failed request. */ readonly path?: string;
+    /** Creates a REST error with request context. @param message Error message. @param status HTTP status. @param code Discord error code. @param errors Raw error payload. @param options Request context and cause. */
+    constructor(message: string, status: number, code?: number, errors?: unknown, options?: {
+        method?: string;
+        path?: string;
+        cause?: unknown;
+    });
+}
+import { type RateLimitStore } from "./store.js";
+/** A file attachment sent as part of a multipart REST request. */
+export interface RESTFileAttachment {
+    name: string;
+    data: Blob | Uint8Array | ArrayBuffer;
+    contentType?: string;
+}
+/** Query-string value accepted by {@link RESTRequestOptions.query}. */
+export type RESTQuery = URLSearchParams | Record<string, string | number | boolean | null | undefined> | string;
+/**
+ * Options controlling an individual REST request.
+ *
+ * Lunibee's canonical call shape is positional (`post(path, body)`); these options
+ * add the Discord.js-`@discordjs/rest`-familiar per-request knobs (`query`, `headers`,
+ * `reason`, `auth`) additively without changing that positional default.
+ */
+export interface RESTRequestOptions {
+    /** Abort signal used to cancel the request and any queued wait. */ signal?: AbortSignal;
+    /** Query-string appended to the path (`URLSearchParams`, a record, or a raw string). */ query?: RESTQuery;
+    /** Extra request headers merged in (library headers such as `Authorization` win). */ headers?: Record<string, string>;
+    /** Audit-log reason, sent as the `X-Audit-Log-Reason` header. */ reason?: string;
+    /** Set `false` to omit the `Authorization` header for this request. Defaults to `true`. */ auth?: boolean;
+}
+/**
+ * Discord.js-familiar request payload. Superset of {@link RESTRequestOptions} that also
+ * carries the `body` and `files`, matching `@discordjs/rest`'s `RequestData`. It powers the
+ * additive `method(path, { body })` overloads without breaking the positional signature.
+ */
+export interface RequestData extends RESTRequestOptions {
+    /** Request body. Encoded as JSON unless `files` are present (then multipart). */ body?: unknown;
+    /** File attachments; presence upgrades the request to `multipart/form-data`. */ files?: RESTFileAttachment[];
+}
+/** Context passed to `RESTHooks.onRequest`. */
+export interface RESTRequestContext {
+    method: string;
+    path: string;
+    attempt: number;
+}
+/** Context passed to `RESTHooks.onResponse`. */
+export interface RESTResponseContext {
+    method: string;
+    path: string;
+    status: number;
+    durationMs: number;
+}
+/** Context passed to `RESTHooks.onRateLimit`. */
+export interface RESTRateLimitContext {
+    method: string;
+    path: string;
+    retryAfterMs: number;
+    global: boolean;
+    bucket?: string;
+}
+/** Context passed to `RESTHooks.onRetry`. */
+export interface RESTRetryContext {
+    method: string;
+    path: string;
+    attempt: number;
+    status: number;
+    delayMs: number;
+}
+/**
+ * Lightweight callback hooks for REST request lifecycle events.
+ *
+ * All callbacks are optional. They are dispatched in isolation from the request
+ * path (deferred to a microtask, and any thrown error is swallowed), so a hook
+ * cannot break or reject a request. Even so, hooks **must** be fast and
+ * non-blocking: heavy synchronous work in a hook still steals event-loop time
+ * from in-flight requests. Offload anything expensive to your own queue.
+ */
+export interface RESTHooks {
+    /** Called just before every HTTP attempt. */
+    onRequest?(ctx: RESTRequestContext): void;
+    /** Called after a successful or failed response is received. */
+    onResponse?(ctx: RESTResponseContext): void;
+    /** Called when a rate limit is encountered and the client is about to wait. */
+    onRateLimit?(ctx: RESTRateLimitContext): void;
+    /** Called when a failed request is about to be retried. */
+    onRetry?(ctx: RESTRetryContext): void;
+}
+/** Configures which REST failures may be retried. */
+export interface RetryPolicy {
+    /** Maximum retry attempts. */ maxRetries: number;
+    /** Determines whether a request may be retried. @param method HTTP method. @param status HTTP status, or zero for transport errors. @returns True when retrying is safe under the policy. */ shouldRetry(method: string, status: number): boolean;
+    /** Calculates delay before the next attempt. @param attempt Zero-based retry number. @param retryAfter Server-provided delay, when available. @returns Delay in milliseconds. */ getDelay(attempt: number, retryAfter?: number): number;
+}
+/** Creates the default conservative REST retry policy. @param maxRetries Maximum retries. @returns Retry policy that retries rate limits and idempotent transient failures. @throws {TypeError} If maxRetries is negative or not finite. */
+export declare function createRetryPolicy(maxRetries?: number): RetryPolicy;
+/** Bun-native REST transport with Discord bucket-aware rate limiting, retries, and cancellation. */
+export declare class REST {
+    #private;
+    /** Creates a REST transport. @param options Transport configuration. @throws {TypeError} If retry configuration is invalid. */
+    constructor(options?: {
+        token?: string;
+        timeout?: number;
+        retries?: number;
+        retryPolicy?: RetryPolicy;
+        baseURL?: string;
+        hooks?: RESTHooks;
+        store?: RateLimitStore;
+    });
+    /** Replaces the current hook set. Pass an empty object to clear all hooks. */
+    setHooks(hooks: RESTHooks): this;
+    /** Sets the authentication token. @param token Discord bot token. @returns Nothing. @throws {TypeError} If token is empty. */
+    setToken(token: string): void;
+    /** Executes an HTTP request with Discord bucket/global rate limits, retry handling, and AbortSignal support.
+     * Accepts a JSON body, a FormData body (for file uploads), or undefined.
+     * @param method HTTP method.
+     * @param path API path.
+     * @param body Optional JSON body, FormData for file uploads, or undefined.
+     * @param options Request options: cancellation `signal` plus the Discord.js-familiar
+     *   `query`, `headers`, `reason`, `auth`, and `files` (which upgrade to multipart).
+     * @returns Decoded response body.
+     * @throws {RESTError} If Discord or transport rejects the request.
+     */
+    request<T>(method: string, path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a GET request. @param path API path. @param options Request options (`query`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */ get<T>(path: string, options?: RequestData): Promise<T>;
+    /** Sends a POST request. Accepts a raw body (`post(path, body)`) or a Discord.js-familiar `post(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
+    post<T>(path: string, options: RequestData): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a PATCH request. Accepts a raw body (`patch(path, body)`) or a Discord.js-familiar `patch(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
+    patch<T>(path: string, options: RequestData): Promise<T>;
+    patch<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a PUT request. Accepts a raw body (`put(path, body)`) or a Discord.js-familiar `put(path, { body })`. @param path API path. @param body Optional JSON body, or a `RequestData` wrapper. @param options Request options. @returns Decoded response. @throws {RESTError} When the request fails. */
+    put<T>(path: string, options: RequestData): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestData): Promise<T>;
+    /** Sends a DELETE request. @param path API path. @param options Request options (`reason`, `headers`, `signal`, …). @returns Decoded response. @throws {RESTError} When the request fails. */ delete<T>(path: string, options?: RequestData): Promise<T>;
+    /**
+     * Sends a multipart/form-data POST request for file uploads.
+     * Attaches a JSON payload as `payload_json` and files as additional fields.
+     * @param path API path.
+     * @param payload JSON payload (e.g. message content, embeds).
+     * @param files Array of file attachments.
+     * @param options Cancellation options.
+     * @returns Decoded response.
+     * @throws {RESTError} When the request fails.
+     */
+    postWithFiles<T>(path: string, payload: unknown, files: RESTFileAttachment[], options?: RESTRequestOptions): Promise<T>;
+    /**
+     * Sends a multipart/form-data PATCH request for editing messages with files.
+     * @param path API path.
+     * @param payload JSON payload.
+     * @param files Array of file attachments.
+     * @param options Cancellation options.
+     * @returns Decoded response.
+     * @throws {RESTError} When the request fails.
+     */
+    patchWithFiles<T>(path: string, payload: unknown, files: RESTFileAttachment[], options?: RESTRequestOptions): Promise<T>;
+}
+export { Routes } from "./routes.js";
+export { type RateLimitStore, type BucketState, MemoryRateLimitStore, } from "./store.js";
+export { RedisRateLimitStore, type RedisRateLimitStoreOptions, type MinimalRedisClient, } from "./redis.js";
+export { WebhookClient, type WebhookClientOptions, type WebhookMessageOptions, } from "./webhook.js";
+/**
+ * Discord.js-familiar alias for {@link RESTError}. `@discordjs/rest` throws `DiscordAPIError`
+ * on a Discord-rejected request; Lunibee keeps `RESTError` as the canonical class and exports
+ * this alias so Discord.js-shaped `catch (err) { if (err instanceof DiscordAPIError) … }` works.
+ */
+export { RESTError as DiscordAPIError };