@etus/bhono-app 0.1.1

package/templates/base/src/server/__tests__/mocks/db.ts

@@ -0,0 +1,186 @@
+// src/server/__tests__/mocks/db.ts
+import { vi } from 'vitest'
+
+/**
+ * Mock D1 Prepared Statement
+ */
+export interface MockPreparedStatement {
+  bind: ReturnType<typeof vi.fn>
+  first: ReturnType<typeof vi.fn>
+  all: ReturnType<typeof vi.fn>
+  run: ReturnType<typeof vi.fn>
+  raw: ReturnType<typeof vi.fn>
+}
+
+/**
+ * Mock D1 Database interface
+ */
+export interface MockD1Database {
+  prepare: ReturnType<typeof vi.fn>
+  batch: ReturnType<typeof vi.fn>
+  exec: ReturnType<typeof vi.fn>
+  dump: ReturnType<typeof vi.fn>
+  _queryResults: Map<string, unknown>
+  _defaultResult: unknown
+}
+
+/**
+ * Creates a mock prepared statement
+ */
+function createMockPreparedStatement(db: MockD1Database): MockPreparedStatement {
+  const boundValues: unknown[] = []
+
+  const statement: MockPreparedStatement = {
+    bind: vi.fn((...values: unknown[]) => {
+      boundValues.push(...values)
+      return statement
+    }),
+    first: vi.fn(async (columnName?: string) => {
+      const key = getQueryKey(boundValues)
+      const result = db._queryResults.get(key) ?? db._defaultResult
+      if (Array.isArray(result) && result.length > 0) {
+        const row = result[0]
+        if (columnName && typeof row === 'object' && row !== null) {
+          return (row as Record<string, unknown>)[columnName] ?? null
+        }
+        return row
+      }
+      if (typeof result === 'object' && result !== null && !Array.isArray(result)) {
+        if (columnName) {
+          return (result as Record<string, unknown>)[columnName] ?? null
+        }
+        return result
+      }
+      return null
+    }),
+    all: vi.fn(async () => {
+      const key = getQueryKey(boundValues)
+      const result = db._queryResults.get(key) ?? db._defaultResult
+      const results = Array.isArray(result) ? result : result ? [result] : []
+      return {
+        results,
+        success: true,
+        meta: {
+          duration: 0,
+          changes: 0,
+          last_row_id: 0,
+          changed_db: false,
+          size_after: 0,
+          rows_read: results.length,
+          rows_written: 0,
+        },
+      }
+    }),
+    run: vi.fn(async () => {
+      return {
+        results: [],
+        success: true,
+        meta: {
+          duration: 0,
+          changes: 1,
+          last_row_id: 1,
+          changed_db: true,
+          size_after: 0,
+          rows_read: 0,
+          rows_written: 1,
+        },
+      }
+    }),
+    raw: vi.fn(async () => {
+      const key = getQueryKey(boundValues)
+      const result = db._queryResults.get(key) ?? db._defaultResult
+      const results = Array.isArray(result) ? result : result ? [result] : []
+      // raw returns array of arrays instead of objects
+      return results.map((row) => {
+        if (typeof row === 'object' && row !== null) {
+          return Object.values(row as Record<string, unknown>)
+        }
+        return [row]
+      })
+    }),
+  }
+
+  return statement
+}
+
+/**
+ * Generate a key for query results based on bound values
+ */
+function getQueryKey(values: unknown[]): string {
+  if (values.length === 0) return '__default__'
+  return JSON.stringify(values)
+}
+
+/**
+ * Creates a mock D1 database with in-memory storage for query results
+ */
+export function createMockD1(): MockD1Database {
+  const queryResults = new Map<string, unknown>()
+
+  const db: MockD1Database = {
+    _queryResults: queryResults,
+    _defaultResult: null,
+    prepare: vi.fn((query: string) => {
+      return createMockPreparedStatement(db)
+    }),
+    batch: vi.fn(async (statements: MockPreparedStatement[]) => {
+      const results = await Promise.all(
+        statements.map(async (stmt) => {
+          return stmt.all()
+        })
+      )
+      return results
+    }),
+    exec: vi.fn(async (query: string) => {
+      return {
+        count: 1,
+        duration: 0,
+      }
+    }),
+    dump: vi.fn(async () => {
+      return new ArrayBuffer(0)
+    }),
+  }
+
+  return db
+}
+
+/**
+ * Set a mock query result for specific bound values
+ * @param db The mock database
+ * @param boundValues The values that will be bound (used as key)
+ * @param results The results to return
+ */
+export function setMockQueryResult(
+  db: MockD1Database,
+  boundValues: unknown[],
+  results: unknown
+): void {
+  const key = getQueryKey(boundValues)
+  db._queryResults.set(key, results)
+}
+
+/**
+ * Set the default result for queries that don't match any specific pattern
+ * @param db The mock database
+ * @param results The default results
+ */
+export function setMockDefaultResult(db: MockD1Database, results: unknown): void {
+  db._defaultResult = results
+}
+
+/**
+ * Clear all mock query results
+ * @param db The mock database
+ */
+export function clearMockQueryResults(db: MockD1Database): void {
+  db._queryResults.clear()
+  db._defaultResult = null
+}
+
+/**
+ * Create a mock D1Database that conforms to the Cloudflare D1Database type
+ */
+export function createMockD1AsD1Database(): D1Database {
+  return createMockD1() as unknown as D1Database
+}

package/templates/base/src/server/__tests__/mocks/index.ts

@@ -0,0 +1,33 @@
+// src/server/__tests__/mocks/index.ts
+
+// D1 Database mock
+export {
+  createMockD1,
+  createMockD1AsD1Database,
+  setMockQueryResult,
+  setMockDefaultResult,
+  clearMockQueryResults,
+  type MockD1Database,
+  type MockPreparedStatement,
+} from './db'
+
+// KV Namespace mock
+export {
+  createMockKV,
+  createMockKVAsKVNamespace,
+  seedMockKV,
+  clearMockKV,
+  type MockKVNamespace,
+} from './kv'
+
+// R2 Bucket mock
+export {
+  createMockR2,
+  createMockR2AsR2Bucket,
+  seedMockR2,
+  clearMockR2,
+  type MockR2Bucket,
+  type MockR2Object,
+  type MockR2ObjectBody,
+  type MockR2Objects,
+} from './r2'

package/templates/base/src/server/__tests__/mocks/kv.ts

@@ -0,0 +1,286 @@
+// src/server/__tests__/mocks/kv.ts
+import { vi } from 'vitest'
+
+/**
+ * Stored KV value with metadata and expiration
+ */
+interface StoredValue {
+  value: string
+  metadata?: unknown
+  expirationTtl?: number
+  expiration?: number
+  storedAt: number
+}
+
+/**
+ * Mock KV Namespace interface
+ */
+export interface MockKVNamespace {
+  get: ReturnType<typeof vi.fn>
+  getWithMetadata: ReturnType<typeof vi.fn>
+  put: ReturnType<typeof vi.fn>
+  delete: ReturnType<typeof vi.fn>
+  list: ReturnType<typeof vi.fn>
+  _store: Map<string, StoredValue>
+}
+
+/**
+ * Check if a stored value has expired
+ */
+function isExpired(stored: StoredValue): boolean {
+  const now = Date.now()
+
+  // Check absolute expiration
+  if (stored.expiration && stored.expiration * 1000 < now) {
+    return true
+  }
+
+  // Check TTL-based expiration
+  if (stored.expirationTtl) {
+    const expiresAt = stored.storedAt + stored.expirationTtl * 1000
+    if (expiresAt < now) {
+      return true
+    }
+  }
+
+  return false
+}
+
+/**
+ * Creates a mock KV namespace with in-memory Map store
+ */
+export function createMockKV(): MockKVNamespace {
+  const store = new Map<string, StoredValue>()
+
+  const kv: MockKVNamespace = {
+    _store: store,
+
+    get: vi.fn(
+      async (
+        key: string,
+        options?: { type?: 'text' | 'json' | 'arrayBuffer' | 'stream'; cacheTtl?: number }
+      ) => {
+        const stored = store.get(key)
+        if (!stored) return null
+
+        // Check expiration
+        if (isExpired(stored)) {
+          store.delete(key)
+          return null
+        }
+
+        const type = options?.type ?? 'text'
+
+        switch (type) {
+          case 'json':
+            try {
+              return JSON.parse(stored.value)
+            } catch {
+              return null
+            }
+          case 'arrayBuffer':
+            return new TextEncoder().encode(stored.value).buffer
+          case 'stream':
+            return new ReadableStream({
+              start(controller) {
+                controller.enqueue(new TextEncoder().encode(stored.value))
+                controller.close()
+              },
+            })
+          case 'text':
+          default:
+            return stored.value
+        }
+      }
+    ),
+
+    getWithMetadata: vi.fn(
+      async (
+        key: string,
+        options?: { type?: 'text' | 'json' | 'arrayBuffer' | 'stream'; cacheTtl?: number }
+      ) => {
+        const stored = store.get(key)
+        if (!stored) return { value: null, metadata: null }
+
+        // Check expiration
+        if (isExpired(stored)) {
+          store.delete(key)
+          return { value: null, metadata: null }
+        }
+
+        const type = options?.type ?? 'text'
+        let value: unknown
+
+        switch (type) {
+          case 'json':
+            try {
+              value = JSON.parse(stored.value)
+            } catch {
+              value = null
+            }
+            break
+          case 'arrayBuffer':
+            value = new TextEncoder().encode(stored.value).buffer
+            break
+          case 'stream':
+            value = new ReadableStream({
+              start(controller) {
+                controller.enqueue(new TextEncoder().encode(stored.value))
+                controller.close()
+              },
+            })
+            break
+          case 'text':
+          default:
+            value = stored.value
+        }
+
+        return {
+          value,
+          metadata: stored.metadata ?? null,
+        }
+      }
+    ),
+
+    put: vi.fn(
+      async (
+        key: string,
+        value: string | ReadableStream | ArrayBuffer,
+        options?: {
+          expiration?: number
+          expirationTtl?: number
+          metadata?: unknown
+        }
+      ) => {
+        let stringValue: string
+
+        if (value instanceof ArrayBuffer) {
+          stringValue = new TextDecoder().decode(value)
+        } else if (value instanceof ReadableStream) {
+          const reader = value.getReader()
+          const chunks: Uint8Array[] = []
+          let done = false
+          while (!done) {
+            const result = await reader.read()
+            done = result.done
+            if (result.value) {
+              chunks.push(result.value)
+            }
+          }
+          const combined = new Uint8Array(chunks.reduce((acc, chunk) => acc + chunk.length, 0))
+          let offset = 0
+          for (const chunk of chunks) {
+            combined.set(chunk, offset)
+            offset += chunk.length
+          }
+          stringValue = new TextDecoder().decode(combined)
+        } else {
+          stringValue = value
+        }
+
+        store.set(key, {
+          value: stringValue,
+          metadata: options?.metadata,
+          expiration: options?.expiration,
+          expirationTtl: options?.expirationTtl,
+          storedAt: Date.now(),
+        })
+      }
+    ),
+
+    delete: vi.fn(async (key: string) => {
+      store.delete(key)
+    }),
+
+    list: vi.fn(
+      async (options?: { prefix?: string; limit?: number; cursor?: string }) => {
+        const prefix = options?.prefix ?? ''
+        const limit = options?.limit ?? 1000
+
+        const keys: { name: string; expiration?: number; metadata?: unknown }[] = []
+
+        for (const [key, stored] of store.entries()) {
+          // Check expiration
+          if (isExpired(stored)) {
+            store.delete(key)
+            continue
+          }
+
+          if (key.startsWith(prefix)) {
+            keys.push({
+              name: key,
+              expiration: stored.expiration,
+              metadata: stored.metadata,
+            })
+
+            if (keys.length >= limit) {
+              break
+            }
+          }
+        }
+
+        // Sort keys alphabetically
+        keys.sort((a, b) => a.name.localeCompare(b.name))
+
+        return {
+          keys,
+          list_complete: keys.length < limit,
+          cursor: undefined,
+        }
+      }
+    ),
+  }
+
+  return kv
+}
+
+/**
+ * Seeds mock KV with data
+ * @param kv The mock KV namespace
+ * @param data Object mapping keys to values (string or { value, metadata, ttl })
+ */
+export function seedMockKV(
+  kv: MockKVNamespace,
+  data: Record<
+    string,
+    | string
+    | {
+        value: string
+        metadata?: unknown
+        expirationTtl?: number
+        expiration?: number
+      }
+  >
+): void {
+  for (const [key, entry] of Object.entries(data)) {
+    if (typeof entry === 'string') {
+      kv._store.set(key, {
+        value: entry,
+        storedAt: Date.now(),
+      })
+    } else {
+      kv._store.set(key, {
+        value: entry.value,
+        metadata: entry.metadata,
+        expirationTtl: entry.expirationTtl,
+        expiration: entry.expiration,
+        storedAt: Date.now(),
+      })
+    }
+  }
+}
+
+/**
+ * Clears all data from the mock KV
+ * @param kv The mock KV namespace
+ */
+export function clearMockKV(kv: MockKVNamespace): void {
+  kv._store.clear()
+}
+
+/**
+ * Creates a mock KV that conforms to the Cloudflare KVNamespace type
+ */
+export function createMockKVAsKVNamespace(): KVNamespace {
+  return createMockKV() as unknown as KVNamespace
+}