@beechcms/api 0.6.0-preview.1 → 0.6.0-preview.3

package/src/public/query-builder.test.ts

@@ -1,224 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { describe, it, expect } from 'vitest'
-import {
-  parsePublicFilter,
-  toEngineFilters,
-  parsePublicPagination,
-  parseLatestCount,
-} from './query-builder'
-import type { Seed } from '@beechcms/core'
-
-const SEED = {
-  slug: 'posts',
-  displayNameAlias: 'title',
-  branches: [
-    { id: 'br_01', alias: 'title', type: 'text' },
-    { id: 'br_02', alias: 'count', type: 'number' },
-    { id: 'br_03', alias: 'active', type: 'boolean' },
-    { id: 'br_04', alias: 'published_at', type: 'date' },
-    { id: 'br_05', alias: 'tags', type: 'tags' },
-    { id: 'br_06', alias: 'body', type: 'richtext' },
-    { id: 'br_07', alias: 'attachment', type: 'file' },
-    { id: 'br_08', alias: 'meta', type: 'json' },
-  ],
-} as unknown as Seed
-
-// ─── parsePublicFilter ────────────────────────────────────────────────────────
-
-describe('parsePublicFilter', () => {
-  it('returns null for undefined input', () => {
-    expect(parsePublicFilter(undefined)).toBeNull()
-  })
-
-  it('returns null for empty string', () => {
-    expect(parsePublicFilter('')).toBeNull()
-  })
-
-  it('parses a valid filter with explicit AND logic', () => {
-    const raw = JSON.stringify({ logic: 'AND', where: [{ field: 'title', op: 'eq', value: 'Hello' }] })
-    const result = parsePublicFilter(raw)!
-    expect(result.logic).toBe('AND')
-    expect(result.where).toHaveLength(1)
-    expect(result.where[0]).toEqual({ field: 'title', op: 'eq', value: 'Hello' })
-  })
-
-  it('defaults logic to AND when omitted', () => {
-    const raw = JSON.stringify({ where: [{ field: 'title', op: 'contains', value: 'x' }] })
-    expect(parsePublicFilter(raw)!.logic).toBe('AND')
-  })
-
-  it('accepts case-insensitive logic value', () => {
-    const raw = JSON.stringify({ logic: 'or', where: [] })
-    expect(parsePublicFilter(raw)!.logic).toBe('OR')
-  })
-
-  it('throws for malformed JSON', () => {
-    expect(() => parsePublicFilter('{not-json')).toThrow('malformed JSON')
-  })
-
-  it('throws when parsed value is not an object', () => {
-    expect(() => parsePublicFilter('"a string"')).toThrow('object expected')
-  })
-
-  it('throws for an invalid logic value', () => {
-    const raw = JSON.stringify({ logic: 'BOTH', where: [] })
-    expect(() => parsePublicFilter(raw)).toThrow("'AND' or 'OR'")
-  })
-
-  it('throws for an unknown operator in a where condition', () => {
-    const raw = JSON.stringify({ where: [{ field: 'title', op: 'like', value: 'x' }] })
-    expect(() => parsePublicFilter(raw)).toThrow("unknown operator 'like'")
-  })
-
-  it('throws when where is not an array', () => {
-    const raw = JSON.stringify({ where: { field: 'title', op: 'eq' } })
-    expect(() => parsePublicFilter(raw)).toThrow("'where' must be an array")
-  })
-
-  it('filters out null conditions from where (missing field/op)', () => {
-    const raw = JSON.stringify({ where: [null, { field: 'title', op: 'eq', value: 'x' }] })
-    const result = parsePublicFilter(raw)!
-    expect(result.where).toHaveLength(1)
-  })
-
-  it('accepts all valid operators without throwing', () => {
-    const operators = ['eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'contains', 'not_contains',
-      'starts_with', 'ends_with', 'is_empty', 'is_not_empty', 'in', 'not_in',
-      'has_tag', 'has_any_tag', 'has_all_tags']
-    for (const op of operators) {
-      const raw = JSON.stringify({ where: [{ field: 'title', op, value: 'x' }] })
-      expect(() => parsePublicFilter(raw)).not.toThrow()
-    }
-  })
-})
-
-// ─── toEngineFilters ──────────────────────────────────────────────────────────
-
-describe('toEngineFilters', () => {
-  it('returns [] for null filter', () => {
-    expect(toEngineFilters(SEED, null)).toEqual([])
-  })
-
-  it('returns [] when where array is empty', () => {
-    expect(toEngineFilters(SEED, { where: [], logic: 'AND' })).toEqual([])
-  })
-
-  it('maps text branch to FilterType "text"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'title', op: 'eq', value: 'Hi' }], logic: 'AND' })
-    expect(result[0].type).toBe('text')
-  })
-
-  it('maps number branch to FilterType "number"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'count', op: 'gt', value: 5 }], logic: 'AND' })
-    expect(result[0].type).toBe('number')
-  })
-
-  it('maps boolean branch to FilterType "boolean"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'active', op: 'eq', value: true }], logic: 'AND' })
-    expect(result[0].type).toBe('boolean')
-  })
-
-  it('maps date branch to FilterType "date"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'published_at', op: 'gt', value: '2024-01-01' }], logic: 'AND' })
-    expect(result[0].type).toBe('date')
-  })
-
-  it('maps tags branch to FilterType "tags"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'tags', op: 'has_tag', value: 'news' }], logic: 'AND' })
-    expect(result[0].type).toBe('tags')
-  })
-
-  it('maps richtext branch to FilterType "text"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'body', op: 'contains', value: 'x' }], logic: 'AND' })
-    expect(result[0].type).toBe('text')
-  })
-
-  it('maps file branch to FilterType "text"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'attachment', op: 'contains', value: 'url' }], logic: 'AND' })
-    expect(result[0].type).toBe('text')
-  })
-
-  it('maps json branch to FilterType "json"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'meta', op: 'eq', value: '{}' }], logic: 'AND' })
-    expect(result[0].type).toBe('json')
-  })
-
-  it('maps system columns (id, slug, status) to FilterType "system"', () => {
-    for (const field of ['id', 'slug', 'status', 'created_at', 'updated_at']) {
-      const result = toEngineFilters(SEED, { where: [{ field, op: 'eq', value: 'x' }], logic: 'AND' })
-      expect(result[0].type).toBe('system')
-    }
-  })
-
-  it('maps unknown fields to FilterType "text"', () => {
-    const result = toEngineFilters(SEED, { where: [{ field: 'ghost_field', op: 'eq', value: 'x' }], logic: 'AND' })
-    expect(result[0].type).toBe('text')
-  })
-
-  it('produces one FilterGroup per condition', () => {
-    const filter = {
-      where: [
-        { field: 'title', op: 'eq' as const, value: 'A' },
-        { field: 'count', op: 'gt' as const, value: 5 },
-      ],
-      logic: 'AND' as const,
-    }
-    expect(toEngineFilters(SEED, filter)).toHaveLength(2)
-  })
-
-  it('includes column and conditions in each FilterGroup', () => {
-    const filter = { where: [{ field: 'title', op: 'contains' as const, value: 'hi' }], logic: 'AND' as const }
-    const [group] = toEngineFilters(SEED, filter)
-    expect(group.column).toBe('title')
-    expect(group.conditions[0].op).toBe('contains')
-    expect(group.conditions[0].value).toBe('hi')
-  })
-})
-
-// ─── parsePublicPagination ────────────────────────────────────────────────────
-
-describe('parsePublicPagination', () => {
-  it('defaults to page=1 and limit=25 when input is empty', () => {
-    expect(parsePublicPagination({})).toEqual({ page: 1, limit: 25 })
-  })
-
-  it('parses valid page and limit values', () => {
-    expect(parsePublicPagination({ page: '3', limit: '10' })).toEqual({ page: 3, limit: 10 })
-  })
-
-  it('clamps limit to a maximum of 100', () => {
-    expect(parsePublicPagination({ limit: '500' }).limit).toBe(100)
-  })
-
-  it('uses default for invalid (non-numeric) input', () => {
-    expect(parsePublicPagination({ page: 'abc', limit: 'xyz' })).toEqual({ page: 1, limit: 25 })
-  })
-})
-
-// ─── parseLatestCount ─────────────────────────────────────────────────────────
-
-describe('parseLatestCount', () => {
-  it('returns 10 for undefined', () => {
-    expect(parseLatestCount(undefined)).toBe(10)
-  })
-
-  it('parses a valid integer string', () => {
-    expect(parseLatestCount('5')).toBe(5)
-  })
-
-  it('clamps to 1 for values below minimum', () => {
-    expect(parseLatestCount('0')).toBe(1)
-    expect(parseLatestCount('-5')).toBe(1)
-  })
-
-  it('clamps to 100 for values above maximum', () => {
-    expect(parseLatestCount('200')).toBe(100)
-  })
-
-  it('returns 10 for non-numeric input', () => {
-    expect(parseLatestCount('abc')).toBe(10)
-  })
-})

package/src/public/query-builder.ts

@@ -1,156 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import type { Seed, FilterGroup, FilterOperator, FilterType, BranchType } from '@beechcms/core'
-import { parsePositiveInt } from '../shared/query-utils'
-
-export type PublicQueryInput = {
-  page?: string
-  limit?: string
-  latest?: string
-}
-
-export type PublicFilterLogic = 'AND' | 'OR'
-export type PublicFilterOperator =
-  | 'eq'
-  | 'neq'
-  | 'gt'
-  | 'gte'
-  | 'lt'
-  | 'lte'
-  | 'contains'
-  | 'not_contains'
-  | 'starts_with'
-  | 'ends_with'
-  | 'is_empty'
-  | 'is_not_empty'
-  | 'in'
-  | 'not_in'
-  | 'has_tag'
-  | 'has_any_tag'
-  | 'has_all_tags'
-
-export type PublicFilterCondition = {
-  field: string
-  op: PublicFilterOperator
-  value?: unknown
-}
-
-export type ParsedPublicFilter = {
-  where: PublicFilterCondition[]
-  logic: PublicFilterLogic
-}
-
-const PUBLIC_FILTER_OPERATORS = new Set<PublicFilterOperator>([
-  'eq', 'neq', 'gt', 'gte', 'lt', 'lte',
-  'contains', 'not_contains', 'starts_with', 'ends_with',
-  'is_empty', 'is_not_empty', 'in', 'not_in',
-  'has_tag', 'has_any_tag', 'has_all_tags',
-])
-
-function asString(value: unknown): string | null {
-  return typeof value === 'string' && value.trim() ? value.trim() : null
-}
-
-function validateLogic(logicRaw: unknown): PublicFilterLogic {
-  if (logicRaw === undefined) return 'AND'
-  if (typeof logicRaw !== 'string') throw new TypeError("Invalid filter: 'logic' must be 'AND' or 'OR'")
-  const normalized = logicRaw.toUpperCase()
-  if (normalized !== 'AND' && normalized !== 'OR') throw new TypeError("Invalid filter: 'logic' must be 'AND' or 'OR'")
-  return normalized
-}
-
-function parseWhereCondition(raw: unknown): PublicFilterCondition | null {
-  if (!raw || typeof raw !== 'object') return null
-  const maybe = raw as Record<string, unknown>
-  const field = asString(maybe.field)
-  const opRaw = asString(maybe.op)
-  if (!field || !opRaw || !PUBLIC_FILTER_OPERATORS.has(opRaw as PublicFilterOperator)) {
-    throw new TypeError(`Invalid filter: unknown operator '${opRaw ?? 'undefined'}'`)
-  }
-  return { field, op: opRaw as PublicFilterOperator, value: maybe.value }
-}
-
-export function parsePublicFilter(raw: string | undefined): ParsedPublicFilter | null {
-  if (!raw) return null
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(raw)
-  } catch {
-    throw new TypeError('Invalid filter: malformed JSON')
-  }
-  if (!parsed || typeof parsed !== 'object') throw new TypeError('Invalid filter: object expected')
-  const filterObj = parsed as Record<string, unknown>
-  const logic = validateLogic(filterObj.logic)
-  if (!Array.isArray(filterObj.where)) throw new TypeError("Invalid filter: 'where' must be an array")
-  const where = filterObj.where
-    .map(parseWhereCondition)
-    .filter((item): item is PublicFilterCondition => item !== null)
-  return { where, logic }
-}
-
-const SYSTEM_COLUMNS = new Set(['id', 'slug', 'status', 'created_at', 'updated_at'])
-
-function mapBranchToFilterType(type: BranchType): FilterType {
-  switch (type) {
-    case 'richtext':
-    case 'file':
-      return 'text'
-    case 'json':
-      return 'json'
-    case 'tags':
-      return 'tags'
-    case 'number':
-      return 'number'
-    case 'boolean':
-      return 'boolean'
-    case 'date':
-      return 'date'
-    case 'text':
-    default:
-      return 'text'
-  }
-}
-
-/**
- * Trasforma il filtro pubblico in FilterGroup[] per il Repository.
- * Zero SQL: la logica di generazione query risiede esclusivamente nel Repository/Engine core.
- */
-export function toEngineFilters(seed: Seed, parsedFilter: ParsedPublicFilter | null): FilterGroup[] {
-  if (!parsedFilter || parsedFilter.where.length === 0) return []
-  
-  // Note: Repository currently joins groups with AND. 
-  // Public API supports logic: OR but the core engine currently defaults to AND for top-level groups.
-  // We map each condition to a group for maximum compatibility with the engine's buildFilterCondition.
-  return parsedFilter.where.map((cond) => {
-    const branch = seed.branches.find(b => b.alias === cond.field)
-    const type: FilterType = branch 
-      ? mapBranchToFilterType(branch.type) 
-      : (SYSTEM_COLUMNS.has(cond.field) ? 'system' : 'text')
-    
-    return {
-      column: cond.field,
-      type,
-      conditions: [{
-        op: cond.op as FilterOperator,
-        value: cond.value as any
-      }]
-    }
-  })
-}
-
-export function parsePublicPagination(input: PublicQueryInput): { page: number; limit: number } {
-  const page = parsePositiveInt(input.page, 1)
-  const limit = Math.min(parsePositiveInt(input.limit, 25), 100)
-  return { page, limit }
-}
-
-export function parseLatestCount(latest: string | undefined): number {
-  if (!latest) return 10
-  const raw = Number.parseInt(latest, 10)
-  const parsed = Number.isNaN(raw) ? 10 : raw
-  if (parsed < 1) return 1
-  if (parsed > 100) return 100
-  return parsed
-}

package/src/public/rate-limit-middleware.ts

@@ -1,34 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import type { Context, Next } from 'hono'
-import type { AppEnv } from '../types'
-import { publicProblem } from './problem-details'
-import { getClientIp } from '../shared/request-utils'
-
-function isReadMethod(method: string): boolean {
-  return method === 'GET' || method === 'HEAD' || method === 'OPTIONS'
-}
-
-export function publicRateLimitMiddleware() {
-  return async (c: Context<AppEnv>, next: Next): Promise<Response | void> => {
-    const readMethod = isReadMethod(c.req.method)
-    const limiterName = readMethod ? ('publicApiRead' as const) : ('publicApiWrite' as const)
-
-    const seed = c.req.param('seed') ?? 'no-seed'
-    const key = `${getClientIp(c.req)}:${seed}:${limiterName}`
-    const result = await c.get('rateLimiters').getLimiter(limiterName).checkLimit(key)
-
-    if (!result.isAllowed) {
-      return publicProblem(c, {
-        type: 'rate-limit-exceeded',
-        title: 'Too Many Requests',
-        status: 429,
-        detail: 'Too many requests',
-      })
-    }
-
-    await next()
-  }
-}

package/src/public/read-list.ts

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import type { Seed, ContentRepository } from '@beechcms/core'
-import { cleanStr } from '../shared/query-utils'
-import { toFlatPublicEntry } from './entry-projection'
-import { buildPublicListMeta } from './response-builder'
-import { parsePublicFilter, parsePublicPagination, parseLatestCount, toEngineFilters } from './query-builder'
-
-type ReadListInput = {
-  seed: Seed
-  seedSlug: string
-  repository: ContentRepository
-  query: Record<string, string | undefined>
-  publishedOnly: boolean
-}
-
-export async function readListEntries(input: ReadListInput) {
-  const { seed, seedSlug, repository, query, publishedOnly } = input
-
-  const parsedFilter = parsePublicFilter(query.filter)
-  const allMode = cleanStr(query.all)?.toLowerCase() === 'true'
-  const latestMode = cleanStr(query.latest) !== null
-  const latestCount = latestMode ? parseLatestCount(query.latest ?? '') : null
-  const pagination = allMode ? { page: 1, limit: 100 } : parsePublicPagination(query)
-  const offset = (pagination.page - 1) * pagination.limit
-  const search = cleanStr(query.search) ?? ''
-  const engineFilters = toEngineFilters(seed, parsedFilter)
-  const sortBy = cleanStr(query.orderBy) ?? 'created_at'
-  const sortDir = (cleanStr(query.orderDir) ?? 'desc').toLowerCase() === 'asc' ? 'ASC' : 'DESC'
-
-  const { items, total } = await repository.findMany(seed, {
-    filters: engineFilters,
-    search: search || undefined,
-    status: publishedOnly ? 'published' : null,
-    pagination: {
-      limit: latestMode ? (latestCount ?? 10) : pagination.limit,
-      offset: latestMode ? 0 : offset,
-    },
-    orderBy: latestMode ? { column: 'created_at', dir: 'DESC' } : { column: sortBy, dir: sortDir },
-  })
-
-  const data = items.map(item => toFlatPublicEntry(item, seed, query.fields))
-
-  if (latestMode) {
-    return { data, meta: { total, returned: data.length, seed: seedSlug } }
-  }
-
-  return {
-    data,
-    meta: buildPublicListMeta({ total, page: pagination.page, limit: pagination.limit, returned: data.length, seed: seedSlug }),
-  }
-}

package/src/public/read-single.ts

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { EntryNotFoundError } from '@beechcms/core'
-import type { Seed, ContentRepository } from '@beechcms/core'
-import { toFlatPublicEntry } from './entry-projection'
-import { buildPublicSingleMeta } from './response-builder'
-
-type ReadSingleInput = {
-  seed: Seed
-  seedSlug: string
-  repository: ContentRepository
-  id: string | null
-  slug: string | null
-  publishedOnly: boolean
-  fieldsParam?: string
-}
-
-export type ReadSingleResult =
-  | { ok: true; data: Record<string, unknown>; meta: { seed: string } }
-  | { ok: false; detail: string }
-
-export async function readSingleEntry(input: ReadSingleInput): Promise<ReadSingleResult> {
-  const { seed, seedSlug, repository, id, slug, publishedOnly, fieldsParam } = input
-  const label = id ?? slug!
-
-  try {
-    const entry = id
-      ? await repository.findById(seed, id)
-      : await repository.findBySlug(seed, slug!)
-
-    if (publishedOnly && entry.status !== 'published') {
-      return { ok: false, detail: `Entry '${label}' not found or not published.` }
-    }
-
-    return {
-      ok: true,
-      data: toFlatPublicEntry(entry, seed, fieldsParam),
-      meta: buildPublicSingleMeta(seedSlug),
-    }
-  } catch (error) {
-    if (error instanceof EntryNotFoundError) {
-      return { ok: false, detail: `Entry '${label}' not found for content type '${seedSlug}'.` }
-    }
-    throw error
-  }
-}

package/src/public/response-builder.ts

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-/**
- * Helper meta per risposta lista Public API.
- */
-export function buildPublicListMeta(input: {
-  total: number
-  page: number
-  limit: number
-  returned: number
-  seed: string
-}) {
-  return {
-    total: input.total,
-    page: input.page,
-    limit: input.limit,
-    returned: input.returned,
-    seed: input.seed,
-  }
-}
-
-/**
- * Helper meta per risposta singolo elemento Public API.
- */
-export function buildPublicSingleMeta(seed: string) {
-  return { seed }
-}
-

package/src/public/sanitize.ts

@@ -1,69 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { validateAndSanitizeSeedPayload } from '@beechcms/core'
-import type { Seed, ValidationDetail } from '@beechcms/core'
-
-type PublicSanitizeSuccess = {
-  ok: true
-  data: Record<string, unknown>
-}
-
-type PublicSanitizeFailure = {
-  ok: false
-  status: 400 | 422
-  code: 'validation_failed' | 'dangerous_content'
-  message: string
-  details?: ValidationDetail[]
-}
-
-export type PublicSanitizeResult = PublicSanitizeSuccess | PublicSanitizeFailure
-
-/**
- * Public API Adapter: uses the core foundation and maps errors into the sprint format.
- */
-export function sanitizePublicPayload(
-  seed: Seed,
-  payload: Record<string, unknown>,
-  options: {
-    allowNull?: boolean
-    operation?: 'create' | 'update'
-    requireAtLeastOneValidField?: boolean
-    enforceRequiredFields?: boolean
-  } = {}
-): PublicSanitizeResult {
-  const operation = options.operation ?? 'create'
-  const result = validateAndSanitizeSeedPayload(seed, payload, {
-    allowNull: options.allowNull ?? false,
-    operation,
-    requireAtLeastOneValidField: options.requireAtLeastOneValidField ?? true,
-    enforceRequiredFields: options.enforceRequiredFields ?? true,
-  })
-
-  if (result.dangerousFields.length > 0) {
-    const field = result.dangerousFields[0]
-    return {
-      ok: false,
-      status: 422,
-      code: 'dangerous_content',
-      message: `Content rejected: dangerous markup detected in field '${field}'`,
-    }
-  }
-
-  if (result.details.length > 0) {
-    return {
-      ok: false,
-      status: 400,
-      code: 'validation_failed',
-      message: 'Validation failed',
-      details: result.details,
-    }
-  }
-
-  return {
-    ok: true,
-    data: result.data,
-  }
-}
-

package/src/public/slug-utils.ts

@@ -1,18 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { slugify, generateEntrySlug } from '@beechcms/core'
-
-/**
- * Converts a string into a URL-safe slug.
- * Logic moved to @beechcms/core for consistency between Dashboard and API.
- */
-export { slugify }
-
-/**
- * Generates a slug from a title/name or a UUID-like fallback.
- * Logic moved to @beechcms/core for consistency between Dashboard and API.
- */
-export { generateEntrySlug }
-

package/src/rate-limit/cloudflare-rate-limiter.test.ts

@@ -1,30 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-import { describe, it, expect, vi } from 'vitest'
-import { CloudflareRateLimiter } from './cloudflare-rate-limiter'
-
-describe('CloudflareRateLimiter', () => {
-  it('returns isAllowed: true when the Cloudflare binding grants the request', async () => {
-    const mockBinding = { limit: vi.fn().mockResolvedValue({ success: true }) }
-    const limiter = new CloudflareRateLimiter(mockBinding as any)
-    const result = await limiter.checkLimit('192.168.1.1:login')
-    expect(result.isAllowed).toBe(true)
-  })
-
-  it('returns isAllowed: false when the Cloudflare binding blocks the request', async () => {
-    const mockBinding = { limit: vi.fn().mockResolvedValue({ success: false }) }
-    const limiter = new CloudflareRateLimiter(mockBinding as any)
-    const result = await limiter.checkLimit('192.168.1.1:login')
-    expect(result.isAllowed).toBe(false)
-  })
-
-  it('forwards the exact key to the binding so per-key accounting is correct', async () => {
-    const mockBinding = { limit: vi.fn().mockResolvedValue({ success: true }) }
-    const limiter = new CloudflareRateLimiter(mockBinding as any)
-    const key = '10.0.0.1:some-seed:publicApiRead'
-    await limiter.checkLimit(key)
-    expect(mockBinding.limit).toHaveBeenCalledWith({ key })
-  })
-})

package/src/rate-limit/cloudflare-rate-limiter.ts

@@ -1,15 +0,0 @@
-// SPDX-License-Identifier: BUSL-1.1
-// Copyright (c) 2024–2026 Flavio De Musso. All rights reserved.
-// See LICENSE in the repository root for license terms.
-
-/// <reference types="@cloudflare/workers-types" />
-import type { IRateLimiter, RateLimitResult } from '@beechcms/core'
-
-export class CloudflareRateLimiter implements IRateLimiter {
-  constructor(private readonly binding: RateLimit) {}
-
-  async checkLimit(key: string): Promise<RateLimitResult> {
-    const { success } = await this.binding.limit({ key })
-    return { isAllowed: success }
-  }
-}