@squord/sdk 0.0.0-stage → 0.2.0

package/dist/testing/index.cjs

@@ -0,0 +1,789 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/testing/index.ts
+var testing_exports = {};
+__export(testing_exports, {
+  MockGatewayServer: () => MockGatewayServer,
+  MockRest: () => MockRest,
+  createMockEnvironment: () => createMockEnvironment,
+  createMockGateway: () => createMockGateway,
+  createMockRest: () => createMockRest,
+  fixtures: () => fixtures_exports
+});
+module.exports = __toCommonJS(testing_exports);
+
+// src/testing/MockRest.ts
+var API_ERROR_HEADERS = { "x-request-id": "mock-request-id" };
+var MockRest = class {
+  routes = [];
+  calls = [];
+  /** Quando definido, todo request recebe esta resposta (testes de falha). */
+  failingHandler = null;
+  /** Token esperado no header Authorization (sem o prefixo `Bot `). */
+  expectedToken = null;
+  /** Registra uma rota. `handler` devolve `{ status, body }` ou o corpo puro (status 200). */
+  on(method, pattern, handler) {
+    this.routes.push({
+      method: method.toUpperCase(),
+      pattern,
+      segments: pattern.split("/").filter(Boolean),
+      handler
+    });
+    return this;
+  }
+  get(pattern, handler) {
+    return this.on("GET", pattern, handler);
+  }
+  post(pattern, handler) {
+    return this.on("POST", pattern, handler);
+  }
+  put(pattern, handler) {
+    return this.on("PUT", pattern, handler);
+  }
+  patch(pattern, handler) {
+    return this.on("PATCH", pattern, handler);
+  }
+  delete(pattern, handler) {
+    return this.on("DELETE", pattern, handler);
+  }
+  /** Força falha em todas as requisições (ex.: simular queda de rede). */
+  failWith(handler) {
+    this.failingHandler = handler;
+  }
+  /** Volta ao comportamento normal. */
+  clearFailure() {
+    this.failingHandler = null;
+  }
+  /** Histórico de chamadas recebidas. */
+  get callLog() {
+    return this.calls;
+  }
+  /** Última chamada registrada. */
+  get lastCall() {
+    return this.calls[this.calls.length - 1];
+  }
+  /** Remove rotas e histórico. */
+  reset() {
+    this.routes = [];
+    this.calls.length = 0;
+    this.failingHandler = null;
+  }
+  /** A implementação de `fetch` para passar em `new SquordClient({ fetchImpl })`. */
+  fetch = async (input, init) => {
+    const request = input instanceof Request ? input : new Request(input, init);
+    const url = new URL(request.url);
+    const method = request.method.toUpperCase();
+    let body = void 0;
+    const rawBody = init?.body ?? (input instanceof Request ? void 0 : void 0);
+    if (rawBody !== void 0 && rawBody !== null) {
+      if (typeof rawBody === "string") {
+        body = rawBody ? JSON.parse(rawBody) : void 0;
+      } else if (rawBody instanceof ArrayBuffer || ArrayBuffer.isView(rawBody)) {
+        body = rawBody;
+      } else {
+        body = rawBody;
+      }
+    } else if (input instanceof Request) {
+      const clone = input.clone();
+      const text = await clone.text().catch(() => "");
+      if (text) {
+        try {
+          body = JSON.parse(text);
+        } catch {
+          body = text;
+        }
+      }
+    }
+    const headers = {};
+    for (const [key, value] of request.headers) headers[key] = value;
+    const call = {
+      method,
+      path: url.pathname,
+      params: {},
+      query: url.searchParams,
+      body,
+      headers,
+      requestId: headers["x-request-id"] ?? null
+    };
+    this.calls.push(call);
+    if (this.failingHandler) {
+      return this.failingHandler(call);
+    }
+    if (this.expectedToken) {
+      const auth = headers.authorization ?? "";
+      if (auth !== `Bot ${this.expectedToken}`) {
+        return jsonResponse(401, {
+          statusCode: 401,
+          code: "INVALID_TOKEN",
+          message: "Invalid token"
+        });
+      }
+    }
+    const pathSegments = url.pathname.split("/").filter(Boolean);
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      const match = matchSegments(route.segments, pathSegments);
+      if (!match) continue;
+      const matchInfo = {
+        params: match,
+        query: url.searchParams,
+        body,
+        call: { ...call, params: match }
+      };
+      const result = await route.handler(matchInfo);
+      const response = result && typeof result === "object" && "status" in result ? result : { status: 200, body: result };
+      return jsonResponse(response.status, response.body, response.headers);
+    }
+    return jsonResponse(404, {
+      statusCode: 404,
+      code: "NOT_FOUND",
+      message: `Rota n\xE3o mockada: ${method} ${url.pathname}`
+    });
+  };
+};
+function matchSegments(pattern, path) {
+  if (pattern.length !== path.length) return null;
+  const params = {};
+  for (let i = 0; i < pattern.length; i++) {
+    const p = pattern[i];
+    const s = path[i];
+    if (p.startsWith(":")) {
+      params[p.slice(1)] = decodeURIComponent(s);
+    } else if (p !== s) {
+      return null;
+    }
+  }
+  return params;
+}
+function jsonResponse(status, body, headers) {
+  const payload = body === void 0 || body === null ? void 0 : JSON.stringify(body);
+  return new Response(payload, {
+    status,
+    headers: {
+      ...payload !== void 0 ? { "Content-Type": "application/json" } : {},
+      ...API_ERROR_HEADERS,
+      ...headers
+    }
+  });
+}
+function createMockRest(options = {}) {
+  const rest = new MockRest();
+  if (options.token) rest.expectedToken = options.token;
+  return rest;
+}
+
+// src/testing/MockGateway.ts
+var MockWebSocket = class _MockWebSocket {
+  constructor(server) {
+    this.server = server;
+    queueMicrotask(() => {
+      this.readyState = _MockWebSocket.OPEN;
+      this.dispatch("open", {});
+      this.server.handleClientOpen(this);
+    });
+  }
+  server;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  readyState = 0;
+  // CONNECTING
+  listeners = /* @__PURE__ */ new Map();
+  addEventListener(type, listener) {
+    const list = this.listeners.get(type) ?? [];
+    list.push(listener);
+    this.listeners.set(type, list);
+  }
+  removeEventListener(type, listener) {
+    const list = this.listeners.get(type) ?? [];
+    const index = list.indexOf(listener);
+    if (index >= 0) list.splice(index, 1);
+  }
+  dispatch(type, event) {
+    for (const listener of [...this.listeners.get(type) ?? []]) {
+      listener(event);
+    }
+  }
+  /** Frame do cliente: entrega ao servidor. */
+  send(data) {
+    if (this.readyState !== _MockWebSocket.OPEN) return;
+    if (Buffer.byteLength(data, "utf8") > 65536) {
+      this.serverClose(1009, "frame too large");
+      return;
+    }
+    let frame;
+    try {
+      frame = JSON.parse(data);
+    } catch {
+      this.serverClose(4002, "decode error");
+      return;
+    }
+    this.server.handleClientFrame(this, frame);
+  }
+  close(code = 1e3, reason = "") {
+    if (this.readyState === _MockWebSocket.CLOSED) return;
+    this.readyState = _MockWebSocket.CLOSED;
+    this.server.handleClientClose(this, code, reason);
+    this.dispatch("close", { code, reason, wasClean: true });
+  }
+  /** Servidor fecha a conexão. */
+  serverClose(code, reason) {
+    if (this.readyState === _MockWebSocket.CLOSED) return;
+    this.readyState = _MockWebSocket.CLOSED;
+    this.server.handleClientClose(this, code, reason, true);
+    this.dispatch("close", { code, reason, wasClean: true });
+  }
+  /** Servidor envia frame. */
+  receive(frame) {
+    this.dispatch("message", { data: JSON.stringify(frame) });
+  }
+};
+var MockGatewayServer = class {
+  options;
+  sockets = /* @__PURE__ */ new Set();
+  eventBuffer = [];
+  globalSequence = 0;
+  refuseResumePending;
+  knownSessionIds = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.options = options;
+    this.refuseResumePending = options.refuseResumeOnce ?? false;
+  }
+  /** Fábrica de WebSocket para passar ao cliente. */
+  wsFactory = (url) => {
+    const pathname = (() => {
+      try {
+        return new URL(url.replace(/^wss/, "https")).pathname;
+      } catch {
+        return url;
+      }
+    })();
+    if (!/\/gateway$/.test(pathname)) {
+      throw new Error(`MockGateway: caminho inv\xE1lido ${url} (use wss://.../gateway)`);
+    }
+    return new MockWebSocket(this);
+  };
+  /** Conexões abertas no momento. */
+  get connectionCount() {
+    return this.sockets.size;
+  }
+  /** Última sequência emitida. */
+  get lastSequence() {
+    return this.eventBuffer.length > 0 ? this.eventBuffer[this.eventBuffer.length - 1].s : 0;
+  }
+  /** Total de eventos já emitidos. */
+  get totalEvents() {
+    return this.globalSequence;
+  }
+  /**
+   * Emite um evento durável: guarda no buffer (sequência crescente) e
+   * entrega às conexões autenticadas.
+   */
+  emitEvent(type, d) {
+    const s = ++this.globalSequence;
+    this.eventBuffer.push({ type, d, s });
+    if (this.eventBuffer.length > 500) this.eventBuffer.shift();
+    for (const socket of this.sockets) {
+      const state = socket;
+      if (state.session?.authenticated) {
+        socket.receive({ op: "event", type, d, s, timestamp: Date.now() });
+      }
+    }
+  }
+  /** Envia um frame cru às conexões autenticadas (sem `s`). */
+  sendFrame(frame) {
+    for (const socket of this.sockets) {
+      const state = socket;
+      if (state.session?.authenticated) socket.receive({ ...frame, timestamp: Date.now() });
+    }
+  }
+  /**
+   * Envia um evento com sequência arbitrária (para treinar a deduplicação
+   * do cliente: `s` repetido ou antigo deve ser descartado).
+   */
+  sendEventWithSequence(type, d, s) {
+    for (const socket of this.sockets) {
+      const state = socket;
+      if (state.session?.authenticated) {
+        socket.receive({ op: "event", type, d, s, timestamp: Date.now() });
+      }
+    }
+  }
+  /** Fecha as conexões com um código (ex.: 4009 para treinar resume). */
+  closeAll(code, reason) {
+    for (const socket of [...this.sockets]) {
+      socket.serverClose(code, reason);
+    }
+  }
+  /** Pede reconexão (frame `reconnect` + fechamento 4007, como o real). */
+  requestReconnect(reason = "gateway shutting down") {
+    for (const socket of [...this.sockets]) {
+      socket.receive({
+        op: "reconnect",
+        d: { reason, resumable: true },
+        timestamp: Date.now()
+      });
+    }
+    this.closeAll(4007, reason);
+  }
+  /** Descarta o histórico de eventos (o próximo resume falha com `invalid_session`). */
+  expireHistory() {
+    this.eventBuffer = [];
+  }
+  /** Reinicia o estado do mock. */
+  reset() {
+    this.sockets.clear();
+    this.eventBuffer = [];
+    this.globalSequence = 0;
+    this.knownSessionIds.clear();
+    this.refuseResumePending = this.options.refuseResumeOnce ?? false;
+  }
+  // ------------------------------------------------------------------
+  // "Servidor": handlers chamados pelo MockWebSocket
+  // ------------------------------------------------------------------
+  handleClientOpen(socket) {
+    this.sockets.add(socket);
+    socket.receive({
+      op: "hello",
+      d: {
+        heartbeatIntervalMs: this.options.heartbeatIntervalMs ?? 3e4,
+        sessionId: `mock-${Math.random().toString(36).slice(2, 12)}`,
+        protocolVersion: 1
+      },
+      timestamp: Date.now()
+    });
+  }
+  handleClientFrame(socket, frame) {
+    const op = frame.op;
+    const d = frame.d ?? {};
+    const state = socket;
+    switch (op) {
+      case "identify": {
+        if (state.session?.authenticated) {
+          socket.serverClose(4005, "already authenticated");
+          return;
+        }
+        if (this.options.token && d.token !== this.options.token) {
+          socket.serverClose(4004, "invalid token");
+          return;
+        }
+        const sessionId = `mock-${Math.random().toString(36).slice(2, 12)}`;
+        this.knownSessionIds.add(sessionId);
+        state.session = { authenticated: true, sessionId };
+        socket.receive({
+          op: "ready",
+          d: {
+            sessionId,
+            userId: this.options.ready?.userId ?? "1300000000000000010",
+            guilds: this.options.ready?.guilds ?? [],
+            resumeGatewayUrl: "wss://gateway.squord.com.br/gateway"
+          },
+          timestamp: Date.now()
+        });
+        return;
+      }
+      case "resume": {
+        const sessionId = d.sessionId;
+        const lastSequence = d.lastSequence ?? 0;
+        if (this.refuseResumePending) {
+          this.refuseResumePending = false;
+          socket.receive({
+            op: "invalid_session",
+            d: { resumable: false },
+            timestamp: Date.now()
+          });
+          return;
+        }
+        if (!this.knownSessionIds.has(sessionId)) {
+          socket.receive({
+            op: "invalid_session",
+            d: { resumable: false },
+            timestamp: Date.now()
+          });
+          return;
+        }
+        state.session = { authenticated: true, sessionId };
+        const replay = this.eventBuffer.filter((event) => event.s > lastSequence);
+        for (const event of replay) {
+          socket.receive({
+            op: "event",
+            type: event.type,
+            d: event.d,
+            s: event.s,
+            timestamp: Date.now()
+          });
+        }
+        const sequence = replay.length > 0 ? replay[replay.length - 1].s : lastSequence;
+        socket.receive({
+          op: "resumed",
+          d: { sessionId, replayed: replay.length, sequence },
+          timestamp: Date.now()
+        });
+        return;
+      }
+      case "heartbeat": {
+        if (!state.session?.authenticated) {
+          socket.serverClose(4003, "not authenticated");
+          return;
+        }
+        if (this.options.suppressHeartbeatAck) return;
+        socket.receive({
+          op: "heartbeat.ack",
+          d: { sequence: this.lastSequence },
+          timestamp: Date.now()
+        });
+        return;
+      }
+      case "presence.update":
+      case "subscribe":
+      case "unsubscribe":
+      case "typing.start":
+      case "voice.state.update":
+        return;
+      // aceitos e ignorados, como o real
+      default:
+        socket.serverClose(4001, "unknown opcode");
+    }
+  }
+  handleClientClose(socket, code, reason, byServer = false) {
+    this.sockets.delete(socket);
+    socket.session = void 0;
+    void code;
+    void reason;
+    void byServer;
+  }
+};
+function createMockGateway(options = {}) {
+  return new MockGatewayServer(options);
+}
+
+// src/testing/fixtures.ts
+var fixtures_exports = {};
+__export(fixtures_exports, {
+  bot: () => bot,
+  botUser: () => botUser,
+  channel: () => channel,
+  command: () => command,
+  commandInteraction: () => commandInteraction,
+  componentInteraction: () => componentInteraction,
+  guild: () => guild,
+  member: () => member,
+  message: () => message,
+  role: () => role,
+  user: () => user
+});
+function user(overrides = {}) {
+  return {
+    id: "1300000000000000020",
+    username: "ana",
+    displayName: "Ana",
+    avatarUrl: null,
+    avatarAnimatedUrl: null,
+    nameStyle: null,
+    flags: 0,
+    deleted: false,
+    suspended: false,
+    premium: false,
+    ...overrides
+  };
+}
+function botUser(overrides = {}) {
+  return user({
+    id: "1300000000000000010",
+    username: "bot~meubot",
+    displayName: "Meu Bot",
+    flags: 32,
+    // BOT
+    ...overrides
+  });
+}
+function member(overrides = {}) {
+  return {
+    id: "1300000000000000011",
+    guildId: "1300000000000000001",
+    userId: "1300000000000000020",
+    user: user(),
+    type: "INTERNAL",
+    nickname: null,
+    avatarUrl: null,
+    avatarAnimatedUrl: null,
+    bannerUrl: null,
+    bannerAnimatedUrl: null,
+    bio: null,
+    bioEmojis: [],
+    nameStyle: null,
+    profileFont: null,
+    profileTheme: null,
+    roleIds: [],
+    joinedAt: "2026-10-01T10:00:00.000Z",
+    timeoutUntil: null,
+    deaf: false,
+    mute: false,
+    pending: false,
+    boostingSince: null,
+    createdAt: "2026-10-01T10:00:00.000Z",
+    updatedAt: "2026-10-01T10:00:00.000Z",
+    ...overrides
+  };
+}
+function channel(overrides = {}) {
+  return {
+    id: "1300000000000000040",
+    guildId: "1300000000000000001",
+    categoryId: null,
+    name: "geral",
+    type: "TEXT",
+    position: 0,
+    topic: null,
+    topicUpdatedAt: null,
+    topicUpdatedById: null,
+    isPrivate: false,
+    rateLimitPerUser: 0,
+    bitrate: null,
+    userLimit: null,
+    chatEnabled: true,
+    lastMessageId: null,
+    overwrites: [],
+    availableTags: [],
+    requireTag: false,
+    defaultAutoArchiveMinutes: null,
+    createdAt: "2026-10-01T10:00:00.000Z",
+    updatedAt: "2026-10-01T10:00:00.000Z",
+    ...overrides
+  };
+}
+function role(overrides = {}) {
+  return {
+    id: "1300000000000000001",
+    guildId: "1300000000000000001",
+    name: "@everyone",
+    color: null,
+    position: 0,
+    permissions: "1685839112193",
+    hoist: false,
+    mentionable: false,
+    managed: false,
+    managedKind: null,
+    botId: null,
+    icon: null,
+    selfAssignable: false,
+    createdAt: "2026-10-01T10:00:00.000Z",
+    updatedAt: "2026-10-01T10:00:00.000Z",
+    ...overrides
+  };
+}
+function guild(overrides = {}) {
+  return {
+    id: "1300000000000000001",
+    ownerId: "1300000000000000009",
+    name: "Meu Space",
+    slug: "meu-space",
+    description: null,
+    iconUrl: null,
+    iconAnimatedUrl: null,
+    bannerUrl: null,
+    bannerAnimatedUrl: null,
+    bannerPlaceholder: null,
+    defaultChannelId: "1300000000000000040",
+    systemChannelId: null,
+    visibility: "PUBLIC",
+    verificationLevel: "NONE",
+    accessMode: "LINK",
+    requireVerifiedEmail: false,
+    requireTwoFactor: false,
+    moderationMfaRequired: false,
+    joinRequestRoleIds: [],
+    requireJoinMessage: false,
+    joinRequestRetryDays: 0,
+    memberCount: 2,
+    flags: 0,
+    planId: "free",
+    vanityLapsesAt: null,
+    vanityInvite: false,
+    boostCount: 0,
+    boostLevel: 0,
+    boostMessages: false,
+    discoveryCategory: null,
+    locale: null,
+    rules: [],
+    rulesUpdatedAt: null,
+    discoverable: false,
+    discoverableSince: null,
+    minAccountAgeDays: 0,
+    createdAt: "2026-10-01T10:00:00.000Z",
+    updatedAt: "2026-10-01T10:00:00.000Z",
+    self: {
+      memberId: "1300000000000000012",
+      roleIds: ["1300000000000000031"],
+      permissions: "155649",
+      isOwner: false
+    },
+    ...overrides
+  };
+}
+function message(overrides = {}) {
+  return {
+    id: "1300000000000000100",
+    guildId: "1300000000000000001",
+    channelId: "1300000000000000040",
+    authorId: "1300000000000000020",
+    type: "DEFAULT",
+    content: "Ol\xE1!",
+    replyToId: null,
+    attachments: [],
+    embeds: [],
+    components: [],
+    interaction: null,
+    mentions: { userIds: [], roleIds: [], channelIds: [], everyone: false },
+    reactions: [],
+    pinned: false,
+    editedAt: null,
+    deletedAt: null,
+    moderated: false,
+    nonce: null,
+    call: null,
+    poll: null,
+    forward: null,
+    relay: null,
+    relayedCount: null,
+    stickers: [],
+    emojis: [],
+    thread: null,
+    automod: null,
+    createdAt: "2026-10-05T14:30:00.000Z",
+    updatedAt: "2026-10-05T14:30:00.000Z",
+    author: user(),
+    memberNickname: null,
+    memberAvatarUrl: null,
+    memberNameStyle: null,
+    replyTo: null,
+    ...overrides
+  };
+}
+function commandInteraction(overrides = {}) {
+  return {
+    id: "1300000000000000400",
+    token: "tk_9f2c1d7e8a4b",
+    type: "COMMAND",
+    guildId: "1300000000000000001",
+    channelId: "1300000000000000040",
+    user: user(),
+    member: member(),
+    command: {
+      id: "1300000000000000500",
+      name: "ping",
+      options: []
+    },
+    createdAt: "2026-10-05T14:40:00.000Z",
+    ...overrides
+  };
+}
+function componentInteraction(overrides = {}) {
+  return {
+    id: "1300000000000000401",
+    token: "tk_1b3d5f7a9c2e",
+    type: "COMPONENT",
+    guildId: "1300000000000000001",
+    channelId: "1300000000000000040",
+    user: user(),
+    member: member(),
+    component: {
+      messageId: "1300000000000000100",
+      customId: "confirmar",
+      type: "button",
+      values: []
+    },
+    createdAt: "2026-10-05T14:41:00.000Z",
+    ...overrides
+  };
+}
+function command(overrides = {}) {
+  return {
+    id: "1300000000000000500",
+    botId: "1300000000000000010",
+    guildId: null,
+    name: "ping",
+    description: "Verifica a lat\xEAncia do bot",
+    options: [],
+    updatedAt: "2026-10-05T14:00:00.000Z",
+    ...overrides
+  };
+}
+function bot(overrides = {}) {
+  return {
+    id: "1300000000000000010",
+    user: botUser(),
+    description: "Bot de exemplo",
+    ownerUsername: "ana",
+    public: false,
+    verified: false,
+    installCount: 1,
+    termsUrl: null,
+    privacyUrl: null,
+    createdAt: "2026-10-01T10:00:00.000Z",
+    intents: 13,
+    ...overrides
+  };
+}
+
+// src/testing/index.ts
+function createMockEnvironment(options = {}) {
+  const rest = createMockRest();
+  rest.get("/bots/@me", () => ({ status: 200, body: bot() }));
+  rest.post("/channels/:channelId/messages", (match) => {
+    const body = match.body ?? {};
+    return {
+      status: 201,
+      body: message({
+        channelId: match.params.channelId,
+        content: body.content ?? "",
+        replyToId: body.replyToId ?? null,
+        nonce: body.nonce ?? null,
+        author: botUser()
+      })
+    };
+  });
+  rest.put("/bots/@me/commands", () => ({ status: 200, body: [] }));
+  rest.put("/bots/@me/guilds/:guildId/commands", () => ({ status: 200, body: [] }));
+  const gateway = createMockGateway({
+    heartbeatIntervalMs: options.heartbeatIntervalMs ?? 200,
+    token: options.token
+  });
+  return {
+    options: {
+      apiBaseURL: "https://mock.test",
+      fetchImpl: rest.fetch,
+      ws: gateway.wsFactory,
+      gatewayReconnectBaseMs: options.reconnectBaseMs ?? 20
+    },
+    gateway,
+    rest
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MockGatewayServer,
+  MockRest,
+  createMockEnvironment,
+  createMockGateway,
+  createMockRest,
+  fixtures
+});
+//# sourceMappingURL=index.cjs.map