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

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

@@ -0,0 +1,68 @@
+import { ContentRepository, type BulkFieldUpdate, type BatchWrite, type DraftSummary, type Seed, type SelectOptions, type RepositoryOptions, type BeechHooks } from '@beechcms/core';
+import { BaseD1Repository } from './base.repository.d1';
+export declare class D1ContentRepository extends BaseD1Repository implements ContentRepository {
+    private readonly hooks?;
+    constructor(database: D1Database, hooks?: BeechHooks | undefined);
+    private hookCtx;
+    /**
+     * Deserializes a DB row using the Seed's branch definitions.
+     * Skips multi-relation branches — their values come from junction tables.
+     */
+    private rowToData;
+    /**
+     * Fetches multi-relation arrays for a single entry and attaches them to `data`.
+     */
+    private attachMultiRelations;
+    /**
+     * Fetches multi-relation arrays for a list of entries and attaches them.
+     * One query per multi-relation branch (O(R) queries, R = branch count).
+     */
+    private attachMultiRelationsMany;
+    findMany(seed: Seed, options: SelectOptions): Promise<{
+        items: Record<string, any>[];
+        total: number;
+    }>;
+    findById(seed: Seed, id: string): Promise<Record<string, any>>;
+    findBySlug(seed: Seed, slug: string): Promise<Record<string, any>>;
+    getFacets(seed: Seed): Promise<{
+        statuses: Record<string, number>;
+        tagsByColumn: Record<string, string[]>;
+    }>;
+    existsSlug(seed: Seed, slug: string, excludeId?: string): Promise<boolean>;
+    private buildCreateMainStmt;
+    private buildUpdateMainStmt;
+    private buildJunctionInserts;
+    private buildDraftJunctionInserts;
+    private validatePublishDraftRelations;
+    private getBulkArrayUpdateStmts;
+    private processBulkUpdateSingle;
+    private processBulkUpdateChunk;
+    create(seed: Seed, id: string, slug: string, status: string, data: Record<string, any>, options?: RepositoryOptions): Promise<void>;
+    update(seed: Seed, id: string, data: Record<string, any>, status?: string, options?: RepositoryOptions): Promise<void>;
+    delete(seed: Seed, id: string, options?: RepositoryOptions): Promise<{
+        row: Record<string, any>;
+    }>;
+    mutateField(seed: Seed, id: string, fieldName: string, operation: {
+        type: 'increment' | 'decrement';
+        value: number;
+    }, options?: {
+        min?: number;
+        max?: number;
+    }): Promise<{
+        newValue: number;
+    }>;
+    runBatch(operations: BatchWrite[]): Promise<void>;
+    saveDraft(seed: Seed, entryId: string, data: Record<string, any>): Promise<void>;
+    getDraft(seed: Seed, entryId: string): Promise<Record<string, any> | null>;
+    hasDraft(seed: Seed, entryId: string): Promise<boolean>;
+    publishDraft(seed: Seed, entryId: string): Promise<void>;
+    bulkUpdate(seedSlug: string, ids: string[], fields: Record<string, BulkFieldUpdate>): Promise<{
+        updated: number;
+        failed: Array<{
+            id: string;
+            reason: string;
+        }>;
+    }>;
+    deleteDraft(seed: Seed, entryId: string): Promise<void>;
+    findPendingDrafts(seeds: Seed[]): Promise<DraftSummary[]>;
+}

package/dist/shared/d1-activity-log.repository.d.ts

@@ -0,0 +1,13 @@
+import type { IActivityLogRepository, ActivityLogRecord, ActivityLogListOptions, CountSinceOptions } from '@beechcms/core';
+/**
+ * D1-backed implementation of {@link IActivityLogRepository}.
+ *
+ * Builds parameterised queries with optional WHERE clauses without nesting
+ * conditionals — guard clauses keep the body flat and the SQL deterministic.
+ */
+export declare class D1ActivityLogRepository implements IActivityLogRepository {
+    private readonly database;
+    constructor(database: D1Database);
+    list(options: ActivityLogListOptions): Promise<ActivityLogRecord[]>;
+    countSince(options: CountSinceOptions): Promise<number>;
+}

package/dist/shared/d1-activity-logger.d.ts

@@ -0,0 +1,20 @@
+import type { IActivityLogger, ActivityLogEntry, IClock, IIdGenerator } from '@beechcms/core';
+type ScheduleBackgroundTask = (task: Promise<unknown>) => void;
+/**
+ * D1-backed implementation of {@link IActivityLogger}.
+ *
+ * When `scheduleBackgroundTask` is provided (production path, wired to
+ * `c.executionCtx.waitUntil`), the INSERT runs after the response is sent so
+ * audit logging never adds latency to the user-facing request. When absent
+ * (tests, scripts), the INSERT runs inline and any errors are logged.
+ */
+export declare class D1ActivityLogger implements IActivityLogger {
+    private readonly database;
+    private readonly clock;
+    private readonly idGenerator;
+    private readonly scheduleBackgroundTask?;
+    constructor(database: D1Database, clock: IClock, idGenerator: IIdGenerator, scheduleBackgroundTask?: ScheduleBackgroundTask | undefined);
+    log(entry: ActivityLogEntry): Promise<void> | void;
+    private runInsert;
+}
+export {};

package/dist/shared/d1-analytics.repository.d.ts

@@ -0,0 +1,20 @@
+import type { IAnalyticsRepository, AnalyticsMetric, IClock } from '@beechcms/core';
+/**
+ * D1-backed implementation of {@link IAnalyticsRepository}.
+ *
+ * The underlying schema is long-format:
+ * `analytics(day_ts, metric, seed, value)` with UNIQUE(day_ts, metric, seed).
+ * Each row stores the counter for one (day, metric, seed) tuple. The
+ * IAnalyticsRepository contract is metric-aware (the metric is selected via
+ * a switch on the validated enum), and never interpolates user values into
+ * SQL — the actual metric name is bound through a parameter.
+ */
+export declare class D1AnalyticsRepository implements IAnalyticsRepository {
+    private readonly database;
+    private readonly clock;
+    constructor(database: D1Database, clock: IClock);
+    recordRequest(seedSlug: string): Promise<void>;
+    sumByMetric(metric: AnalyticsMetric, seedSlug: string, sinceTimestamp: number): Promise<number>;
+    groupByMetric(seedSlug: string, sinceTimestamp: number): Promise<Record<string, number>>;
+    private resolveMetricName;
+}

package/dist/shared/d1-content-scan.repository.d.ts

@@ -0,0 +1,7 @@
+import type { D1Database } from '@cloudflare/workers-types';
+import type { IContentScanRepository, Seed } from '@beechcms/core';
+export declare class D1ContentScanRepository implements IContentScanRepository {
+    private readonly db;
+    constructor(db: D1Database);
+    getReferencedMediaKeys(seeds: Seed[]): Promise<Set<string>>;
+}

package/dist/shared/d1-notification.repository.d.ts

@@ -0,0 +1,17 @@
+import type { INotificationRepository, NotificationRecord, NotificationStats, IClock, IIdGenerator } from '@beechcms/core';
+/**
+ * D1-backed implementation of {@link INotificationRepository}.
+ */
+export declare class D1NotificationRepository implements INotificationRepository {
+    private readonly database;
+    private readonly clock;
+    private readonly idGenerator;
+    constructor(database: D1Database, clock: IClock, idGenerator: IIdGenerator);
+    list(limit: number): Promise<NotificationRecord[]>;
+    stats(): Promise<NotificationStats>;
+    create(record: Omit<NotificationRecord, 'id' | 'createdAt' | 'isRead'>): Promise<string>;
+    markRead(notificationId: string): Promise<void>;
+    markUnread(notificationId: string): Promise<void>;
+    markAllRead(): Promise<void>;
+    delete(notificationId: string): Promise<void>;
+}

package/dist/shared/d1-password-reset-token.repository.d.ts

@@ -0,0 +1,10 @@
+import type { IPasswordResetTokenRepository, NewPasswordResetToken, ValidatedResetToken, IIdGenerator } from '@beechcms/core';
+export declare class D1PasswordResetTokenRepository implements IPasswordResetTokenRepository {
+    private readonly db;
+    private readonly idGenerator;
+    constructor(db: D1Database, idGenerator: IIdGenerator);
+    invalidatePending(userId: string, nowTimestamp: number): Promise<void>;
+    create(record: NewPasswordResetToken): Promise<void>;
+    findValidByHashWithEmail(tokenHash: string, nowTimestamp: number): Promise<ValidatedResetToken | null>;
+    markUsed(tokenId: string, nowTimestamp: number): Promise<void>;
+}

package/dist/shared/d1-search.repository.d.ts

@@ -0,0 +1,14 @@
+import type { Seed, ISearchRepository, SearchQueryOptions, SearchResultRow, SearchCountResult } from '@beechcms/core';
+/**
+ * D1-backed implementation of {@link ISearchRepository}.
+ *
+ * Delegates SQL composition to the pure `buildFtsQuery` helper to keep this
+ * class focused on D1 wiring. Returns raw rows; the route handler is
+ * responsible for mapping them via `mapFtsRow`.
+ */
+export declare class D1SearchRepository implements ISearchRepository {
+    private readonly database;
+    constructor(database: D1Database);
+    search(options: SearchQueryOptions, seeds: Seed[]): Promise<SearchResultRow[]>;
+    count(options: Omit<SearchQueryOptions, 'limit' | 'cursor'>, seeds: Seed[]): Promise<SearchCountResult>;
+}

package/dist/shared/d1-session.repository.d.ts

@@ -0,0 +1,12 @@
+import type { ISessionRepository, NewRefreshToken, RefreshTokenRecord, ActiveSessionSummary, IClock } from '@beechcms/core';
+export declare class D1SessionRepository implements ISessionRepository {
+    private readonly db;
+    private readonly clock;
+    constructor(db: D1Database, clock: IClock);
+    saveRefreshToken(record: NewRefreshToken): Promise<void>;
+    findActiveByHash(tokenHash: string, nowTimestamp: number): Promise<RefreshTokenRecord | null>;
+    revokeByHash(tokenHash: string, nowTimestamp: number): Promise<boolean>;
+    revokeAllForUser(userId: string, nowTimestamp: number): Promise<void>;
+    listActiveForUser(userId: string, nowTimestamp: number, limit: number): Promise<ActiveSessionSummary[]>;
+    revokeById(sessionId: string, userId: string, nowTimestamp: number): Promise<boolean>;
+}

package/dist/shared/d1-setup-checklist.repository.d.ts

@@ -0,0 +1,12 @@
+export interface ISetupChecklistRepository {
+    getExistingTableNames(): Promise<Set<string>>;
+    countAdmins(): Promise<number>;
+    countEntriesInSeed(slug: string): Promise<number>;
+}
+export declare class D1SetupChecklistRepository implements ISetupChecklistRepository {
+    private readonly db;
+    constructor(db: D1Database);
+    getExistingTableNames(): Promise<Set<string>>;
+    countAdmins(): Promise<number>;
+    countEntriesInSeed(slug: string): Promise<number>;
+}

package/dist/shared/d1-user.repository.d.ts

@@ -0,0 +1,18 @@
+import type { IUserRepository, UserRecord, NewUserInput } from '@beechcms/core';
+export declare class D1UserRepository implements IUserRepository {
+    private readonly db;
+    constructor(db: D1Database);
+    countAll(): Promise<number>;
+    findById(userId: string): Promise<UserRecord | null>;
+    findByEmail(email: string): Promise<UserRecord | null>;
+    create(user: NewUserInput): Promise<void>;
+    updateProfile(userId: string, fields: {
+        name?: string;
+        surname?: string;
+        email?: string;
+    }): Promise<void>;
+    updatePasswordHash(userId: string, newPasswordHash: string): Promise<void>;
+    updateAvatarUrl(userId: string, avatarUrl: string | null): Promise<void>;
+    updateNotificationPreferences(userId: string, preferencesJson: string): Promise<void>;
+    emailBelongsToAnotherUser(email: string, currentUserId: string): Promise<boolean>;
+}

package/dist/shared/d1-widget.repository.d.ts

@@ -0,0 +1,31 @@
+import { type Seed, type IWidgetRepository, type AggregateFormula, type WidgetWindow, type LeaderboardEntry, type LeaderboardOptions, type TimeseriesPoint, type WidgetListOptions, type WidgetListResult, type GrowthResult, type DistributionSlice } from '@beechcms/core';
+/**
+ * D1-backed implementation of {@link IWidgetRepository}.
+ *
+ * All user-supplied values are bound via parameterised statements. Column
+ * aliases originating from query strings are validated against the seed
+ * before being composed into the SQL string, preventing column-name
+ * injection. SQL keywords (aggregate function names, ORDER direction) are
+ * selected via hardcoded branches.
+ */
+export declare class D1WidgetRepository implements IWidgetRepository {
+    private readonly database;
+    constructor(database: D1Database);
+    aggregate(seed: Seed, formula: AggregateFormula, window: WidgetWindow): Promise<number>;
+    growth(seed: Seed, formula: AggregateFormula, window: WidgetWindow): Promise<GrowthResult>;
+    leaderboard(seed: Seed, options: LeaderboardOptions): Promise<LeaderboardEntry[]>;
+    list(seed: Seed, options: WidgetListOptions): Promise<WidgetListResult>;
+    timeseries(seed: Seed, formula: AggregateFormula, window: WidgetWindow, groupColumn: string): Promise<TimeseriesPoint[]>;
+    distribution(seed: Seed, column: string, window: WidgetWindow, limit: number): Promise<DistributionSlice[]>;
+    /**
+     * Throws UNSAFE_COLUMN if the alias is neither a system column nor a
+     * declared seed branch, preventing SQL injection via column names.
+     */
+    private resolveColumnExpression;
+    private buildAggregateExpression;
+    private buildCountWhereExpression;
+    private buildTimeWindowFilter;
+    private buildPreviousWindowFilter;
+    private appendFilterCondition;
+    private buildListOrderClause;
+}

package/dist/shared/dashboard-layout.repository.d1.d.ts

@@ -0,0 +1,9 @@
+import type { IDashboardLayoutRepository, DashboardLayoutRecord, DashboardLayout } from '@beechcms/core';
+export declare class D1DashboardLayoutRepository implements IDashboardLayoutRepository {
+    private readonly db;
+    constructor(db: D1Database);
+    get(scope: string): Promise<DashboardLayoutRecord | null>;
+    listScopes(): Promise<string[]>;
+    upsert(scope: string, layout: DashboardLayout, updatedBy: string): Promise<void>;
+    remove(scope: string): Promise<void>;
+}