@beechcms/api 0.6.0-preview.2 → 0.6.0-preview.4

package/dist/media-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Media utils: estrazione chiavi R2 dal data di un'entry.
+ * Usato alla cancellazione entry per eliminare i file associati da R2.
+ *
+ * @see docs/media-engine.md
+ */
+import type { Seed } from '@beechcms/core';
+/**
+ * Estrae la chiave R2 da un URL di media.
+ * Es: "https://x.com/api/media/1739123456-avatar.png" → "1739123456-avatar.png"
+ *
+ * @param mediaUrl - URL completo o path (es. /api/media/123-foto.png)
+ * @returns Chiave R2 o null se l'URL non è valido
+ */
+export declare function extractMediaKey(mediaUrl: string): string | null;
+/**
+ * Estrae tutte le chiavi R2 dal data di un'entry.
+ * Cerca nei campi `file` (stringa URL) e `json` (array/oggetto con URL).
+ * Il data è in formato DB: chiavi = branch.id (es. art_03, prd_05).
+ *
+ * @param seed - Schema del tipo di contenuto
+ * @param entryData - Payload in formato DB (chiavi = branch ID)
+ * @returns Array di chiavi R2 uniche da eliminare
+ */
+export declare function extractMediaKeysFromData(seed: Seed, entryData: Record<string, unknown>): string[];

package/dist/middleware/auth-providers.middleware.d.ts

@@ -0,0 +1,8 @@
+import type { IHashProvider, ITokenService, IClock } from '@beechcms/core';
+import type { AppEnv } from '../types';
+export interface AuthProviderOverrides {
+    hashProvider?: IHashProvider;
+    tokenService?: ITokenService;
+    clock?: IClock;
+}
+export declare const authProvidersMiddleware: (overrides?: AuthProviderOverrides) => import("hono").MiddlewareHandler<AppEnv, string, {}, Response>;

package/dist/middleware/observability.middleware.d.ts

@@ -0,0 +1,20 @@
+import type { IActivityLogger, INotificationService, IClock, IIdGenerator } from '@beechcms/core';
+import type { AppEnv } from '../types';
+export interface ObservabilityOverrides {
+    activityLogger?: IActivityLogger;
+    notificationService?: INotificationService;
+    clock?: IClock;
+    idGenerator?: IIdGenerator;
+}
+/**
+ * Observability middleware.
+ *
+ * Injects the activity logger and the notification service into the Hono
+ * context. Both depend on `executionCtx.waitUntil` to fire-and-forget their
+ * persistence work in production. The notification service additionally
+ * depends on the notification repository — `repositoryMiddleware` MUST run
+ * before this middleware in the factory pipeline.
+ *
+ * Tests can pass their own implementations via `overrides` to bypass D1.
+ */
+export declare const observabilityMiddleware: (overrides?: ObservabilityOverrides) => import("hono").MiddlewareHandler<AppEnv, string, {}, Response>;

package/dist/middleware/queue.middleware.d.ts

@@ -0,0 +1,11 @@
+import type { IQueueService, JobRegistry } from '@beechcms/core';
+import type { AppEnv } from '../types';
+export interface QueueOverrides {
+    queue?: IQueueService;
+}
+/**
+ * Injects `queue` into context. Must run AFTER repositoryMiddleware and
+ * storageMiddleware: the in-memory fallback builds a JobContext from
+ * `repository` + `bucket` already present in context.
+ */
+export declare const queueMiddleware: (jobs?: JobRegistry, overrides?: QueueOverrides) => import("hono").MiddlewareHandler<AppEnv, string, {}, Response>;

package/dist/middleware/rate-limit.middleware.d.ts

@@ -0,0 +1,9 @@
+import type { IRateLimiter } from '@beechcms/core';
+import type { AppEnv } from '../types';
+export type RateLimiterName = 'login' | 'tokenRefresh' | 'forgotPassword' | 'resetPassword' | 'publicApiRead' | 'publicApiWrite';
+export interface IRateLimiterRegistry {
+    getLimiter(name: RateLimiterName): IRateLimiter;
+}
+export declare const rateLimiterMiddleware: (overrides?: {
+    registry?: IRateLimiterRegistry;
+}) => import("hono").MiddlewareHandler<AppEnv, string, {}, Response>;

package/dist/middleware/repository.middleware.d.ts

@@ -0,0 +1,34 @@
+import type { ContentRepository, IdempotencyRepository, MediaRepository, SystemStatsRepository, IUserRepository, ISessionRepository, IPasswordResetTokenRepository, IActivityLogRepository, INotificationRepository, IWidgetRepository, ISearchRepository, IAnalyticsRepository, IContentScanRepository, IClock, IIdGenerator, IAutomationRunner, IAutomationRepository, IScheduler, ISiteSettingsRepository, IDemoDataRepository, ISeedLayoutRepository, ISeedRepository, ISchemaMutator, IDashboardLayoutRepository, BeechHooks } from '@beechcms/core';
+import type { Env, Variables } from '../types';
+interface RepositoryOverrides {
+    repository?: ContentRepository;
+    idempotencyRepository?: IdempotencyRepository;
+    mediaRepository?: MediaRepository;
+    systemStatsRepository?: SystemStatsRepository;
+    userRepository?: IUserRepository;
+    sessionRepository?: ISessionRepository;
+    passwordResetTokenRepository?: IPasswordResetTokenRepository;
+    activityLogRepository?: IActivityLogRepository;
+    notificationRepository?: INotificationRepository;
+    widgetRepository?: IWidgetRepository;
+    searchRepository?: ISearchRepository;
+    analyticsRepository?: IAnalyticsRepository;
+    contentScanRepository?: IContentScanRepository;
+    clock?: IClock;
+    idGenerator?: IIdGenerator;
+    automationRepository?: IAutomationRepository;
+    automationRunner?: IAutomationRunner;
+    scheduler?: IScheduler;
+    siteSettingsRepository?: ISiteSettingsRepository;
+    demoDataRepository?: IDemoDataRepository;
+    seedLayoutRepository?: ISeedLayoutRepository;
+    seedRepository?: ISeedRepository;
+    schemaMutator?: ISchemaMutator;
+    dashboardLayoutRepository?: IDashboardLayoutRepository;
+    hooks?: BeechHooks;
+}
+export declare const repositoryMiddleware: (overrides?: RepositoryOverrides) => import("hono").MiddlewareHandler<{
+    Bindings: Env;
+    Variables: Variables;
+}, string, {}, Response>;
+export {};

package/dist/middleware/seed-registry.middleware.d.ts

@@ -0,0 +1,10 @@
+import type { Env, Variables } from '../types';
+/**
+ * Hydrates the seed registry from D1 and injects seedRegistry, getSeed, and backrefMap
+ * into the context. Must run AFTER repositoryMiddleware (needs seedRepository) and
+ * BEFORE any handler that reads the registry.
+ */
+export declare const seedRegistryMiddleware: () => import("hono").MiddlewareHandler<{
+    Bindings: Env;
+    Variables: Variables;
+}, string, {}, Response>;

package/dist/middleware/storage.middleware.d.ts

@@ -0,0 +1,7 @@
+import { BeechBucket } from '@beechcms/core';
+import { AppEnv } from '../types';
+interface StorageOverrides {
+    bucket?: BeechBucket;
+}
+export declare const storageMiddleware: (overrides?: StorageOverrides) => import("hono").MiddlewareHandler<AppEnv, string, {}, Response>;
+export {};

package/dist/middleware.d.ts

@@ -0,0 +1,11 @@
+import type { Context, Next } from 'hono';
+import type { Env, Variables } from './types';
+/**
+ * JWT authentication middleware. Reads the Bearer token from the Authorization
+ * header and delegates verification to the ITokenService injected in context.
+ * Returns 401 on any missing or invalid token; never exposes failure details.
+ */
+export declare function authMiddleware(): (c: Context<{
+    Bindings: Env;
+    Variables: Variables;
+}>, next: Next) => Promise<Response | void>;

package/dist/public/access-policy.d.ts

@@ -0,0 +1,12 @@
+import type { Seed } from '@beechcms/core';
+export type PublicOperation = 'read' | 'add' | 'edit';
+export declare function checkPublicOperation(seed: Seed, operation: PublicOperation): {
+    readonly ok: true;
+    readonly error?: undefined;
+} | {
+    readonly ok: false;
+    readonly error: {
+        readonly error: "Forbidden";
+        readonly message: `Public ${string} is not allowed for content type '${string}'.`;
+    };
+};

package/dist/public/api-key-middleware.d.ts

@@ -0,0 +1,6 @@
+import type { Context, Next } from 'hono';
+/**
+ * API key auth middleware for Public API routes.
+ * Uses X-API-Key header only.
+ */
+export declare function apiKeyMiddleware(): (c: Context, next: Next) => Promise<Response | void>;

package/dist/public/cache-utils.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from 'hono';
+type EdgeCache = {
+    cache: Cache;
+    executionCtx: {
+        waitUntil: (p: Promise<unknown>) => void;
+    };
+} | null;
+export declare function resolveEdgeCache(c: Context): EdgeCache;
+export declare function withCachedResponse(edgeCache: EdgeCache, cacheKey: Request, response: Response): Response;
+export {};

package/dist/public/entry-projection.d.ts

@@ -0,0 +1,2 @@
+import type { Seed } from '@beechcms/core';
+export declare function toFlatPublicEntry(data: Record<string, unknown>, seed: Seed, fieldsParam?: string): Record<string, unknown>;

package/dist/public/idempotency.d.ts

@@ -0,0 +1,9 @@
+export declare function parseIdempotencyKey(rawValue: string | undefined): string | null;
+type FingerprintInput = {
+    seedSlug: string;
+    statusValue: unknown;
+    slug: string | null;
+    data: Record<string, unknown>;
+};
+export declare function buildRequestFingerprint(input: FingerprintInput): Promise<string>;
+export {};

package/dist/public/index.d.ts

@@ -0,0 +1,11 @@
+export { apiKeyMiddleware } from './api-key-middleware';
+export { publicRateLimitMiddleware } from './rate-limit-middleware';
+export { publicRoutes } from './public-routes';
+export { PUBLIC_ERRORS } from './public-errors';
+export { sanitizePublicPayload } from './sanitize';
+export { generateEntrySlug, slugify } from './slug-utils';
+export { buildPublicListMeta, buildPublicSingleMeta } from './response-builder';
+export { parseLatestCount, parsePublicPagination } from './query-builder';
+export { publicReadHandler } from './public-read';
+export { publicAddHandler } from './public-add';
+export { publicEditHandler } from './public-edit';

package/dist/public/problem-details.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from 'hono';
+/**
+ * Returns a Problem+JSON response when the error is a SQLite FK violation,
+ * or null when the error is unrelated (let the caller handle it).
+ *
+ * @param c       Hono context
+ * @param error   The caught error
+ * @param method  HTTP method of the current request (e.g. 'DELETE', 'POST')
+ */
+export declare function fkProblemOrNull(c: Context, error: unknown, method: string): Response | null;
+export interface PublicProblemDetailItem {
+    field: string;
+    expected: string;
+    received: string;
+    message: string;
+}
+type PublicProblemInput = {
+    type: string;
+    title: string;
+    status: 400 | 401 | 403 | 404 | 405 | 409 | 422 | 429 | 500 | 501;
+    detail: string;
+    errors?: PublicProblemDetailItem[];
+};
+export declare function internalErrorDetail(env: {
+    ENV?: string;
+}, error: unknown): string;
+/**
+ * Restituisce errori API in formato Problem Details (RFC 9457).
+ */
+export declare function publicProblem(c: Context, input: PublicProblemInput): Response;
+export {};

package/dist/public/public-add.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'hono';
+import { AppEnv } from '../types';
+export declare function publicAddHandler(context: Context<AppEnv>): Promise<Response>;

package/dist/public/public-edit.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from 'hono';
+import { AppEnv } from '../types';
+type PublicCtx = Context<AppEnv>;
+export declare function publicEditHandler(context: PublicCtx): Promise<Response>;
+export {};

package/dist/public/public-errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Error constants for Public API responses.
+ */
+export declare const PUBLIC_ERRORS: {
+    readonly API_KEY_UNAUTHORIZED: {
+        readonly error: "Unauthorized";
+        readonly message: "Missing or invalid API key. Provide a valid key via X-API-Key header.";
+    };
+    readonly API_KEY_FORBIDDEN: {
+        readonly error: "Forbidden";
+        readonly message: "Public API access is not configured for this instance.";
+    };
+};

package/dist/public/public-read.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from 'hono';
+import { AppEnv } from '../types';
+export declare function publicReadHandler(context: Context<AppEnv>): Promise<Response>;

package/dist/public/public-routes.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+import type { AppEnv } from '../types';
+export declare const publicRoutes: Hono<AppEnv, import("hono/types").BlankSchema, "/">;

package/dist/public/query-builder.d.ts

@@ -0,0 +1,28 @@
+import type { Seed, FilterGroup } from '@beechcms/core';
+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;
+};
+export declare function parsePublicFilter(raw: string | undefined): ParsedPublicFilter | null;
+/**
+ * Trasforma il filtro pubblico in FilterGroup[] per il Repository.
+ * Zero SQL: la logica di generazione query risiede esclusivamente nel Repository/Engine core.
+ */
+export declare function toEngineFilters(seed: Seed, parsedFilter: ParsedPublicFilter | null): FilterGroup[];
+export declare function parsePublicPagination(input: PublicQueryInput): {
+    page: number;
+    limit: number;
+};
+export declare function parseLatestCount(latest: string | undefined): number;

package/dist/public/rate-limit-middleware.d.ts

@@ -0,0 +1,3 @@
+import type { Context, Next } from 'hono';
+import type { AppEnv } from '../types';
+export declare function publicRateLimitMiddleware(): (c: Context<AppEnv>, next: Next) => Promise<Response | void>;

package/dist/public/read-list.d.ts

@@ -0,0 +1,26 @@
+import type { Seed, ContentRepository } from '@beechcms/core';
+type ReadListInput = {
+    seed: Seed;
+    seedSlug: string;
+    repository: ContentRepository;
+    query: Record<string, string | undefined>;
+    publishedOnly: boolean;
+};
+export declare function readListEntries(input: ReadListInput): Promise<{
+    data: Record<string, unknown>[];
+    meta: {
+        total: number;
+        returned: number;
+        seed: string;
+    };
+} | {
+    data: Record<string, unknown>[];
+    meta: {
+        total: number;
+        page: number;
+        limit: number;
+        returned: number;
+        seed: string;
+    };
+}>;
+export {};

package/dist/public/read-single.d.ts

@@ -0,0 +1,22 @@
+import type { Seed, ContentRepository } from '@beechcms/core';
+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 declare function readSingleEntry(input: ReadSingleInput): Promise<ReadSingleResult>;
+export {};

package/dist/public/response-builder.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Helper meta per risposta lista Public API.
+ */
+export declare function buildPublicListMeta(input: {
+    total: number;
+    page: number;
+    limit: number;
+    returned: number;
+    seed: string;
+}): {
+    total: number;
+    page: number;
+    limit: number;
+    returned: number;
+    seed: string;
+};
+/**
+ * Helper meta per risposta singolo elemento Public API.
+ */
+export declare function buildPublicSingleMeta(seed: string): {
+    seed: string;
+};

package/dist/public/sanitize.d.ts

@@ -0,0 +1,23 @@
+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 declare function sanitizePublicPayload(seed: Seed, payload: Record<string, unknown>, options?: {
+    allowNull?: boolean;
+    operation?: 'create' | 'update';
+    requireAtLeastOneValidField?: boolean;
+    enforceRequiredFields?: boolean;
+}): PublicSanitizeResult;
+export {};

package/{src/public/slug-utils.ts → dist/public/slug-utils.d.ts}

@@ -1,18 +1,11 @@
-// 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'
-
+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 }
-
+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 }
-
+export { generateEntrySlug };

package/dist/rate-limit/cloudflare-rate-limiter.d.ts

@@ -0,0 +1,6 @@
+import type { IRateLimiter, RateLimitResult } from '@beechcms/core';
+export declare class CloudflareRateLimiter implements IRateLimiter {
+    private readonly binding;
+    constructor(binding: RateLimit);
+    checkLimit(key: string): Promise<RateLimitResult>;
+}

package/dist/rate-limit/in-memory-rate-limiter.d.ts

@@ -0,0 +1,7 @@
+import type { IRateLimiter, RateLimitResult } from '@beechcms/core';
+export declare class InMemoryRateLimiter implements IRateLimiter {
+    private readonly maxAllowedHits;
+    private readonly hitCounts;
+    constructor(maxAllowedHits: number);
+    checkLimit(key: string): Promise<RateLimitResult>;
+}

package/dist/rate-limit/no-op-rate-limiter.d.ts

@@ -0,0 +1,4 @@
+import type { IRateLimiter, RateLimitResult } from '@beechcms/core';
+export declare class NoOpRateLimiter implements IRateLimiter {
+    checkLimit(_key: string): Promise<RateLimitResult>;
+}

package/dist/search-utils.d.ts

@@ -0,0 +1,54 @@
+import type { Seed, SearchResultRow } from "@beechcms/core";
+export interface FtsRow {
+    entry_id: string;
+    schema_slug: string;
+    slug: string | null;
+    status: string;
+    title: string | null;
+    excerpt: string;
+    rank: number;
+}
+export interface SearchResultItem {
+    id: string;
+    schema_slug: string;
+    slug: string | null;
+    status: string;
+    title: string;
+    excerpt: string;
+    data: Record<string, unknown>;
+}
+export interface SearchResponse {
+    items: SearchResultItem[];
+    nextCursor: string | null;
+    total: number;
+}
+export interface SearchQueryParams {
+    q: string;
+    schemaSlug: string | null;
+    status: string | null;
+    limit: number;
+    cursor: string | null;
+}
+export declare function encodeCursor(rank: number, entryId: string): string;
+export declare function decodeCursor(cursor: string): {
+    rank: number;
+    entryId: string;
+} | null;
+/**
+ * Builds a UNION ALL query across all per-seed fts_{slug} tables (v0.4.0).
+ * Each SELECT joins fts_{slug} with content_{slug} to fetch title, slug, status.
+ * Seeds param: full registry — filtered internally by schemaSlug and FTS availability.
+ */
+export declare function buildFtsQuery(params: SearchQueryParams, seeds: Seed[]): {
+    sql: string;
+    binds: unknown[];
+    countSql: string;
+    countBinds: unknown[];
+};
+export declare function mapFtsRow(row: FtsRow): SearchResultItem;
+/**
+ * Maps a repository-shaped SearchResultRow (camelCase) to the wire-format
+ * SearchResultItem returned by the /api/search route. Keeps the HTML
+ * stripping behaviour previously inlined inside mapFtsRow.
+ */
+export declare function mapSearchResultRow(row: SearchResultRow): SearchResultItem;

package/dist/search.d.ts

@@ -0,0 +1,6 @@
+import { Hono } from "hono";
+import type { Env, Variables } from "./types";
+export declare const searchRouter: Hono<{
+    Bindings: Env;
+    Variables: Variables;
+}, import("hono/types").BlankSchema, "/">;

package/dist/shared/apply-policies.d.ts

@@ -0,0 +1,10 @@
+import type { Seed } from '@beechcms/core';
+declare class PrivacyPolicyError extends Error {
+    readonly status: 501;
+    constructor(message: string);
+}
+export { PrivacyPolicyError };
+/** Applica la privacy policy ai campi del payload prima della scrittura su DB. */
+export declare function applyPrivacy(data: Record<string, unknown>, seed: Seed): Promise<Record<string, unknown>>;
+/** Applica la visibility policy ai campi del payload in uscita verso il client. */
+export declare function applyVisibility(data: Record<string, unknown>, seed: Seed): Record<string, unknown>;

package/dist/shared/automations.repository.d1.d.ts

@@ -0,0 +1,12 @@
+import type { IAutomationRepository, Automation, AutomationTriggerEvent, CreateAutomationInput, UpdateAutomationInput } from '@beechcms/core';
+export declare class D1AutomationRepository implements IAutomationRepository {
+    private readonly db;
+    constructor(db: D1Database);
+    findActive(seedSlug: string, event: AutomationTriggerEvent): Promise<Automation[]>;
+    list(seedSlug: string): Promise<Automation[]>;
+    findById(id: string): Promise<Automation | null>;
+    create(input: CreateAutomationInput): Promise<string>;
+    update(id: string, input: UpdateAutomationInput): Promise<void>;
+    toggle(id: string, enabled: boolean): Promise<void>;
+    delete(id: string): Promise<void>;
+}

package/dist/shared/background-notification-service.d.ts

@@ -0,0 +1,18 @@
+import type { INotificationService, CreateNotificationInput, INotificationRepository } from '@beechcms/core';
+type ScheduleBackgroundTask = (task: Promise<unknown>) => void;
+/**
+ * Production implementation of {@link INotificationService}.
+ *
+ * Delegates persistence to the injected {@link INotificationRepository}.
+ * When `scheduleBackgroundTask` is provided (wired to
+ * `c.executionCtx.waitUntil`), the repository write runs after the response
+ * is flushed so the public-API request that triggered it is never delayed.
+ */
+export declare class BackgroundNotificationService implements INotificationService {
+    private readonly notificationRepository;
+    private readonly scheduleBackgroundTask?;
+    constructor(notificationRepository: INotificationRepository, scheduleBackgroundTask?: ScheduleBackgroundTask | undefined);
+    notify(input: CreateNotificationInput): Promise<void> | void;
+    private runPersist;
+}
+export {};

package/dist/shared/base.repository.d1.d.ts

@@ -0,0 +1,18 @@
+import { RepositoryError } from '@beechcms/core';
+/**
+ * Base class for D1-backed repositories.
+ * Handles the D1 instance and provides common database utilities and error mapping.
+ */
+export declare abstract class BaseD1Repository {
+    protected readonly database: D1Database;
+    constructor(database: D1Database);
+    /**
+     * Utility method to extract a table name for a given seed.
+     */
+    protected getTableName(slug: string, isDraft?: boolean): string;
+    /**
+     * Helper to map generic D1 errors to Beech RepositoryErrors.
+     * This centralizes error handling for all D1 repositories.
+     */
+    protected mapError(error: any, context: string): RepositoryError;
+}

package/dist/shared/cloudflare-queue-service.d.ts

@@ -0,0 +1,11 @@
+import type { IQueueService, QueueMessage } from '@beechcms/core';
+/**
+ * Production producer. Sends a QueueMessage envelope onto the Cloudflare Queue
+ * binding. Cloudflare guarantees at-least-once delivery + retries on the
+ * consumer side, so enqueue only needs to hand off the message.
+ */
+export declare class CloudflareQueueService implements IQueueService {
+    private readonly queue;
+    constructor(queue: Queue<QueueMessage>);
+    enqueue<T>(name: string, payload: T): Promise<void>;
+}

package/dist/shared/content-utils.d.ts

@@ -0,0 +1,21 @@
+import type { Seed } from '@beechcms/core';
+import type { ContentEntry } from './query-utils';
+/** Deserializza ogni branch colonna di un DB row in formato API alias. */
+export declare function rowToApiData(seed: Seed, row: Record<string, unknown>): Record<string, unknown>;
+/** Converte un row della tabella content_{slug} in ContentEntry per le risposte API. */
+export declare function rowToEntry(seed: Seed, row: Record<string, unknown>, hasPendingDraft?: boolean): ContentEntry;
+export interface InsertBindings {
+    cols: string[];
+    placeholders: string[];
+    bindings: (string | number | null)[];
+}
+/** Costruisce colonne, placeholders e bindings per INSERT INTO content_{slug}. */
+export declare function buildInsertBindings(seed: Seed, payload: Record<string, unknown>): InsertBindings;
+export interface UpdateBindings {
+    setClause: string;
+    bindings: (string | number | null)[];
+}
+/** Costruisce SET clause e bindings per UPDATE content_{slug}. */
+export declare function buildUpdateBindings(seed: Seed, payload: Record<string, unknown>): UpdateBindings;
+/** Controlla se esiste un draft pendente in content_{slug}_drafts. */
+export declare function hasDraft(db: D1Database, seed: Seed, entryId: string): Promise<boolean>;