@erinjs/core 1.0.0

package/core/packages/rest/src/RequestManager.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { RequestManager } from './RequestManager.js';
+import { HTTPError, FluxerAPIError } from './errors/index.js';
+
+describe('RequestManager', () => {
+  let fetchMock: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    fetchMock = vi.fn();
+    vi.stubGlobal('fetch', fetchMock);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it('constructor uses defaults', () => {
+    const rm = new RequestManager({});
+    expect(rm.baseUrl).toBe('https://api.fluxer.app/v1');
+  });
+
+  it('constructor accepts overrides', () => {
+    const rm = new RequestManager({ api: 'https://test', version: '2' });
+    expect(rm.baseUrl).toBe('https://test/v2');
+  });
+
+  it('request succeeds with JSON body', async () => {
+    const rm = new RequestManager({ retries: 0 });
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      text: () => Promise.resolve('{"id":"123"}'),
+      headers: new Headers(),
+    });
+    const result = await rm.request('GET', '/channels/123');
+    expect(result).toEqual({ id: '123' });
+  });
+
+  it('request returns undefined for 204', async () => {
+    const rm = new RequestManager({ retries: 0 });
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      status: 204,
+      text: () => Promise.resolve(''),
+      headers: new Headers(),
+    });
+    const result = await rm.request('DELETE', '/channels/123');
+    expect(result).toBeUndefined();
+  });
+
+  it('request throws FluxerAPIError for non-ok with JSON body', async () => {
+    const rm = new RequestManager({ retries: 0 });
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      text: () => Promise.resolve('{"code":10003,"message":"Unknown Channel"}'),
+      headers: new Headers(),
+    });
+    await expect(rm.request('GET', '/channels/999')).rejects.toThrow(FluxerAPIError);
+  });
+
+  it('request throws HTTPError for non-JSON error body', async () => {
+    const rm = new RequestManager({ retries: 0 });
+    fetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      text: () => Promise.resolve('Internal Server Error'),
+      headers: new Headers(),
+    });
+    await expect(rm.request('GET', '/channels/1')).rejects.toThrow(HTTPError);
+  });
+
+  it('request uses full URL when route starts with http', async () => {
+    const rm = new RequestManager({ retries: 0 });
+    fetchMock.mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      text: () => Promise.resolve('{}'),
+      headers: new Headers(),
+    });
+    await rm.request('GET', 'https://cdn.example.com/asset/123');
+    expect(fetchMock).toHaveBeenCalledWith(
+      'https://cdn.example.com/asset/123',
+      expect.objectContaining({ method: 'GET' }),
+    );
+  });
+});

package/core/packages/rest/src/RequestManager.ts

@@ -0,0 +1,172 @@
+import { RateLimitManager } from './RateLimitManager.js';
+import { FluxerAPIError, RateLimitError, HTTPError } from './errors/index.js';
+import { APIErrorBody, RateLimitErrorBody } from '@erinjs/types';
+import { buildFormData } from './utils/files.js';
+
+export interface RequestOptions {
+  body?: unknown | FormData;
+  headers?: Record<string, string>;
+  files?: Array<{
+    name: string;
+    data: Blob | ArrayBuffer | Uint8Array | Buffer;
+    filename?: string;
+  }>;
+  auth?: boolean;
+}
+
+export interface RestOptions {
+  api: string;
+  version: string;
+  authPrefix: 'Bot' | 'Bearer';
+  timeout: number;
+  retries: number;
+  userAgent: string;
+}
+
+export class RequestManager {
+  private token: string | null = null;
+  private readonly options: RestOptions;
+  private readonly rateLimiter = new RateLimitManager();
+
+  constructor(options: Partial<RestOptions>) {
+    this.options = {
+      api: options.api ?? 'https://api.fluxer.app',
+      version: options.version ?? '1',
+      authPrefix: options.authPrefix ?? 'Bot',
+      timeout: options.timeout ?? 15000,
+      retries: options.retries ?? 3,
+      userAgent: options.userAgent ?? 'erin.js',
+    };
+  }
+
+  setToken(token: string | null): void {
+    this.token = token;
+  }
+
+  get baseUrl(): string {
+    return `${this.options.api}/v${this.options.version}`;
+  }
+
+  /** Hash route for rate limit bucket (use path without ids for grouping). */
+  private getRouteHash(route: string): string {
+    return route.replace(/\d{17,19}/g, ':id');
+  }
+
+  private async waitForRateLimit(routeHash: string): Promise<void> {
+    const wait = this.rateLimiter.getWaitTime(routeHash);
+    if (wait > 0) await new Promise((r) => setTimeout(r, wait));
+  }
+
+  private buildHeaders(
+    _route: string,
+    options: RequestOptions,
+    body: string | FormData | undefined,
+  ): Record<string, string> {
+    const headers: Record<string, string> = {
+      'User-Agent': this.options.userAgent,
+      ...options.headers,
+    };
+    if (options.auth !== false && this.token) {
+      headers['Authorization'] = `${this.options.authPrefix} ${this.token}`;
+    }
+    if (body !== undefined && !(body instanceof FormData)) {
+      headers['Content-Type'] = 'application/json';
+    }
+    return headers;
+  }
+
+  async request<T>(method: string, route: string, options: RequestOptions = {}): Promise<T> {
+    const routeHash = this.getRouteHash(route);
+    const url = route.startsWith('http') ? route : `${this.baseUrl}${route}`;
+
+    await this.waitForRateLimit(routeHash);
+
+    let body: string | FormData | undefined;
+    if (options.body !== undefined) {
+      if (options.body instanceof FormData) {
+        body = options.body;
+      } else if (
+        options.files?.length &&
+        typeof options.body === 'object' &&
+        options.body !== null
+      ) {
+        body = buildFormData(options.body as Record<string, unknown>, options.files);
+      } else {
+        body = JSON.stringify(options.body);
+      }
+    }
+
+    const headers = this.buildHeaders(route, options, body);
+
+    let lastError: Error | null = null;
+    for (let attempt = 0; attempt <= this.options.retries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+      try {
+        const response = await fetch(url, {
+          method,
+          headers,
+          body,
+          signal: controller.signal,
+        });
+
+        this.rateLimiter.updateFromHeaders(routeHash, response.headers);
+
+        if (response.status === 429) {
+          const data = (await response.json().catch(() => ({}))) as RateLimitErrorBody;
+          const retryAfter =
+            (data.retry_after ?? parseInt(response.headers.get('Retry-After') ?? '0', 10)) * 1000;
+          this.rateLimiter.setBucket(routeHash, 1, 0, Date.now() + retryAfter);
+          if (data.global) this.rateLimiter.setGlobalReset(Date.now() + retryAfter);
+          throw new RateLimitError(
+            {
+              ...data,
+              code: 'RATE_LIMITED',
+              message: data.message ?? 'Rate limited',
+              retry_after: data.retry_after ?? 0,
+            },
+            response.status,
+          );
+        }
+
+        const text = await response.text();
+        if (!response.ok) {
+          let parsed: APIErrorBody;
+          try {
+            parsed = JSON.parse(text) as APIErrorBody;
+          } catch {
+            throw new HTTPError(response.status, text);
+          }
+          throw new FluxerAPIError(parsed, response.status);
+        }
+
+        if (response.status === 204 || text.length === 0) return undefined as T;
+        return JSON.parse(text) as T;
+      } catch (err) {
+        const wrapped = err instanceof Error ? err : new Error(String(err));
+        lastError =
+          attempt > 0
+            ? new Error(`Retry ${attempt} failed: ${wrapped.message}`, {
+                cause: wrapped,
+              })
+            : wrapped;
+        if (err instanceof RateLimitError && attempt < this.options.retries) {
+          const retryMs = err.retryAfter * 1000;
+          if (Number.isFinite(retryMs)) {
+            await new Promise((r) => setTimeout(r, retryMs));
+            continue;
+          }
+        }
+        if (err instanceof FluxerAPIError || err instanceof HTTPError) throw err;
+        if (attempt < this.options.retries) {
+          await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+          continue;
+        }
+        throw lastError;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    throw lastError ?? new Error('Request failed');
+  }
+}

package/core/packages/rest/src/errors/FluxerAPIError.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { FluxerAPIError } from './FluxerAPIError.js';
+
+describe('FluxerAPIError', () => {
+  it('creates error with message from body', () => {
+    const err = new FluxerAPIError(
+      { message: 'Channel not found', code: 'CHANNEL_NOT_FOUND' },
+      404,
+    );
+    expect(err.message).toBe('Channel not found');
+    expect(err.name).toBe('FluxerAPIError');
+  });
+
+  it('stores code and statusCode', () => {
+    const err = new FluxerAPIError({ message: 'Rate limited', code: 'RATE_LIMITED' }, 429);
+    expect(err.code).toBe('RATE_LIMITED');
+    expect(err.statusCode).toBe(429);
+  });
+
+  it('stores optional errors field', () => {
+    const errors = { field: ['invalid value'] };
+    const err = new FluxerAPIError(
+      { message: 'Validation failed', code: 'VALIDATION_ERROR', errors },
+      400,
+    );
+    expect(err.errors).toEqual(errors);
+  });
+
+  it('isRetryable returns true for 429', () => {
+    const err = new FluxerAPIError({ message: 'Rate limited', code: 'RATE_LIMITED' }, 429);
+    expect(err.isRetryable).toBe(true);
+  });
+
+  it('isRetryable returns true for 5xx', () => {
+    expect(new FluxerAPIError({ message: 'Server error', code: 'INTERNAL' }, 500).isRetryable).toBe(
+      true,
+    );
+    expect(
+      new FluxerAPIError({ message: 'Bad gateway', code: 'BAD_GATEWAY' }, 502).isRetryable,
+    ).toBe(true);
+    expect(
+      new FluxerAPIError({ message: 'Unavailable', code: 'UNAVAILABLE' }, 503).isRetryable,
+    ).toBe(true);
+  });
+
+  it('isRetryable returns false for 4xx (except 429)', () => {
+    expect(new FluxerAPIError({ message: 'Not found', code: 'NOT_FOUND' }, 404).isRetryable).toBe(
+      false,
+    );
+    expect(new FluxerAPIError({ message: 'Forbidden', code: 'FORBIDDEN' }, 403).isRetryable).toBe(
+      false,
+    );
+    expect(
+      new FluxerAPIError({ message: 'Bad request', code: 'BAD_REQUEST' }, 400).isRetryable,
+    ).toBe(false);
+  });
+});

package/core/packages/rest/src/errors/FluxerAPIError.ts

@@ -0,0 +1,21 @@
+import { APIErrorBody } from '@erinjs/types';
+
+export class FluxerAPIError extends Error {
+  readonly code: string;
+  readonly statusCode: number;
+  readonly errors?: APIErrorBody['errors'];
+
+  constructor(body: APIErrorBody, statusCode: number) {
+    super(body.message);
+    this.name = 'FluxerAPIError';
+    this.code = body.code;
+    this.statusCode = statusCode;
+    this.errors = body.errors;
+    Object.setPrototypeOf(this, FluxerAPIError.prototype);
+  }
+
+  /** True if the error is retryable (429 rate limit, 5xx server errors). */
+  get isRetryable(): boolean {
+    return this.statusCode === 429 || (this.statusCode >= 500 && this.statusCode < 600);
+  }
+}

package/core/packages/rest/src/errors/HTTPError.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { HTTPError } from './HTTPError.js';
+
+describe('HTTPError', () => {
+  it('creates error with status and body', () => {
+    const err = new HTTPError(404, '{"error":"not found"}');
+    expect(err.message).toContain('404');
+    expect(err.message).toContain('not found');
+    expect(err.name).toBe('HTTPError');
+  });
+
+  it('stores statusCode and body', () => {
+    const err = new HTTPError(500, 'Internal Server Error');
+    expect(err.statusCode).toBe(500);
+    expect(err.body).toBe('Internal Server Error');
+  });
+
+  it('accepts null body', () => {
+    const err = new HTTPError(502, null);
+    expect(err.body).toBeNull();
+    expect(err.message).toContain('502');
+  });
+
+  it('uses status hint when body is empty', () => {
+    const err = new HTTPError(503, '');
+    expect(err.message).toContain('Service Unavailable');
+  });
+
+  it('isRetryable returns true for 429', () => {
+    const err = new HTTPError(429, 'Too Many Requests');
+    expect(err.isRetryable).toBe(true);
+  });
+
+  it('isRetryable returns true for 5xx', () => {
+    expect(new HTTPError(500, '').isRetryable).toBe(true);
+    expect(new HTTPError(502, '').isRetryable).toBe(true);
+    expect(new HTTPError(503, '').isRetryable).toBe(true);
+    expect(new HTTPError(504, '').isRetryable).toBe(true);
+  });
+
+  it('isRetryable returns false for 4xx (except 429)', () => {
+    expect(new HTTPError(400, '').isRetryable).toBe(false);
+    expect(new HTTPError(403, '').isRetryable).toBe(false);
+    expect(new HTTPError(404, '').isRetryable).toBe(false);
+  });
+
+  it('isRetryable returns false for 599 (upper boundary)', () => {
+    expect(new HTTPError(599, '').isRetryable).toBe(true);
+  });
+
+  it('uses body when present over status hint', () => {
+    const err = new HTTPError(502, 'Custom error body');
+    expect(err.message).toContain('Custom error body');
+  });
+});

package/core/packages/rest/src/errors/HTTPError.ts

@@ -0,0 +1,25 @@
+const STATUS_MESSAGES: Record<number, string> = {
+  502: 'Bad Gateway — Fluxer API may be temporarily unavailable.',
+  503: 'Service Unavailable — Fluxer API is down or overloaded. Try again later.',
+  504: 'Gateway Timeout — Fluxer API did not respond in time.',
+};
+
+export class HTTPError extends Error {
+  readonly statusCode: number;
+  readonly body: string | null;
+
+  constructor(statusCode: number, body: string | null) {
+    const hint = STATUS_MESSAGES[statusCode];
+    const detail = body?.trim() || (hint ?? 'No body');
+    super(`HTTP ${statusCode}: ${detail}`);
+    this.name = 'HTTPError';
+    this.statusCode = statusCode;
+    this.body = body;
+    Object.setPrototypeOf(this, HTTPError.prototype);
+  }
+
+  /** True if the error is retryable (429 rate limit, 5xx server errors). */
+  get isRetryable(): boolean {
+    return this.statusCode === 429 || (this.statusCode >= 500 && this.statusCode < 600);
+  }
+}

package/core/packages/rest/src/errors/RateLimitError.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from 'vitest';
+import { RateLimitError } from './RateLimitError.js';
+
+describe('RateLimitError', () => {
+  it('extends FluxerAPIError with retryAfter and global', () => {
+    const err = new RateLimitError(
+      { message: 'Rate limited', code: 'RATE_LIMITED', retry_after: 5 },
+      429,
+    );
+    expect(err.message).toBe('Rate limited');
+    expect(err.name).toBe('RateLimitError');
+    expect(err.statusCode).toBe(429);
+    expect(err.retryAfter).toBe(5);
+    expect(err.global).toBe(false);
+  });
+
+  it('sets global from body when true', () => {
+    const err = new RateLimitError(
+      { message: 'Global rate limit', code: 'RATE_LIMITED', retry_after: 10, global: true },
+      429,
+    );
+    expect(err.global).toBe(true);
+    expect(err.retryAfter).toBe(10);
+  });
+
+  it('defaults global to false when omitted', () => {
+    const err = new RateLimitError(
+      { message: 'Limited', code: 'RATE_LIMITED', retry_after: 1 },
+      429,
+    );
+    expect(err.global).toBe(false);
+  });
+
+  it('isRetryable returns true (inherited from FluxerAPIError)', () => {
+    const err = new RateLimitError(
+      { message: 'Limited', code: 'RATE_LIMITED', retry_after: 1 },
+      429,
+    );
+    expect(err.isRetryable).toBe(true);
+  });
+});

package/core/packages/rest/src/errors/RateLimitError.ts

@@ -0,0 +1,15 @@
+import { RateLimitErrorBody } from '@erinjs/types';
+import { FluxerAPIError } from './FluxerAPIError.js';
+
+export class RateLimitError extends FluxerAPIError {
+  readonly retryAfter: number;
+  readonly global: boolean;
+
+  constructor(body: RateLimitErrorBody, statusCode: number) {
+    super(body, statusCode);
+    this.retryAfter = body.retry_after;
+    this.global = body.global ?? false;
+    this.name = 'RateLimitError';
+    Object.setPrototypeOf(this, RateLimitError.prototype);
+  }
+}

package/core/packages/rest/src/errors/index.ts

@@ -0,0 +1,3 @@
+export { FluxerAPIError } from './FluxerAPIError.js';
+export { RateLimitError } from './RateLimitError.js';
+export { HTTPError } from './HTTPError.js';

package/core/packages/rest/src/index.ts

@@ -0,0 +1,6 @@
+export { REST, type RESTOptions } from './REST.js';
+export { RequestManager, type RequestOptions, type RestOptions } from './RequestManager.js';
+export { RateLimitManager, type RateLimitState } from './RateLimitManager.js';
+export { FluxerAPIError, RateLimitError, HTTPError } from './errors/index.js';
+export { buildFormData, type AttachmentPayload, type AttachmentData } from './utils/files.js';
+export { Routes } from '@erinjs/types';

package/core/packages/rest/src/utils/constants.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import {
+  DEFAULT_API,
+  DEFAULT_VERSION,
+  DEFAULT_USER_AGENT,
+  REQUEST_TIMEOUT,
+  MAX_RETRIES,
+} from './constants.js';
+
+describe('rest constants', () => {
+  it('DEFAULT_API points to Fluxer API', () => {
+    expect(DEFAULT_API).toBe('https://api.fluxer.app');
+  });
+
+  it('DEFAULT_VERSION is 1', () => {
+    expect(DEFAULT_VERSION).toBe('1');
+  });
+
+  it('DEFAULT_USER_AGENT contains erin.js and repository URL', () => {
+    expect(DEFAULT_USER_AGENT).toContain('erin.js');
+    expect(DEFAULT_USER_AGENT).toContain('github.com/blstmo-abandoned-us-for-the-milk/core');
+  });
+
+  it('REQUEST_TIMEOUT is 15 seconds', () => {
+    expect(REQUEST_TIMEOUT).toBe(15000);
+  });
+
+  it('MAX_RETRIES is 3', () => {
+    expect(MAX_RETRIES).toBe(3);
+  });
+});

package/core/packages/rest/src/utils/constants.ts

@@ -0,0 +1,5 @@
+export const DEFAULT_API = 'https://api.fluxer.app';
+export const DEFAULT_VERSION = '1';
+export const DEFAULT_USER_AGENT = `erin.js (https://github.com/blstmo-abandoned-us-for-the-milk/core)`;
+export const REQUEST_TIMEOUT = 15000;
+export const MAX_RETRIES = 3;

package/core/packages/rest/src/utils/files.test.ts

@@ -0,0 +1,37 @@
+import { describe, it, expect } from 'vitest';
+import { buildFormData } from './files.js';
+
+describe('buildFormData', () => {
+  it('creates FormData with payload_json only', () => {
+    const payload = { content: 'Hello' };
+    const form = buildFormData(payload);
+    expect(form.get('payload_json')).toBe(JSON.stringify(payload));
+    expect(form.get('files[0]')).toBeNull();
+  });
+
+  it('adds files with auto-generated attachments metadata', () => {
+    const payload = { content: 'With file' };
+    const files = [{ name: 'test.txt', data: new Uint8Array([1, 2, 3]) }];
+    const form = buildFormData(payload, files);
+    expect(form.get('payload_json')).toBeTruthy();
+    const parsed = JSON.parse(form.get('payload_json') as string);
+    expect(parsed.attachments).toEqual([{ id: 0, filename: 'test.txt' }]);
+    expect(form.get('files[0]')).toBeTruthy();
+  });
+
+  it('uses custom filename when provided', () => {
+    const payload = {};
+    const files = [{ name: 'a', data: new Uint8Array(), filename: 'custom.png' }];
+    const form = buildFormData(payload, files);
+    const parsed = JSON.parse(form.get('payload_json') as string);
+    expect(parsed.attachments).toEqual([{ id: 0, filename: 'custom.png' }]);
+  });
+
+  it('preserves existing attachments when files provided', () => {
+    const payload = { attachments: [{ id: 0, filename: 'existing.png', description: 'desc' }] };
+    const files = [{ name: 'x', data: new Uint8Array() }];
+    const form = buildFormData(payload, files);
+    const parsed = JSON.parse(form.get('payload_json') as string);
+    expect(parsed.attachments[0].description).toBe('desc');
+  });
+});

package/core/packages/rest/src/utils/files.ts

@@ -0,0 +1,75 @@
+/**
+ * File handling for multipart requests. Matches fluxer_api parseMultipartMessageData exactly:
+ * - payload_json: JSON string with content, embeds, attachments metadata
+ * - files[N]: File parts where N is 0-based index (fluxer API expects files[0], files[1], etc.)
+ *
+ * @see fluxer_api MessageController.parseMultipartMessageData
+ * @see fluxer_api AttachmentDTOs.ClientAttachmentRequest (id, filename required)
+ */
+
+export type AttachmentData = Blob | ArrayBuffer | Uint8Array | Buffer;
+
+export interface AttachmentPayload {
+  /** Used as filename when filename is not set (required) */
+  name: string;
+  data: AttachmentData;
+  /** Override filename for the part (defaults to name) */
+  filename?: string;
+}
+
+/**
+ * Convert attachment data to a Blob. Handles Node.js Buffer (extends Uint8Array).
+ */
+function toBlob(data: AttachmentData): Blob {
+  if (data instanceof Blob) return data;
+  return new Blob([data as BlobPart]);
+}
+
+/**
+ * Create a File instance for FormData append. Ensures server receives proper File
+ * (fluxer_api checks `file instanceof File`). Node.js 20+ has global File.
+ */
+function toFormDataFile(data: AttachmentData, filename: string): Blob | File {
+  const blob = toBlob(data);
+  if (typeof File !== 'undefined') {
+    return new File([blob], filename, { type: blob.type || 'application/octet-stream' });
+  }
+  return blob;
+}
+
+/**
+ * Build FormData for message with attachments.
+ * Matches fluxer_api parseMultipartMessageData expectations:
+ * - payload_json: JSON string (required)
+ * - files[0], files[1], ...: File parts with indices matching payload_json.attachments[].id
+ *
+ * Attachment metadata in payload_json must have id and filename for each file.
+ */
+export function buildFormData(
+  payloadJson: Record<string, unknown>,
+  files?: AttachmentPayload[],
+): FormData {
+  const form = new FormData();
+
+  // payload_json is required; must include attachments metadata when files present
+  const payload = { ...payloadJson };
+  if (files?.length && !payload.attachments) {
+    payload.attachments = files.map((f, i) => ({
+      id: i,
+      filename: f.filename ?? f.name,
+    }));
+  }
+  form.append('payload_json', JSON.stringify(payload));
+
+  if (files?.length) {
+    for (let i = 0; i < files.length; i++) {
+      const file = files[i];
+      if (!file) continue;
+      const filename = file.filename ?? file.name;
+      const part = toFormDataFile(file.data, filename);
+      form.append(`files[${i}]`, part, filename);
+    }
+  }
+
+  return form;
+}

package/core/packages/rest/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "noEmit": false
+  },
+  "include": ["src/**/*"]
+}

package/core/packages/rest/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  clean: true,
+});

package/core/packages/rest/vitest.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts'],
+  },
+});