@tinybirdco/sdk 0.0.1

package/src/schema/types.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect } from 'vitest';
+import { t, isTypeValidator, getTinybirdType, getModifiers } from './types.js';
+
+describe('Type Validators (t.*)', () => {
+  describe('Basic types', () => {
+    it('generates String type', () => {
+      const type = t.string();
+      expect(type._tinybirdType).toBe('String');
+    });
+
+    it('generates Int32 type', () => {
+      const type = t.int32();
+      expect(type._tinybirdType).toBe('Int32');
+    });
+
+    it('generates DateTime type', () => {
+      const type = t.dateTime();
+      expect(type._tinybirdType).toBe('DateTime');
+    });
+
+    it('generates DateTime with timezone', () => {
+      const type = t.dateTime('UTC');
+      expect(type._tinybirdType).toBe("DateTime('UTC')");
+    });
+
+    it('generates Bool type', () => {
+      const type = t.bool();
+      expect(type._tinybirdType).toBe('Bool');
+    });
+
+    it('generates UUID type', () => {
+      const type = t.uuid();
+      expect(type._tinybirdType).toBe('UUID');
+    });
+
+    it('generates Float64 type', () => {
+      const type = t.float64();
+      expect(type._tinybirdType).toBe('Float64');
+    });
+
+    it('generates UInt64 type', () => {
+      const type = t.uint64();
+      expect(type._tinybirdType).toBe('UInt64');
+    });
+  });
+
+  describe('Nullable modifier', () => {
+    it('wraps type in Nullable', () => {
+      const type = t.string().nullable();
+      expect(type._tinybirdType).toBe('Nullable(String)');
+    });
+
+    it('wraps Int32 in Nullable', () => {
+      const type = t.int32().nullable();
+      expect(type._tinybirdType).toBe('Nullable(Int32)');
+    });
+
+    it('sets nullable modifier', () => {
+      const type = t.string().nullable();
+      expect(type._modifiers.nullable).toBe(true);
+    });
+  });
+
+  describe('LowCardinality modifier', () => {
+    it('wraps type in LowCardinality', () => {
+      const type = t.string().lowCardinality();
+      expect(type._tinybirdType).toBe('LowCardinality(String)');
+    });
+
+    it('sets lowCardinality modifier', () => {
+      const type = t.string().lowCardinality();
+      expect(type._modifiers.lowCardinality).toBe(true);
+    });
+  });
+
+  describe('LowCardinality + Nullable ordering', () => {
+    it('generates LowCardinality(Nullable(X)) when chaining .lowCardinality().nullable()', () => {
+      const type = t.string().lowCardinality().nullable();
+      expect(type._tinybirdType).toBe('LowCardinality(Nullable(String))');
+    });
+
+    it('generates LowCardinality(Nullable(X)) when chaining .nullable().lowCardinality()', () => {
+      const type = t.string().nullable().lowCardinality();
+      expect(type._tinybirdType).toBe('LowCardinality(Nullable(String))');
+    });
+
+    it('preserves both modifiers when chained', () => {
+      const type = t.string().lowCardinality().nullable();
+      expect(type._modifiers.lowCardinality).toBe(true);
+      expect(type._modifiers.nullable).toBe(true);
+    });
+  });
+
+  describe('Default values', () => {
+    it('sets hasDefault modifier', () => {
+      const type = t.string().default('test');
+      expect(type._modifiers.hasDefault).toBe(true);
+    });
+
+    it('stores defaultValue in modifiers', () => {
+      const type = t.string().default('test');
+      expect(type._modifiers.defaultValue).toBe('test');
+    });
+
+    it('works with numeric defaults', () => {
+      const type = t.int32().default(42);
+      expect(type._modifiers.defaultValue).toBe(42);
+    });
+  });
+
+  describe('Codec modifier', () => {
+    it('sets codec in modifiers', () => {
+      const type = t.string().codec('LZ4');
+      expect(type._modifiers.codec).toBe('LZ4');
+    });
+  });
+
+  describe('Complex types', () => {
+    it('generates Array type', () => {
+      const type = t.array(t.string());
+      expect(type._tinybirdType).toBe('Array(String)');
+    });
+
+    it('generates nested Array type', () => {
+      const type = t.array(t.int32());
+      expect(type._tinybirdType).toBe('Array(Int32)');
+    });
+
+    it('generates Map type', () => {
+      const type = t.map(t.string(), t.int32());
+      expect(type._tinybirdType).toBe('Map(String, Int32)');
+    });
+
+    it('generates Decimal type', () => {
+      const type = t.decimal(10, 2);
+      expect(type._tinybirdType).toBe('Decimal(10, 2)');
+    });
+
+    it('generates FixedString type', () => {
+      const type = t.fixedString(3);
+      expect(type._tinybirdType).toBe('FixedString(3)');
+    });
+
+    it('generates Tuple type', () => {
+      const type = t.tuple(t.string(), t.int32());
+      expect(type._tinybirdType).toBe('Tuple(String, Int32)');
+    });
+
+    it('generates DateTime64 type', () => {
+      const type = t.dateTime64(3);
+      expect(type._tinybirdType).toBe('DateTime64(3)');
+    });
+
+    it('generates DateTime64 with timezone', () => {
+      const type = t.dateTime64(3, 'UTC');
+      expect(type._tinybirdType).toBe("DateTime64(3, 'UTC')");
+    });
+  });
+
+  describe('Helper functions', () => {
+    it('isTypeValidator returns true for validators', () => {
+      expect(isTypeValidator(t.string())).toBe(true);
+    });
+
+    it('isTypeValidator returns false for non-validators', () => {
+      expect(isTypeValidator('string')).toBe(false);
+      expect(isTypeValidator({})).toBe(false);
+      expect(isTypeValidator(null)).toBe(false);
+    });
+
+    it('getTinybirdType returns type string', () => {
+      expect(getTinybirdType(t.string())).toBe('String');
+    });
+
+    it('getModifiers returns modifiers object', () => {
+      const modifiers = getModifiers(t.string().nullable());
+      expect(modifiers.nullable).toBe(true);
+    });
+  });
+
+  describe('Chained modifiers', () => {
+    it('supports multiple modifiers', () => {
+      const type = t.string().lowCardinality().default('test');
+      expect(type._tinybirdType).toBe('LowCardinality(String)');
+      expect(type._modifiers.lowCardinality).toBe(true);
+      expect(type._modifiers.hasDefault).toBe(true);
+      expect(type._modifiers.defaultValue).toBe('test');
+    });
+  });
+
+  describe('Enum types', () => {
+    it('generates Enum8 with value mapping', () => {
+      const type = t.enum8('active', 'inactive', 'pending');
+      expect(type._tinybirdType).toBe("Enum8('active' = 1, 'inactive' = 2, 'pending' = 3)");
+    });
+
+    it('generates Enum16 with value mapping', () => {
+      const type = t.enum16('draft', 'published', 'archived');
+      expect(type._tinybirdType).toBe("Enum16('draft' = 1, 'published' = 2, 'archived' = 3)");
+    });
+
+    it('escapes single quotes in enum values', () => {
+      const type = t.enum8("it's ok", 'normal');
+      expect(type._tinybirdType).toBe("Enum8('it\\'s ok' = 1, 'normal' = 2)");
+    });
+
+    it('handles single enum value', () => {
+      const type = t.enum8('only');
+      expect(type._tinybirdType).toBe("Enum8('only' = 1)");
+    });
+  });
+});

package/src/schema/types.ts

@@ -0,0 +1,366 @@
+/**
+ * Column type validators for Tinybird datasources
+ * Similar to Convex's `v.*` pattern, but for ClickHouse types
+ */
+
+// Symbol for brand typing
+const VALIDATOR_BRAND = Symbol("tinybird.validator");
+
+/**
+ * Base interface for all type validators
+ * The phantom types enable TypeScript to infer the correct types
+ */
+export interface TypeValidator<
+  TType,
+  TTinybirdType extends string = string,
+  TModifiers extends TypeModifiers = TypeModifiers
+> {
+  readonly [VALIDATOR_BRAND]: true;
+  /** The inferred TypeScript type */
+  readonly _type: TType;
+  /** The Tinybird/ClickHouse type string */
+  readonly _tinybirdType: TTinybirdType;
+  /** Metadata about modifiers applied */
+  readonly _modifiers: TModifiers;
+
+  /** Make this column nullable */
+  nullable(): TypeValidator<TType | null, `Nullable(${TTinybirdType})`, TModifiers & { nullable: true }>;
+  /** Apply LowCardinality optimization (for strings with few unique values) */
+  lowCardinality(): TypeValidator<TType, `LowCardinality(${TTinybirdType})`, TModifiers & { lowCardinality: true }>;
+  /** Set a default value for the column */
+  default(value: TType): TypeValidator<TType, TTinybirdType, TModifiers & { hasDefault: true; defaultValue: TType }>;
+  /** Set a codec for compression */
+  codec(codec: string): TypeValidator<TType, TTinybirdType, TModifiers & { codec: string }>;
+}
+
+export interface TypeModifiers {
+  nullable?: boolean;
+  lowCardinality?: boolean;
+  hasDefault?: boolean;
+  defaultValue?: unknown;
+  codec?: string;
+}
+
+// Internal implementation
+interface ValidatorImpl<TType, TTinybirdType extends string, TModifiers extends TypeModifiers>
+  extends TypeValidator<TType, TTinybirdType, TModifiers> {
+  readonly tinybirdType: TTinybirdType;
+  readonly modifiers: TModifiers;
+}
+
+function createValidator<TType, TTinybirdType extends string>(
+  tinybirdType: TTinybirdType,
+  modifiers: TypeModifiers = {}
+): TypeValidator<TType, TTinybirdType, TypeModifiers> {
+  const validator: ValidatorImpl<TType, TTinybirdType, TypeModifiers> = {
+    [VALIDATOR_BRAND]: true,
+    _type: undefined as unknown as TType,
+    _tinybirdType: tinybirdType,
+    _modifiers: modifiers,
+    tinybirdType,
+    modifiers,
+
+    nullable() {
+      // If already has LowCardinality, we need to move Nullable inside
+      // ClickHouse requires: LowCardinality(Nullable(X)), not Nullable(LowCardinality(X))
+      if (modifiers.lowCardinality) {
+        // Extract base type from LowCardinality(X) and wrap as LowCardinality(Nullable(X))
+        const baseType = tinybirdType.replace(/^LowCardinality\((.+)\)$/, '$1');
+        const newType = `LowCardinality(Nullable(${baseType}))`;
+        return createValidator<TType | null, `LowCardinality(Nullable(${string}))`>(
+          newType as `LowCardinality(Nullable(${string}))`,
+          { ...modifiers, nullable: true }
+        ) as unknown as TypeValidator<TType | null, `Nullable(${TTinybirdType})`, TypeModifiers & { nullable: true }>;
+      }
+      return createValidator<TType | null, `Nullable(${TTinybirdType})`>(
+        `Nullable(${tinybirdType})` as `Nullable(${TTinybirdType})`,
+        { ...modifiers, nullable: true }
+      ) as TypeValidator<TType | null, `Nullable(${TTinybirdType})`, TypeModifiers & { nullable: true }>;
+    },
+
+    lowCardinality() {
+      // If already nullable, wrap as LowCardinality(Nullable(X))
+      if (modifiers.nullable) {
+        // Extract base type from Nullable(X) and wrap as LowCardinality(Nullable(X))
+        const baseType = tinybirdType.replace(/^Nullable\((.+)\)$/, '$1');
+        const newType = `LowCardinality(Nullable(${baseType}))`;
+        return createValidator<TType, `LowCardinality(Nullable(${string}))`>(
+          newType as `LowCardinality(Nullable(${string}))`,
+          { ...modifiers, lowCardinality: true }
+        ) as unknown as TypeValidator<TType, `LowCardinality(${TTinybirdType})`, TypeModifiers & { lowCardinality: true }>;
+      }
+      return createValidator<TType, `LowCardinality(${TTinybirdType})`>(
+        `LowCardinality(${tinybirdType})` as `LowCardinality(${TTinybirdType})`,
+        { ...modifiers, lowCardinality: true }
+      ) as TypeValidator<TType, `LowCardinality(${TTinybirdType})`, TypeModifiers & { lowCardinality: true }>;
+    },
+
+    default(value: TType) {
+      return createValidator<TType, TTinybirdType>(tinybirdType, {
+        ...modifiers,
+        hasDefault: true,
+        defaultValue: value,
+      }) as TypeValidator<TType, TTinybirdType, TypeModifiers & { hasDefault: true; defaultValue: TType }>;
+    },
+
+    codec(codec: string) {
+      return createValidator<TType, TTinybirdType>(tinybirdType, {
+        ...modifiers,
+        codec,
+      }) as TypeValidator<TType, TTinybirdType, TypeModifiers & { codec: string }>;
+    },
+  };
+
+  return validator;
+}
+
+/**
+ * Type validators for Tinybird columns
+ *
+ * @example
+ * ```ts
+ * import { t } from '@tinybirdco/sdk';
+ *
+ * const schema = {
+ *   id: t.string(),
+ *   count: t.int32(),
+ *   timestamp: t.dateTime(),
+ *   tags: t.array(t.string()),
+ *   metadata: t.json(),
+ * };
+ * ```
+ */
+export const t = {
+  // ============ String Types ============
+
+  /** String type - variable length UTF-8 string */
+  string: () => createValidator<string, "String">("String"),
+
+  /** FixedString(N) - fixed length string, padded with null bytes */
+  fixedString: (length: number) =>
+    createValidator<string, `FixedString(${number})`>(`FixedString(${length})`),
+
+  /** UUID - 16-byte universally unique identifier */
+  uuid: () => createValidator<string, "UUID">("UUID"),
+
+  // ============ Integer Types ============
+
+  /** Int8 - signed 8-bit integer (-128 to 127) */
+  int8: () => createValidator<number, "Int8">("Int8"),
+
+  /** Int16 - signed 16-bit integer */
+  int16: () => createValidator<number, "Int16">("Int16"),
+
+  /** Int32 - signed 32-bit integer */
+  int32: () => createValidator<number, "Int32">("Int32"),
+
+  /** Int64 - signed 64-bit integer (represented as number, may lose precision) */
+  int64: () => createValidator<number, "Int64">("Int64"),
+
+  /** Int128 - signed 128-bit integer (represented as bigint) */
+  int128: () => createValidator<bigint, "Int128">("Int128"),
+
+  /** Int256 - signed 256-bit integer (represented as bigint) */
+  int256: () => createValidator<bigint, "Int256">("Int256"),
+
+  /** UInt8 - unsigned 8-bit integer (0 to 255) */
+  uint8: () => createValidator<number, "UInt8">("UInt8"),
+
+  /** UInt16 - unsigned 16-bit integer */
+  uint16: () => createValidator<number, "UInt16">("UInt16"),
+
+  /** UInt32 - unsigned 32-bit integer */
+  uint32: () => createValidator<number, "UInt32">("UInt32"),
+
+  /** UInt64 - unsigned 64-bit integer (represented as number, may lose precision) */
+  uint64: () => createValidator<number, "UInt64">("UInt64"),
+
+  /** UInt128 - unsigned 128-bit integer (represented as bigint) */
+  uint128: () => createValidator<bigint, "UInt128">("UInt128"),
+
+  /** UInt256 - unsigned 256-bit integer (represented as bigint) */
+  uint256: () => createValidator<bigint, "UInt256">("UInt256"),
+
+  // ============ Float Types ============
+
+  /** Float32 - 32-bit floating point */
+  float32: () => createValidator<number, "Float32">("Float32"),
+
+  /** Float64 - 64-bit floating point (double precision) */
+  float64: () => createValidator<number, "Float64">("Float64"),
+
+  /** Decimal(precision, scale) - fixed-point decimal number */
+  decimal: (precision: number, scale: number) =>
+    createValidator<number, `Decimal(${number}, ${number})`>(
+      `Decimal(${precision}, ${scale})`
+    ),
+
+  // ============ Boolean ============
+
+  /** Bool - boolean value (true/false) */
+  bool: () => createValidator<boolean, "Bool">("Bool"),
+
+  // ============ Date/Time Types ============
+
+  /** Date - date without time (YYYY-MM-DD) */
+  date: () => createValidator<Date, "Date">("Date"),
+
+  /** Date32 - extended date range */
+  date32: () => createValidator<Date, "Date32">("Date32"),
+
+  /** DateTime - date and time with second precision */
+  dateTime: (timezone?: string) =>
+    timezone
+      ? createValidator<Date, `DateTime('${string}')`>(`DateTime('${timezone}')`)
+      : createValidator<Date, "DateTime">("DateTime"),
+
+  /** DateTime64 - date and time with sub-second precision */
+  dateTime64: (precision: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 = 3, timezone?: string) =>
+    timezone
+      ? createValidator<Date, `DateTime64(${number}, '${string}')`>(
+          `DateTime64(${precision}, '${timezone}')`
+        )
+      : createValidator<Date, `DateTime64(${number})`>(`DateTime64(${precision})`),
+
+  // ============ Complex Types ============
+
+  /** Array(T) - array of elements of type T */
+  array: <TElement extends TypeValidator<unknown, string, TypeModifiers>>(
+    element: TElement
+  ): TypeValidator<
+    TElement["_type"][],
+    `Array(${TElement["_tinybirdType"]})`,
+    TypeModifiers
+  > =>
+    createValidator<TElement["_type"][], `Array(${TElement["_tinybirdType"]})`>(
+      `Array(${element._tinybirdType})` as `Array(${TElement["_tinybirdType"]})`
+    ),
+
+  /** Tuple(T1, T2, ...) - tuple of heterogeneous types */
+  tuple: <TElements extends readonly TypeValidator<unknown, string, TypeModifiers>[]>(
+    ...elements: TElements
+  ): TypeValidator<
+    { [K in keyof TElements]: TElements[K]["_type"] },
+    `Tuple(${string})`,
+    TypeModifiers
+  > =>
+    createValidator<
+      { [K in keyof TElements]: TElements[K]["_type"] },
+      `Tuple(${string})`
+    >(`Tuple(${elements.map((e) => e._tinybirdType).join(", ")})`),
+
+  /** Map(K, V) - dictionary/map type */
+  map: <
+    TKey extends TypeValidator<string | number, string, TypeModifiers>,
+    TValue extends TypeValidator<unknown, string, TypeModifiers>
+  >(
+    keyType: TKey,
+    valueType: TValue
+  ): TypeValidator<
+    Map<TKey["_type"], TValue["_type"]>,
+    `Map(${TKey["_tinybirdType"]}, ${TValue["_tinybirdType"]})`,
+    TypeModifiers
+  > =>
+    createValidator<
+      Map<TKey["_type"], TValue["_type"]>,
+      `Map(${TKey["_tinybirdType"]}, ${TValue["_tinybirdType"]})`
+    >(`Map(${keyType._tinybirdType}, ${valueType._tinybirdType})`),
+
+  /** JSON - semi-structured JSON data */
+  json: <TShape = unknown>() => createValidator<TShape, "JSON">("JSON"),
+
+  // ============ Enum Types ============
+
+  /** Enum8 - enumeration stored as Int8 */
+  enum8: <TValues extends readonly string[]>(...values: TValues) => {
+    const enumMapping = values
+      .map((v, i) => `'${v.replace(/'/g, "\\'")}' = ${i + 1}`)
+      .join(", ");
+    return createValidator<TValues[number], `Enum8(${string})`>(
+      `Enum8(${enumMapping})` as `Enum8(${string})`
+    );
+  },
+
+  /** Enum16 - enumeration stored as Int16 */
+  enum16: <TValues extends readonly string[]>(...values: TValues) => {
+    const enumMapping = values
+      .map((v, i) => `'${v.replace(/'/g, "\\'")}' = ${i + 1}`)
+      .join(", ");
+    return createValidator<TValues[number], `Enum16(${string})`>(
+      `Enum16(${enumMapping})` as `Enum16(${string})`
+    );
+  },
+
+  // ============ Special Types ============
+
+  /** IPv4 - IPv4 address */
+  ipv4: () => createValidator<string, "IPv4">("IPv4"),
+
+  /** IPv6 - IPv6 address */
+  ipv6: () => createValidator<string, "IPv6">("IPv6"),
+
+  // ============ Aggregate Function States ============
+
+  /** SimpleAggregateFunction - for materialized views with simple aggregates */
+  simpleAggregateFunction: <
+    TFunc extends string,
+    TType extends TypeValidator<unknown, string, TypeModifiers>
+  >(
+    func: TFunc,
+    type: TType
+  ): TypeValidator<
+    TType["_type"],
+    `SimpleAggregateFunction(${TFunc}, ${TType["_tinybirdType"]})`,
+    TypeModifiers
+  > =>
+    createValidator<
+      TType["_type"],
+      `SimpleAggregateFunction(${TFunc}, ${TType["_tinybirdType"]})`
+    >(`SimpleAggregateFunction(${func}, ${type._tinybirdType})`),
+
+  /** AggregateFunction - for materialized views with complex aggregates */
+  aggregateFunction: <
+    TFunc extends string,
+    TType extends TypeValidator<unknown, string, TypeModifiers>
+  >(
+    func: TFunc,
+    type: TType
+  ): TypeValidator<
+    TType["_type"],
+    `AggregateFunction(${TFunc}, ${TType["_tinybirdType"]})`,
+    TypeModifiers
+  > =>
+    createValidator<
+      TType["_type"],
+      `AggregateFunction(${TFunc}, ${TType["_tinybirdType"]})`
+    >(`AggregateFunction(${func}, ${type._tinybirdType})`),
+} as const;
+
+/** Type alias for any type validator */
+export type AnyTypeValidator = TypeValidator<unknown, string, TypeModifiers>;
+
+/** Extract the TypeScript type from a type validator */
+export type InferType<T extends AnyTypeValidator> = T["_type"];
+
+/** Extract the Tinybird type string from a type validator */
+export type TinybirdType<T extends AnyTypeValidator> = T["_tinybirdType"];
+
+/** Helper to check if a value is a type validator */
+export function isTypeValidator(value: unknown): value is AnyTypeValidator {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    VALIDATOR_BRAND in value &&
+    (value as Record<symbol, unknown>)[VALIDATOR_BRAND] === true
+  );
+}
+
+/** Get the Tinybird type string from a validator */
+export function getTinybirdType(validator: AnyTypeValidator): string {
+  return validator._tinybirdType;
+}
+
+/** Get the modifiers from a validator */
+export function getModifiers(validator: AnyTypeValidator): TypeModifiers {
+  return validator._modifiers;
+}

package/src/test/handlers.ts

@@ -0,0 +1,79 @@
+/**
+ * MSW handlers for API mocking in tests
+ */
+
+import { http, HttpResponse } from "msw";
+
+export const BASE_URL = "https://api.tinybird.co";
+
+/**
+ * Create build success response
+ */
+export function createBuildSuccessResponse(options?: {
+  buildId?: string;
+  changedPipes?: string[];
+  newPipes?: string[];
+  deletedPipes?: string[];
+  changedDatasources?: string[];
+  newDatasources?: string[];
+  deletedDatasources?: string[];
+}) {
+  return {
+    result: "success",
+    build: {
+      id: options?.buildId ?? "build-123",
+      changed_pipe_names: options?.changedPipes ?? [],
+      new_pipe_names: options?.newPipes ?? [],
+      deleted_pipe_names: options?.deletedPipes ?? [],
+      changed_datasource_names: options?.changedDatasources ?? [],
+      new_datasource_names: options?.newDatasources ?? [],
+      deleted_datasource_names: options?.deletedDatasources ?? [],
+    },
+  };
+}
+
+/**
+ * Create build failure response
+ */
+export function createBuildFailureResponse(error: string) {
+  return {
+    result: "failed",
+    error,
+  };
+}
+
+/**
+ * Create build failure response with multiple errors
+ */
+export function createBuildMultipleErrorsResponse(
+  errors: Array<{ filename?: string; error: string }>
+) {
+  return {
+    result: "failed",
+    errors,
+  };
+}
+
+/**
+ * Create no changes response
+ */
+export function createNoChangesResponse() {
+  return {
+    result: "no_changes",
+  };
+}
+
+/**
+ * Default handlers for build and deploy endpoints
+ */
+export const handlers = [
+  // Build endpoint - success by default
+  http.post(`${BASE_URL}/v1/build`, () => {
+    return HttpResponse.json(createBuildSuccessResponse());
+  }),
+
+  // Deploy endpoint - success by default
+  http.post(`${BASE_URL}/v1/deploy`, () => {
+    return HttpResponse.json(createBuildSuccessResponse());
+  }),
+];

package/src/test/setup.ts

@@ -0,0 +1,13 @@
+/**
+ * Test setup file for MSW
+ */
+
+import { beforeAll, afterEach, afterAll } from "vitest";
+import { setupServer } from "msw/node";
+import { handlers } from "./handlers.js";
+
+export const server = setupServer(...handlers);
+
+beforeAll(() => server.listen({ onUnhandledRequest: "error" }));
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());