shardwire 0.2.0 → 1.0.0

package/dist/index.d.mts

@@ -1,20 +1,5 @@
-import { ZodType } from 'zod';
+import { Snowflake, APIEmbed, APIAllowedMentions } from 'discord-api-types/v10';
 
-interface CommandSchema<Request = unknown, Response = unknown> {
-    request: Request;
-    response: Response;
-}
-type CommandMap = Record<string, unknown | CommandSchema>;
-type EventMap = Record<string, unknown>;
-interface SchemaValidationIssue {
-    path: string;
-    message: string;
-}
-interface RuntimeSchema<T = unknown> {
-    parse: (value: unknown) => T;
-}
-type CommandRequestOf<T> = T extends CommandSchema<infer Request, unknown> ? Request : T;
-type CommandResponseOf<T> = T extends CommandSchema<unknown, infer Response> ? Response : unknown;
 type Unsubscribe = () => void;
 interface ShardwireLogger {
     debug?: (message: string, meta?: Record<string, unknown>) => void;
@@ -22,86 +7,242 @@ interface ShardwireLogger {
     warn?: (message: string, meta?: Record<string, unknown>) => void;
     error?: (message: string, meta?: Record<string, unknown>) => void;
 }
-interface DiscordClientLike {
-    login(token: string): Promise<string>;
-    destroy(): void;
-    once(event: "ready", listener: () => void): void;
-    on(event: "ready", listener: () => void): void;
-    off(event: "ready", listener: () => void): void;
+type BotIntentName = "Guilds" | "GuildMembers" | "GuildMessages" | "MessageContent";
+interface BridgeUser {
+    id: Snowflake;
+    username: string;
+    discriminator: string;
+    globalName?: string | null;
+    avatarUrl?: string | null;
+    bot: boolean;
+    system: boolean;
 }
-interface CommandContext {
-    requestId: string;
+interface BridgeAttachment {
+    id: Snowflake;
+    name: string;
+    url: string;
+    contentType?: string | null;
+    size: number;
+}
+interface BridgeMessageReference {
+    messageId?: Snowflake;
+    channelId?: Snowflake;
+    guildId?: Snowflake;
+}
+interface BridgeGuildMember {
+    id: Snowflake;
+    guildId: Snowflake;
+    user?: BridgeUser;
+    displayName?: string;
+    nickname?: string | null;
+    roles: Snowflake[];
+    joinedAt?: string | null;
+    premiumSince?: string | null;
+    pending?: boolean;
+    communicationDisabledUntil?: string | null;
+}
+interface BridgeMessage {
+    id: Snowflake;
+    channelId: Snowflake;
+    guildId?: Snowflake;
+    author?: BridgeUser;
+    member?: BridgeGuildMember;
+    content?: string;
+    createdAt?: string;
+    editedAt?: string | null;
+    attachments: BridgeAttachment[];
+    embeds: APIEmbed[];
+    reference?: BridgeMessageReference;
+}
+interface BridgeDeletedMessage {
+    id: Snowflake;
+    channelId: Snowflake;
+    guildId?: Snowflake;
+    deletedAt: string;
+}
+type BridgeInteractionKind = "chatInput" | "contextMenu" | "button" | "stringSelect" | "userSelect" | "roleSelect" | "mentionableSelect" | "channelSelect" | "modalSubmit" | "unknown";
+interface BridgeInteraction {
+    id: Snowflake;
+    applicationId: Snowflake;
+    kind: BridgeInteractionKind;
+    guildId?: Snowflake;
+    channelId?: Snowflake;
+    user: BridgeUser;
+    member?: BridgeGuildMember;
+    commandName?: string;
+    customId?: string;
+    options?: Record<string, unknown>;
+    values?: string[];
+    fields?: Record<string, string>;
+    message?: BridgeMessage;
+}
+interface EventEnvelopeBase {
     receivedAt: number;
-    connectionId: string;
-    source?: string;
+    shardId?: number;
 }
-interface EventMeta {
-    ts: number;
-    source?: string;
+interface ReadyEventPayload extends EventEnvelopeBase {
+    user: BridgeUser;
 }
-interface CommandSuccess<T = unknown> {
-    ok: true;
-    requestId: string;
-    ts: number;
-    data: T;
+interface InteractionCreateEventPayload extends EventEnvelopeBase {
+    interaction: BridgeInteraction;
 }
-interface CommandFailure {
-    ok: false;
-    requestId: string;
-    ts: number;
-    error: {
-        code: "UNAUTHORIZED" | "TIMEOUT" | "DISCONNECTED" | "COMMAND_NOT_FOUND" | "VALIDATION_ERROR" | "INTERNAL_ERROR";
-        message: string;
-        details?: unknown;
-    };
+interface MessageCreateEventPayload extends EventEnvelopeBase {
+    message: BridgeMessage;
+}
+interface MessageUpdateEventPayload extends EventEnvelopeBase {
+    oldMessage?: BridgeMessage;
+    message: BridgeMessage;
+}
+interface MessageDeleteEventPayload extends EventEnvelopeBase {
+    message: BridgeDeletedMessage;
+}
+interface GuildMemberAddEventPayload extends EventEnvelopeBase {
+    member: BridgeGuildMember;
+}
+interface GuildMemberRemoveEventPayload extends EventEnvelopeBase {
+    member: BridgeGuildMember;
+}
+interface BotEventPayloadMap {
+    ready: ReadyEventPayload;
+    interactionCreate: InteractionCreateEventPayload;
+    messageCreate: MessageCreateEventPayload;
+    messageUpdate: MessageUpdateEventPayload;
+    messageDelete: MessageDeleteEventPayload;
+    guildMemberAdd: GuildMemberAddEventPayload;
+    guildMemberRemove: GuildMemberRemoveEventPayload;
+}
+type BotEventName = keyof BotEventPayloadMap;
+interface BridgeMessageInput {
+    content?: string;
+    embeds?: APIEmbed[];
+    allowedMentions?: APIAllowedMentions;
+}
+interface SendMessageActionPayload extends BridgeMessageInput {
+    channelId: Snowflake;
+}
+interface EditMessageActionPayload extends BridgeMessageInput {
+    channelId: Snowflake;
+    messageId: Snowflake;
+}
+interface DeleteMessageActionPayload {
+    channelId: Snowflake;
+    messageId: Snowflake;
+}
+interface ReplyToInteractionActionPayload extends BridgeMessageInput {
+    interactionId: Snowflake;
+    ephemeral?: boolean;
+}
+interface DeferInteractionActionPayload {
+    interactionId: Snowflake;
+    ephemeral?: boolean;
+}
+interface FollowUpInteractionActionPayload extends BridgeMessageInput {
+    interactionId: Snowflake;
+    ephemeral?: boolean;
+}
+interface BanMemberActionPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+    reason?: string;
+    deleteMessageSeconds?: number;
+}
+interface KickMemberActionPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+    reason?: string;
+}
+interface AddMemberRoleActionPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+    roleId: Snowflake;
+    reason?: string;
+}
+interface RemoveMemberRoleActionPayload {
+    guildId: Snowflake;
+    userId: Snowflake;
+    roleId: Snowflake;
+    reason?: string;
 }
-type CommandResult<T = unknown> = CommandSuccess<T> | CommandFailure;
-interface HostOptions<C extends CommandMap, E extends EventMap> {
-    client?: DiscordClientLike;
-    token?: string;
+interface BotActionPayloadMap {
+    sendMessage: SendMessageActionPayload;
+    editMessage: EditMessageActionPayload;
+    deleteMessage: DeleteMessageActionPayload;
+    replyToInteraction: ReplyToInteractionActionPayload;
+    deferInteraction: DeferInteractionActionPayload;
+    followUpInteraction: FollowUpInteractionActionPayload;
+    banMember: BanMemberActionPayload;
+    kickMember: KickMemberActionPayload;
+    addMemberRole: AddMemberRoleActionPayload;
+    removeMemberRole: RemoveMemberRoleActionPayload;
+}
+interface DeleteMessageActionResult {
+    deleted: true;
+    channelId: Snowflake;
+    messageId: Snowflake;
+}
+interface DeferInteractionActionResult {
+    deferred: true;
+    interactionId: Snowflake;
+}
+interface MemberModerationActionResult {
+    guildId: Snowflake;
+    userId: Snowflake;
+}
+interface BotActionResultDataMap {
+    sendMessage: BridgeMessage;
+    editMessage: BridgeMessage;
+    deleteMessage: DeleteMessageActionResult;
+    replyToInteraction: BridgeMessage;
+    deferInteraction: DeferInteractionActionResult;
+    followUpInteraction: BridgeMessage;
+    banMember: MemberModerationActionResult;
+    kickMember: MemberModerationActionResult;
+    addMemberRole: BridgeGuildMember;
+    removeMemberRole: BridgeGuildMember;
+}
+type BotActionName = keyof BotActionPayloadMap;
+interface BridgeCapabilities {
+    events: BotEventName[];
+    actions: BotActionName[];
+}
+interface EventSubscriptionFilter {
+    guildId?: Snowflake | readonly Snowflake[];
+    channelId?: Snowflake | readonly Snowflake[];
+    userId?: Snowflake | readonly Snowflake[];
+    commandName?: string | readonly string[];
+}
+interface EventSubscription<K extends BotEventName = BotEventName> {
+    name: K;
+    filter?: EventSubscriptionFilter;
+}
+interface SecretPermissions {
+    events?: "*" | readonly BotEventName[];
+    actions?: "*" | readonly BotActionName[];
+}
+interface ScopedSecretConfig {
+    id?: string;
+    value: string;
+    allow?: SecretPermissions;
+}
+type BotBridgeSecret = string | ScopedSecretConfig;
+interface BotBridgeOptions {
+    token: string;
+    intents: readonly BotIntentName[];
     server: {
         port: number;
         host?: string;
-        secrets: string[];
-        primarySecretId?: string;
         path?: string;
         heartbeatMs?: number;
-        commandTimeoutMs?: number;
         maxPayloadBytes?: number;
-        corsOrigins?: string[];
-    };
-    validation?: {
-        commands?: Partial<{
-            [K in keyof C & string]: {
-                request?: RuntimeSchema<CommandRequestOf<C[K]>>;
-                response?: RuntimeSchema<CommandResponseOf<C[K]>>;
-            };
-        }>;
-        events?: Partial<{
-            [K in keyof E & string]: RuntimeSchema<E[K]>;
-        }>;
+        secrets: readonly BotBridgeSecret[];
     };
-    name?: string;
     logger?: ShardwireLogger;
 }
-interface ConsumerOptions {
+interface AppBridgeOptions {
     url: string;
     secret: string;
     secretId?: string;
-    clientName?: string;
-    /**
-     * Allows plain `ws://` connections to non-loopback hosts.
-     *
-     * Keep this `false` unless you explicitly terminate TLS upstream and trust the network path.
-     */
-    allowInsecureWs?: boolean;
-    webSocketFactory?: (url: string) => {
-        readyState: number;
-        send(data: string): void;
-        close(code?: number, reason?: string): void;
-        on(event: "open" | "message" | "close" | "error", listener: (...args: unknown[]) => void): void;
-        once(event: "close", listener: () => void): void;
-    };
+    appName?: string;
     reconnect?: {
         enabled?: boolean;
         initialDelayMs?: number;
@@ -111,65 +252,57 @@ interface ConsumerOptions {
     requestTimeoutMs?: number;
     logger?: ShardwireLogger;
 }
-interface HostShardwire<C extends CommandMap, E extends EventMap> {
-    mode: "host";
-    onCommand<K extends keyof C & string>(name: K, handler: (payload: CommandRequestOf<C[K]>, ctx: CommandContext) => Promise<CommandResponseOf<C[K]>> | CommandResponseOf<C[K]>): Unsubscribe;
-    emitEvent<K extends keyof E & string>(name: K, payload: E[K]): void;
-    broadcast<K extends keyof E & string>(name: K, payload: E[K]): void;
-    close(): Promise<void>;
+interface ActionError {
+    code: "UNAUTHORIZED" | "TIMEOUT" | "DISCONNECTED" | "FORBIDDEN" | "NOT_FOUND" | "INVALID_REQUEST" | "INTERNAL_ERROR";
+    message: string;
+    details?: unknown;
 }
-interface ConsumerShardwire<C extends CommandMap, E extends EventMap> {
-    mode: "consumer";
-    send<K extends keyof C & string>(name: K, payload: CommandRequestOf<C[K]>, options?: {
+interface ActionSuccess<T> {
+    ok: true;
+    requestId: string;
+    ts: number;
+    data: T;
+}
+interface ActionFailure {
+    ok: false;
+    requestId: string;
+    ts: number;
+    error: ActionError;
+}
+type ActionResult<T> = ActionSuccess<T> | ActionFailure;
+declare class BridgeCapabilityError extends Error {
+    readonly kind: "event" | "action";
+    readonly name: string;
+    constructor(kind: "event" | "action", name: string, message?: string);
+}
+type EventHandler<K extends BotEventName> = (payload: BotEventPayloadMap[K]) => void;
+type AppBridgeActions = {
+    [K in BotActionName]: (payload: BotActionPayloadMap[K], options?: {
         timeoutMs?: number;
         requestId?: string;
-    }): Promise<CommandResult<CommandResponseOf<C[K]>>>;
-    on<K extends keyof E & string>(name: K, handler: (payload: E[K], meta: EventMeta) => void): Unsubscribe;
-    off<K extends keyof E & string>(name: K, handler: (payload: E[K], meta: EventMeta) => void): void;
-    onConnected(handler: (info: {
-        connectionId: string;
-        connectedAt: number;
-    }) => void): Unsubscribe;
-    onDisconnected(handler: (info: {
-        reason: string;
-        at: number;
-        willReconnect: boolean;
-    }) => void): Unsubscribe;
-    onReconnecting(handler: (info: {
-        attempt: number;
-        delayMs: number;
-        at: number;
-    }) => void): Unsubscribe;
+    }) => Promise<ActionResult<BotActionResultDataMap[K]>>;
+};
+interface BotBridge {
     ready(): Promise<void>;
-    connected(): boolean;
-    connectionId(): string | null;
     close(): Promise<void>;
-}
-interface CreateShardwire {
-    <C extends CommandMap = {}, E extends EventMap = {}>(options: HostOptions<C, E>): HostShardwire<C, E>;
-    <C extends CommandMap = {}, E extends EventMap = {}>(options: ConsumerOptions): ConsumerShardwire<C, E>;
-}
-
-interface SafeParseResultSuccess<T> {
-    success: true;
-    data: T;
-}
-interface SafeParseResultFailure {
-    success: false;
-    error: {
-        message: string;
-        issues?: SchemaValidationIssue[];
+    status(): {
+        ready: boolean;
+        connectionCount: number;
     };
 }
-type SafeParseResult<T> = SafeParseResultSuccess<T> | SafeParseResultFailure;
-interface SafeParseSchema<T> {
-    safeParse: (value: unknown) => SafeParseResult<T>;
+interface AppBridge {
+    actions: AppBridgeActions;
+    ready(): Promise<void>;
+    close(): Promise<void>;
+    connected(): boolean;
+    connectionId(): string | null;
+    capabilities(): BridgeCapabilities;
+    on<K extends BotEventName>(name: K, handler: EventHandler<K>, filter?: EventSubscriptionFilter): Unsubscribe;
+    off<K extends BotEventName>(name: K, handler: EventHandler<K>): void;
 }
-declare function fromSafeParseSchema<T>(schema: SafeParseSchema<T>): RuntimeSchema<T>;
 
-declare function fromZodSchema<T>(schema: ZodType<T>): RuntimeSchema<T>;
+declare function createBotBridge(options: BotBridgeOptions): BotBridge;
 
-declare function createShardwire<C extends CommandMap = {}, E extends EventMap = {}>(options: HostOptions<C, E>): HostShardwire<C, E>;
-declare function createShardwire<C extends CommandMap = {}, E extends EventMap = {}>(options: ConsumerOptions): ConsumerShardwire<C, E>;
+declare function connectBotBridge(options: AppBridgeOptions): AppBridge;
 
-export { type CommandContext, type CommandFailure, type CommandMap, type CommandRequestOf, type CommandResponseOf, type CommandResult, type CommandSchema, type CommandSuccess, type ConsumerOptions, type ConsumerShardwire, type CreateShardwire, type DiscordClientLike, type EventMap, type EventMeta, type HostOptions, type HostShardwire, type RuntimeSchema, type SchemaValidationIssue, type ShardwireLogger, type Unsubscribe, createShardwire, fromSafeParseSchema, fromZodSchema };
+export { type ActionError, type ActionFailure, type ActionResult, type ActionSuccess, type AddMemberRoleActionPayload, type AppBridge, type AppBridgeActions, type AppBridgeOptions, type BanMemberActionPayload, type BotActionName, type BotActionPayloadMap, type BotActionResultDataMap, type BotBridge, type BotBridgeOptions, type BotBridgeSecret, type BotEventName, type BotEventPayloadMap, type BotIntentName, type BridgeAttachment, type BridgeCapabilities, BridgeCapabilityError, type BridgeDeletedMessage, type BridgeGuildMember, type BridgeInteraction, type BridgeInteractionKind, type BridgeMessage, type BridgeMessageInput, type BridgeMessageReference, type BridgeUser, type DeferInteractionActionPayload, type DeleteMessageActionPayload, type EditMessageActionPayload, type EventEnvelopeBase, type EventHandler, type EventSubscription, type EventSubscriptionFilter, type FollowUpInteractionActionPayload, type GuildMemberAddEventPayload, type GuildMemberRemoveEventPayload, type InteractionCreateEventPayload, type KickMemberActionPayload, type MessageCreateEventPayload, type MessageDeleteEventPayload, type MessageUpdateEventPayload, type ReadyEventPayload, type RemoveMemberRoleActionPayload, type ReplyToInteractionActionPayload, type ScopedSecretConfig, type SecretPermissions, type SendMessageActionPayload, type ShardwireLogger, type Unsubscribe, connectBotBridge, createBotBridge };