@erinjs/core 1.0.0 → 1.2.4

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

@@ -1,87 +0,0 @@
-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

@@ -1,172 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

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

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

@@ -1,6 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,75 +0,0 @@
-/**
- * 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

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

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

@@ -1,9 +0,0 @@
-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

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