@alumbwe/anvil 1.0.20 → 1.0.21

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

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

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

@@ -0,0 +1,166 @@
+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()
+}