@alumbwe/anvil 1.0.42 → 1.0.50

package/vendor/@anvil/common/src/testing/mocks/database.ts

@@ -1,337 +0,0 @@
-/**
- * Typed database mock factory for testing.
- *
- * Provides type-safe mocks for Drizzle database operations used throughout the codebase.
- * Replaces the need for `as any` casts when setting up database spies.
- *
- * @example
- * ```typescript
- * import { createMockDbOperations, setupDbSpies } from '@anvil/common/testing/mocks/database'
- *
- * // Option 1: Create mock operations object
- * const dbOps = createMockDbOperations()
- *
- * // Option 2: Setup spies on actual db module
- * const spies = setupDbSpies(db)
- * await runTest()
- * spies.restore()
- * ```
- */
-
-import { mock, spyOn } from 'bun:test'
-
-import type { Mock } from 'bun:test'
-
-/**
- * Type for the chainable insert result.
- */
-export interface MockInsertResult<T = unknown> {
-  values: Mock<(data: T | T[]) => Promise<{ id: string }>>
-  returning: Mock<() => Promise<T[]>>
-  onConflictDoNothing: Mock<() => MockInsertResult<T>>
-  onConflictDoUpdate: Mock<
-    (config: { target: unknown; set: unknown }) => MockInsertResult<T>
-  >
-}
-
-/**
- * Type for the chainable update result.
- */
-export interface MockUpdateResult<T = unknown> {
-  set: Mock<(data: Partial<T>) => MockUpdateSetResult>
-}
-
-/**
- * Type for the update.set result.
- */
-export interface MockUpdateSetResult {
-  where: Mock<(condition: unknown) => Promise<void>>
-  returning: Mock<() => Promise<unknown[]>>
-}
-
-/**
- * Type for the chainable select result.
- */
-export interface MockSelectResult<T = unknown> {
-  from: Mock<(table: unknown) => MockSelectFromResult<T>>
-}
-
-/**
- * Type for the select.from result.
- */
-export interface MockSelectFromResult<T = unknown> {
-  where: Mock<(condition: unknown) => MockSelectWhereResult<T>>
-  leftJoin: Mock<
-    (table: unknown, condition: unknown) => MockSelectFromResult<T>
-  >
-  innerJoin: Mock<
-    (table: unknown, condition: unknown) => MockSelectFromResult<T>
-  >
-  orderBy: Mock<(...columns: unknown[]) => MockSelectFromResult<T>>
-  limit: Mock<(n: number) => MockSelectFromResult<T>>
-  offset: Mock<(n: number) => MockSelectFromResult<T>>
-  then: Mock<(resolve: (value: T[]) => void) => Promise<T[]>>
-}
-
-/**
- * Type for the select.from.where result.
- */
-export interface MockSelectWhereResult<T = unknown> {
-  then: Mock<(resolve: (value: T[]) => void) => Promise<T[]>>
-  leftJoin: Mock<
-    (table: unknown, condition: unknown) => MockSelectWhereResult<T>
-  >
-  innerJoin: Mock<
-    (table: unknown, condition: unknown) => MockSelectWhereResult<T>
-  >
-  orderBy: Mock<(...columns: unknown[]) => MockSelectWhereResult<T>>
-  limit: Mock<(n: number) => MockSelectWhereResult<T>>
-  offset: Mock<(n: number) => MockSelectWhereResult<T>>
-}
-
-/**
- * Type for the chainable delete result.
- */
-export interface MockDeleteResult {
-  where: Mock<(condition: unknown) => Promise<void>>
-}
-
-/**
- * Interface for the complete mock database operations.
- */
-export interface MockDbOperations {
-  insert: Mock<(table: unknown) => MockInsertResult>
-  update: Mock<(table: unknown) => MockUpdateResult>
-  select: Mock<(columns?: unknown) => MockSelectResult>
-  delete: Mock<(table: unknown) => MockDeleteResult>
-  transaction: Mock<<T>(fn: (tx: MockDbOperations) => Promise<T>) => Promise<T>>
-}
-
-/**
- * Options for creating mock database operations.
- */
-export interface CreateMockDbOptions {
-  /**
-   * Default data to return from select queries.
-   */
-  defaultSelectData?: unknown[]
-
-  /**
-   * Default ID to return from insert operations.
-   */
-  defaultInsertId?: string
-}
-
-/**
- * Creates type-safe mock database operations for testing.
- *
- * @param options - Configuration options for the mock
- * @returns A mock database operations object
- *
- * @example
- * ```typescript
- * const dbOps = createMockDbOperations({
- *   defaultSelectData: [{ id: '1', name: 'Test' }],
- *   defaultInsertId: 'new-id',
- * })
- *
- * // The mocks are chainable just like real Drizzle
- * await dbOps.insert(users).values({ name: 'Test' })
- * await dbOps.select().from(users).where(eq(users.id, '1'))
- * ```
- */
-export function createMockDbOperations(
-  options: CreateMockDbOptions = {},
-): MockDbOperations {
-  const { defaultSelectData = [], defaultInsertId = 'mock-id' } = options
-
-  const createMockSelectWhereResult = <T>(
-    data: T[] = defaultSelectData as T[],
-  ): MockSelectWhereResult<T> => {
-    const result: MockSelectWhereResult<T> = {
-      then: mock((resolve) => {
-        resolve(data)
-        return Promise.resolve(data)
-      }),
-      leftJoin: mock(() => result),
-      innerJoin: mock(() => result),
-      orderBy: mock(() => result),
-      limit: mock(() => result),
-      offset: mock(() => result),
-    }
-    return result
-  }
-
-  const createMockSelectFromResult = <T>(
-    data: T[] = defaultSelectData as T[],
-  ): MockSelectFromResult<T> => {
-    const whereResult = createMockSelectWhereResult(data)
-    const result: MockSelectFromResult<T> = {
-      where: mock(() => whereResult),
-      leftJoin: mock(() => result),
-      innerJoin: mock(() => result),
-      orderBy: mock(() => result),
-      limit: mock(() => result),
-      offset: mock(() => result),
-      then: mock((resolve) => {
-        resolve(data)
-        return Promise.resolve(data)
-      }),
-    }
-    return result
-  }
-
-  const createMockInsertResult = <T>(): MockInsertResult<T> => {
-    const result: MockInsertResult<T> = {
-      values: mock(() => Promise.resolve({ id: defaultInsertId })),
-      returning: mock(() => Promise.resolve([])),
-      onConflictDoNothing: mock(() => result),
-      onConflictDoUpdate: mock(() => result),
-    }
-    return result
-  }
-
-  const createMockUpdateSetResult = (): MockUpdateSetResult => ({
-    where: mock(() => Promise.resolve()),
-    returning: mock(() => Promise.resolve([])),
-  })
-
-  const createMockUpdateResult = <T>(): MockUpdateResult<T> => ({
-    set: mock(() => createMockUpdateSetResult()),
-  })
-
-  const createMockDeleteResult = (): MockDeleteResult => ({
-    where: mock(() => Promise.resolve()),
-  })
-
-  const dbOps: MockDbOperations = {
-    insert: mock(() => createMockInsertResult()),
-    update: mock(() => createMockUpdateResult()),
-    select: mock(() => ({
-      from: mock(() => createMockSelectFromResult()),
-    })),
-    delete: mock(() => createMockDeleteResult()),
-    transaction: mock(async (fn) => fn(dbOps)),
-  }
-
-  return dbOps
-}
-
-/**
- * Result of setting up database spies.
- */
-export interface DbSpies {
-  /** Spy on insert operations */
-  insert: ReturnType<typeof spyOn>
-  /** Spy on update operations */
-  update: ReturnType<typeof spyOn>
-  /** Restore all spies */
-  restore: () => void
-  /** Clear all spy call history */
-  clear: () => void
-}
-
-/**
- * Sets up spies on a database module for insert and update operations.
- * This is the most common pattern used in tests.
- *
- * @param db - The database module to spy on
- * @param options - Configuration options
- * @returns Object containing the spies and cleanup utilities
- *
- * @example
- * ```typescript
- * const db = createMockDbOperations()
- *
- * describe('my test', () => {
- *   let dbSpies: DbSpies
- *
- *   beforeEach(() => {
- *     dbSpies = setupDbSpies(db)
- *   })
- *
- *   afterEach(() => {
- *     dbSpies.restore()
- *   })
- *
- *   it('inserts data', async () => {
- *     await createUser({ name: 'Test' })
- *     expect(dbSpies.insert).toHaveBeenCalled()
- *   })
- * })
- * ```
- */
-
-/**
- * Sets up spies on a database module for insert and update operations.
- * Accepts any object with insert and update methods.
- */
-export function setupDbSpies(
-  db: { insert: unknown; update: unknown },
-  options: CreateMockDbOptions = {},
-): DbSpies {
-  const { defaultInsertId = 'test-run-id' } = options
-
-  const mockInsertResult = {
-    values: mock(() => Promise.resolve({ id: defaultInsertId })),
-  }
-
-  const mockUpdateResult = {
-    set: mock(() => ({
-      where: mock(() => Promise.resolve()),
-    })),
-  }
-
-  // Cast db to a spyable type - the actual db module has complex types that
-  // don't play well with spyOn's inference, but the spy still works at runtime
-  const spyableDb = db as { insert: () => unknown; update: () => unknown }
-  const insertSpy = spyOn(spyableDb, 'insert').mockReturnValue(mockInsertResult)
-  const updateSpy = spyOn(spyableDb, 'update').mockReturnValue(mockUpdateResult)
-
-  return {
-    insert: insertSpy,
-    update: updateSpy,
-    restore: () => {
-      insertSpy.mockRestore()
-      updateSpy.mockRestore()
-    },
-    clear: () => {
-      insertSpy.mockClear()
-      updateSpy.mockClear()
-    },
-  }
-}
-
-/**
- * Creates a mock for a database query builder chain that returns specific data.
- *
- * @param data - The data to return from the query
- * @returns A thenable mock that resolves to the data
- *
- * @example
- * ```typescript
- * const mockQuery = createMockQueryResult([
- *   { id: '1', name: 'User 1' },
- *   { id: '2', name: 'User 2' },
- * ])
- *
- * spyOn(userService, 'findAll').mockReturnValue(mockQuery)
- * ```
- */
-export function createMockQueryResult<T>(data: T[]): Promise<T[]> & {
-  where: Mock<() => Promise<T[]>>
-  orderBy: Mock<() => Promise<T[]>>
-  limit: Mock<() => Promise<T[]>>
-} {
-  const promise = Promise.resolve(data) as Promise<T[]> & {
-    where: Mock<() => Promise<T[]>>
-    orderBy: Mock<() => Promise<T[]>>
-    limit: Mock<() => Promise<T[]>>
-  }
-
-  promise.where = mock(() => promise)
-  promise.orderBy = mock(() => promise)
-  promise.limit = mock(() => promise)
-
-  return promise
-}

package/vendor/@anvil/common/src/testing/mocks/fetch.ts

@@ -1,219 +0,0 @@
-/** Typed fetch mock utilities for testing. */
-
-import { mock } from 'bun:test'
-
-import type { Mock } from 'bun:test'
-
-export interface MockResponseOptions {
-  status?: number
-  statusText?: string
-  headers?: HeadersInit
-}
-
-export type MockFetch = Mock<typeof globalThis.fetch>
-
-export interface InstallMockFetchResult {
-  mockFetch: MockFetch
-  restore: () => void
-  getCalls: () => MockFetchCall[]
-  clear: () => void
-}
-
-export interface MockFetchCall {
-  url: string | URL | Request
-  init?: RequestInit
-  jsonBody?: unknown
-}
-
-export interface CreateMockFetchOptions {
-  defaultImpl?: (
-    input: RequestInfo | URL,
-    init?: RequestInit,
-  ) => Promise<Response>
-}
-
-/** Creates a Response with JSON body. */
-export function mockJsonResponse(
-  data: unknown,
-  options: MockResponseOptions = {},
-): Response {
-  const { status = 200, statusText, headers = {} } = options
-
-  return new Response(JSON.stringify(data), {
-    status,
-    statusText,
-    headers: {
-      'Content-Type': 'application/json',
-      ...normalizeHeaders(headers),
-    },
-  })
-}
-
-/** Creates a Response with text body. */
-export function mockTextResponse(
-  text: string,
-  options: MockResponseOptions = {},
-): Response {
-  const { status = 200, statusText, headers = {} } = options
-
-  return new Response(text, {
-    status,
-    statusText,
-    headers: {
-      'Content-Type': 'text/plain',
-      ...normalizeHeaders(headers),
-    },
-  })
-}
-
-/** Creates an error Response with default status text. */
-export function mockErrorResponse(
-  status: number,
-  body?: string | object,
-  options: Omit<MockResponseOptions, 'status'> = {},
-): Response {
-  const { statusText, headers = {} } = options
-
-  let responseBody: string
-  let contentType: string
-
-  if (body === undefined) {
-    responseBody = ''
-    contentType = 'text/plain'
-  } else if (typeof body === 'string') {
-    responseBody = body
-    contentType = 'text/plain'
-  } else {
-    responseBody = JSON.stringify(body)
-    contentType = 'application/json'
-  }
-
-  return new Response(responseBody, {
-    status,
-    statusText: statusText ?? getDefaultStatusText(status),
-    headers: {
-      'Content-Type': contentType,
-      ...normalizeHeaders(headers),
-    },
-  })
-}
-
-/** Creates a mock fetch function. */
-export function createMockFetch(
-  options: CreateMockFetchOptions = {},
-): MockFetch {
-  const { defaultImpl } = options
-
-  const baseFn =
-    defaultImpl ??
-    (async (): Promise<Response> => {
-      throw new Error('Mock fetch not configured for this call')
-    })
-
-  const mockFn = Object.assign(mock(baseFn), {
-    preconnect: mock(async () => {}),
-  }) as unknown as MockFetch
-
-  return mockFn
-}
-
-/**
- * Installs mock fetch globally. Returns mockFetch for configuration -
- * the wrapper always captures calls before delegating to mockFetch.
- */
-export function installMockFetch(
-  options: CreateMockFetchOptions = {},
-): InstallMockFetchResult {
-  const originalFetch = globalThis.fetch
-  const capturedCalls: MockFetchCall[] = []
-
-  const mockFetch = createMockFetch({
-    defaultImpl:
-      options.defaultImpl ??
-      (async (): Promise<Response> => {
-        throw new Error('Mock fetch not configured for this call')
-      }),
-  })
-
-  // Wrap to capture calls
-  const wrappedMockFn = mock(
-    async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-      const call: MockFetchCall = {
-        url: input,
-        init,
-      }
-
-      // Try to parse JSON body if present
-      if (init?.body && typeof init.body === 'string') {
-        try {
-          call.jsonBody = JSON.parse(init.body)
-        } catch {
-          // Not JSON, that's fine
-        }
-      }
-
-      capturedCalls.push(call)
-
-      // Call the actual mock implementation
-      return mockFetch(input, init)
-    },
-  )
-
-  const wrappedMock = Object.assign(wrappedMockFn, {
-    preconnect: mock(async () => {}),
-  }) as unknown as MockFetch
-
-  ;(globalThis as any).fetch = wrappedMock
-
-  return {
-    mockFetch,
-    restore: () => {
-      globalThis.fetch = originalFetch
-    },
-    getCalls: () => [...capturedCalls],
-    clear: () => {
-      capturedCalls.length = 0
-      mockFetch.mockClear()
-      wrappedMock.mockClear()
-    },
-  }
-}
-
-function normalizeHeaders(headers: HeadersInit): Record<string, string> {
-  if (headers instanceof Headers) {
-    const result: Record<string, string> = {}
-    headers.forEach((value, key) => {
-      result[key] = value
-    })
-    return result
-  }
-
-  if (Array.isArray(headers)) {
-    return Object.fromEntries(headers)
-  }
-
-  return headers as Record<string, string>
-}
-
-function getDefaultStatusText(status: number): string {
-  const statusTexts: Record<number, string> = {
-    200: 'OK',
-    201: 'Created',
-    204: 'No Content',
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    402: 'Payment Required',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    409: 'Conflict',
-    422: 'Unprocessable Entity',
-    429: 'Too Many Requests',
-    500: 'Internal Server Error',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-  }
-
-  return statusTexts[status] ?? ''
-}

package/vendor/@anvil/common/src/testing/mocks/filesystem.ts

@@ -1,166 +0,0 @@
-import { mock } from 'bun:test'
-
-import type { AnvilFileSystem } from '../../types/filesystem'
-import type { Mock } from 'bun:test'
-import type { PathLike , Stats } from 'node:fs'
-
-export interface CreateMockFsOptions {
-  files?: Record<string, string>
-  directories?: Record<string, string[]>
-  readFileImpl?: (path: string) => Promise<string>
-  readdirImpl?: (path: string) => Promise<string[]>
-  writeFileImpl?: (path: string, content: string) => Promise<void>
-  mkdirImpl?: (
-    path: string,
-    options?: { recursive?: boolean },
-  ) => Promise<string | undefined>
-  statImpl?: (path: string) => Promise<Stats>
-}
-
-export interface MockFs extends AnvilFileSystem {}
-
-export interface MockFsWithMocks {
-  readFile: Mock<
-    (path: PathLike, options?: { encoding?: BufferEncoding }) => Promise<string>
-  >
-  readdir: Mock<(path: PathLike) => Promise<string[]>>
-  writeFile: Mock<(path: PathLike, data: string) => Promise<void>>
-  mkdir: Mock<
-    (
-      path: PathLike,
-      options?: { recursive?: boolean },
-    ) => Promise<string | undefined>
-  >
-  stat: Mock<(path: PathLike) => Promise<Stats>>
-}
-
-/** Creates a mock filesystem compatible with AnvilFileSystem. */
-export function createMockFs(options: CreateMockFsOptions = {}): MockFs {
-  const {
-    files = {},
-    directories = {},
-    readFileImpl,
-    readdirImpl,
-    writeFileImpl,
-    mkdirImpl,
-    statImpl,
-  } = options
-
-  const writtenFiles: Record<string, string> = { ...files }
-  const createdDirs: Set<string> = new Set(Object.keys(directories))
-
-  const defaultReadFile = async (path: PathLike): Promise<string> => {
-    const pathStr = String(path)
-    if (pathStr in writtenFiles) {
-      return writtenFiles[pathStr]
-    }
-    throw new Error(`File not found: ${pathStr}`)
-  }
-
-  const defaultReaddir = async (path: PathLike): Promise<string[]> => {
-    const pathStr = String(path)
-    if (pathStr in directories) {
-      return directories[pathStr]
-    }
-    throw new Error(`Directory not found: ${pathStr}`)
-  }
-
-  const defaultWriteFile = async (
-    path: PathLike,
-    data: string,
-  ): Promise<void> => {
-    const pathStr = String(path)
-    writtenFiles[pathStr] = data
-  }
-
-  const defaultMkdir = async (path: PathLike): Promise<string | undefined> => {
-    const pathStr = String(path)
-    createdDirs.add(pathStr)
-    return undefined
-  }
-
-  const defaultStat = async (path: PathLike): Promise<Stats> => {
-    const pathStr = String(path)
-    const isFile = pathStr in writtenFiles
-    const isDir = pathStr in directories || createdDirs.has(pathStr)
-
-    if (!isFile && !isDir) {
-      throw new Error(`Path not found: ${pathStr}`)
-    }
-
-    return {
-      isFile: () => isFile,
-      isDirectory: () => isDir,
-      isBlockDevice: () => false,
-      isCharacterDevice: () => false,
-      isSymbolicLink: () => false,
-      isFIFO: () => false,
-      isSocket: () => false,
-      dev: 0,
-      ino: 0,
-      mode: isDir ? 0o755 : 0o644,
-      nlink: 1,
-      uid: 0,
-      gid: 0,
-      rdev: 0,
-      size: isFile ? writtenFiles[pathStr].length : 0,
-      blksize: 4096,
-      blocks: 0,
-      atimeMs: Date.now(),
-      mtimeMs: Date.now(),
-      ctimeMs: Date.now(),
-      birthtimeMs: Date.now(),
-      atime: new Date(),
-      mtime: new Date(),
-      ctime: new Date(),
-      birthtime: new Date(),
-    } as Stats
-  }
-
-  const readFileFn = readFileImpl
-    ? async (path: PathLike) => readFileImpl(String(path))
-    : defaultReadFile
-
-  const readdirFn = readdirImpl
-    ? async (path: PathLike) => readdirImpl(String(path))
-    : defaultReaddir
-
-  const writeFileFn = writeFileImpl
-    ? async (path: PathLike, data: string) => writeFileImpl(String(path), data)
-    : defaultWriteFile
-
-  const mkdirFn = mkdirImpl
-    ? async (path: PathLike, opts?: { recursive?: boolean }) =>
-        mkdirImpl(String(path), opts)
-    : defaultMkdir
-
-  const statFn = statImpl
-    ? async (path: PathLike) => statImpl(String(path))
-    : defaultStat
-
-  return {
-    readFile: mock(readFileFn),
-    readdir: mock(readdirFn),
-    writeFile: mock(writeFileFn),
-    mkdir: mock(mkdirFn),
-    stat: mock(statFn),
-  } as unknown as MockFs
-}
-
-export function restoreMockFs(mockFs: MockFs): void {
-  const mocks = mockFs as unknown as MockFsWithMocks
-  mocks.readFile.mockRestore()
-  mocks.readdir.mockRestore()
-  mocks.writeFile.mockRestore()
-  mocks.mkdir.mockRestore()
-  mocks.stat.mockRestore()
-}
-
-export function clearMockFs(mockFs: MockFs): void {
-  const mocks = mockFs as unknown as MockFsWithMocks
-  mocks.readFile.mockClear()
-  mocks.readdir.mockClear()
-  mocks.writeFile.mockClear()
-  mocks.mkdir.mockClear()
-  mocks.stat.mockClear()
-}