@beechcms/api 0.5.0 → 0.6.0-preview.2

package/src/shared/seed.repository.d1.ts

@@ -0,0 +1,98 @@
+// 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 { ISeedRepository, SeedRecord, Seed } from '@beechcms/core'
+
+export class D1SeedRepository implements ISeedRepository {
+  constructor(private readonly db: D1Database) {}
+
+  async listActive(): Promise<Seed[]> {
+    const rs = await this.db
+      .prepare(`SELECT definition FROM seeds WHERE status = 'active' ORDER BY created_at ASC`)
+      .all<{ definition: string }>()
+    const seeds: Seed[] = []
+    for (const r of rs.results ?? []) {
+      try { seeds.push(JSON.parse(r.definition) as Seed) } catch { /* skip corrupt */ }
+    }
+    return seeds
+  }
+
+  async listAll(): Promise<SeedRecord[]> {
+    const rs = await this.db
+      .prepare(`SELECT slug, definition, status, source, created_at, updated_at FROM seeds ORDER BY created_at ASC`)
+      .all<{ slug: string; definition: string; status: string; source: string; created_at: number; updated_at: number }>()
+    const out: SeedRecord[] = []
+    for (const r of rs.results ?? []) {
+      try {
+        out.push({
+          slug: r.slug,
+          definition: JSON.parse(r.definition) as Seed,
+          status: r.status as 'active' | 'deleted',
+          source: r.source as 'code' | 'runtime',
+          createdAt: r.created_at,
+          updatedAt: r.updated_at,
+        })
+      } catch { /* skip corrupt */ }
+    }
+    return out
+  }
+
+  async get(slug: string): Promise<SeedRecord | null> {
+    const r = await this.db
+      .prepare(`SELECT slug, definition, status, source, created_at, updated_at FROM seeds WHERE slug = ? LIMIT 1`)
+      .bind(slug)
+      .first<{ slug: string; definition: string; status: string; source: string; created_at: number; updated_at: number }>()
+    if (!r) return null
+    return {
+      slug: r.slug,
+      definition: JSON.parse(r.definition) as Seed,
+      status: r.status as 'active' | 'deleted',
+      source: r.source as 'code' | 'runtime',
+      createdAt: r.created_at,
+      updatedAt: r.updated_at,
+    }
+  }
+
+  async upsert(slug: string, definition: Seed, source: 'code' | 'runtime' = 'runtime'): Promise<void> {
+    const now = Math.floor(Date.now() / 1000)
+    await this.db
+      .prepare(`
+        INSERT INTO seeds (slug, definition, status, source, created_at, updated_at)
+        VALUES (?, ?, 'active', ?, ?, ?)
+        ON CONFLICT(slug) DO UPDATE SET
+          definition = excluded.definition,
+          status     = 'active',
+          updated_at = excluded.updated_at
+      `)
+      .bind(slug, JSON.stringify(definition), source, now, now)
+      .run()
+  }
+
+  async softDelete(slug: string): Promise<void> {
+    const now = Math.floor(Date.now() / 1000)
+    await this.db
+      .prepare(`UPDATE seeds SET status = 'deleted', updated_at = ? WHERE slug = ?`)
+      .bind(now, slug)
+      .run()
+  }
+
+  async hardDelete(slug: string): Promise<void> {
+    await this.db.prepare(`DELETE FROM seeds WHERE slug = ?`).bind(slug).run()
+  }
+
+  async getRegistryVersion(): Promise<number> {
+    const r = await this.db
+      .prepare(`SELECT value FROM seed_meta WHERE id = 'registry_version' LIMIT 1`)
+      .first<{ value: string }>()
+    return r ? parseInt(r.value, 10) || 1 : 1
+  }
+
+  async bumpRegistryVersion(): Promise<number> {
+    const r = await this.db
+      .prepare(`UPDATE seed_meta SET value = CAST(CAST(value AS INTEGER) + 1 AS TEXT) WHERE id = 'registry_version' RETURNING value`)
+      .first<{ value: string }>()
+    return r ? parseInt(r.value, 10) : 1
+  }
+}

package/src/shared/sequential-id-generator.ts

@@ -1,22 +1,33 @@
-import type { IIdGenerator } from '@beechcms/core'
-
-const ID_PADDING_WIDTH = 4
-
-/**
- * Test-only IIdGenerator implementation. Each call returns a stable,
- * monotonically increasing identifier (`test-id-0001`, `test-id-0002`, …)
- * so snapshot assertions and insert-order checks remain deterministic
- * across runs.
- */
-export class SequentialIdGenerator implements IIdGenerator {
-  private counter = 0
-
-  uuid(): string {
-    this.counter += 1
-    return `test-id-${String(this.counter).padStart(ID_PADDING_WIDTH, '0')}`
-  }
-
-  reset(): void {
-    this.counter = 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 { IIdGenerator } from '@beechcms/core'
+
+const ID_PADDING_WIDTH = 4
+
+// Matches the format emitted by uuid() → 'test-id-XXXX'
+const TEST_ID_REGEX = /^test-id-\d{4}$/
+
+/**
+ * Test-only IIdGenerator implementation. Each call returns a stable,
+ * monotonically increasing identifier (`test-id-0001`, `test-id-0002`, …)
+ * so snapshot assertions and insert-order checks remain deterministic
+ * across runs.
+ */
+export class SequentialIdGenerator implements IIdGenerator {
+  private counter = 0
+
+  uuid(): string {
+    this.counter += 1
+    return `test-id-${String(this.counter).padStart(ID_PADDING_WIDTH, '0')}`
+  }
+
+  isValid(value: unknown): value is string {
+    return typeof value === 'string' && TEST_ID_REGEX.test(value)
+  }
+
+  reset(): void {
+    this.counter = 0
+  }
+}

package/src/shared/site-settings.repository.d1.ts

@@ -0,0 +1,53 @@
+// 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 { ISiteSettingsRepository, SiteSettings } from '@beechcms/core'
+
+const DEFAULTS: SiteSettings = {
+  siteTitle: 'Beech CMS',
+  defaultLanguage: 'en',
+  timezone: 'Europe/Rome',
+  currency: 'EUR',
+  companyName: null,
+  companyWebsite: null,
+  companyAbbreviation: null,
+}
+
+export class D1SiteSettingsRepository implements ISiteSettingsRepository {
+  constructor(private readonly db: D1Database) {}
+
+  async getAll(): Promise<SiteSettings> {
+    const { results } = await this.db
+      .prepare('SELECT key, value FROM site_settings')
+      .all<{ key: string; value: string }>()
+
+    const map = new Map(results.map((r) => [r.key, r.value]))
+
+    return {
+      siteTitle: map.get('siteTitle') ?? DEFAULTS.siteTitle,
+      defaultLanguage: map.get('defaultLanguage') ?? DEFAULTS.defaultLanguage,
+      timezone: map.get('timezone') ?? DEFAULTS.timezone,
+      currency: map.get('currency') ?? DEFAULTS.currency,
+      companyName: map.get('companyName') ?? null,
+      companyWebsite: map.get('companyWebsite') ?? null,
+      companyAbbreviation: map.get('companyAbbreviation') ?? null,
+    }
+  }
+
+  async setMany(values: Partial<SiteSettings>): Promise<void> {
+    const entries = Object.entries(values).filter(([, v]) => v !== undefined) as [string, string | null][]
+    if (entries.length === 0) return
+
+    const stmts = entries.map(([key, value]) =>
+      this.db
+        .prepare(
+          'INSERT INTO site_settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value',
+        )
+        .bind(key, value),
+    )
+
+    await this.db.batch(stmts)
+  }
+}

package/src/shared/storage/factory.ts

@@ -1,40 +1,41 @@
-import { BeechBucket, PutBucketOptions, GetBucketResult } from '@beechcms/core'
-import { Env } from '../../types'
-import { R2BindingBucket } from './r2-binding-bucket'
-import { S3Bucket } from './s3-bucket'
-
-class NullBucket implements BeechBucket {
-  private fail(): never {
-    throw new Error('No storage provider configured. Set MEDIA_BUCKET or R2 credentials.')
-  }
-  put(_key: string, _body: ArrayBuffer | Uint8Array | ReadableStream, _options?: PutBucketOptions): Promise<void> { return this.fail() }
-  get(_key: string): Promise<GetBucketResult | null> { return this.fail() }
-  delete(_key: string): Promise<void> { return this.fail() }
-  head(_key: string): Promise<{ size: number; contentType?: string; metadata?: Record<string, string> } | null> { return this.fail() }
-  getUrl(_key: string): string { return this.fail() }
-  getTotalSize(): Promise<number> { return this.fail() }
-  list(_options?: { prefix?: string; limit?: number; cursor?: string }): Promise<{ objects: Array<{ key: string; size: number }>; cursor?: string }> { return this.fail() }
-}
-
-/**
- * Creates the appropriate BeechBucket based on available bindings/credentials.
- * Uses capability detection: R2 binding takes precedence over S3-compatible credentials.
- */
-export function createBucketProvider(env: Env, baseUrl: string): BeechBucket {
-  if (env.MEDIA_BUCKET) {
-    return new R2BindingBucket(env.MEDIA_BUCKET, baseUrl)
-  }
-
-  if (env.R2_ACCESS_KEY_ID && env.R2_SECRET_ACCESS_KEY && env.R2_ENDPOINT && env.R2_BUCKET_NAME) {
-    return new S3Bucket({
-      endpoint: env.R2_ENDPOINT,
-      accessKeyId: env.R2_ACCESS_KEY_ID,
-      secretAccessKey: env.R2_SECRET_ACCESS_KEY,
-      bucketName: env.R2_BUCKET_NAME,
-      baseUrl,
-      cdnUrl: env.MEDIA_CDN_URL?.trim().replace(/\/$/, '') || undefined,
-    })
-  }
-
-  return new NullBucket()
-}
+// 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 { BeechBucket, PutBucketOptions, GetBucketResult } from '@beechcms/core'
+import { Env } from '../../types'
+import { S3Bucket } from './s3-bucket'
+
+class NullBucket implements BeechBucket {
+  private fail(): never {
+    throw new Error('Storage not configured. Set R2_ENDPOINT, R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY, R2_BUCKET_NAME.')
+  }
+  put(): Promise<void> { return this.fail() }
+  get(): Promise<GetBucketResult | null> { return this.fail() }
+  delete(): Promise<void> { return this.fail() }
+  head(): Promise<{ size: number } | null> { return this.fail() }
+  getUrl(): string { return this.fail() }
+  getTotalSize(): Promise<number> { return this.fail() }
+  list(): Promise<{ objects: Array<{ key: string; size: number }>; cursor?: string }> { return this.fail() }
+  presignPut(): Promise<string> { return this.fail() }
+  presignGet(): Promise<string> { return this.fail() }
+}
+
+/**
+ * Single storage path: S3-compatible HTTP API.
+ * Prod → Cloudflare R2 with S3 API token.
+ * Dev  → MinIO container (or R2 staging bucket).
+ */
+export function createBucketProvider(env: Env, baseUrl: string): BeechBucket {
+  if (env.R2_ACCESS_KEY_ID && env.R2_SECRET_ACCESS_KEY && env.R2_ENDPOINT && env.R2_BUCKET_NAME) {
+    return new S3Bucket({
+      endpoint: env.R2_ENDPOINT,
+      accessKeyId: env.R2_ACCESS_KEY_ID,
+      secretAccessKey: env.R2_SECRET_ACCESS_KEY,
+      bucketName: env.R2_BUCKET_NAME,
+      baseUrl,
+      cdnUrl: env.MEDIA_CDN_URL?.trim().replace(/\/$/, '') || undefined,
+    })
+  }
+  return new NullBucket()
+}

package/src/shared/storage/s3-bucket.ts

@@ -1,163 +1,195 @@
-import { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, HeadObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3'
-import { BeechBucket, PutBucketOptions, GetBucketResult } from '@beechcms/core'
-
-/**
- * Implementation of BeechBucket using S3-compatible API (AWS SDK).
- * Used for production when connecting to R2 or any other S3 provider via HTTP.
- */
-export class S3Bucket implements BeechBucket {
-  private client: S3Client
-  private bucketName: string
-  private baseUrl: string
-
-  private cdnUrl: string | null
-
-  constructor(config: {
-    endpoint: string,
-    accessKeyId: string,
-    secretAccessKey: string,
-    bucketName: string,
-    baseUrl: string,
-    cdnUrl?: string,
-  }) {
-    this.client = new S3Client({
-      region: 'auto',
-      endpoint: config.endpoint,
-      credentials: {
-        accessKeyId: config.accessKeyId,
-        secretAccessKey: config.secretAccessKey,
-      },
-      forcePathStyle: true,
-    })
-    this.bucketName = config.bucketName
-    this.baseUrl = config.baseUrl
-    this.cdnUrl = config.cdnUrl ?? null
-  }
-
-  async put(key: string, body: ArrayBuffer | Uint8Array | ReadableStream, options?: PutBucketOptions): Promise<void> {
-    const command = new PutObjectCommand({
-      Bucket: this.bucketName,
-      Key: key,
-      Body: body instanceof ReadableStream ? await this.streamToUint8Array(body) : new Uint8Array(body as ArrayBuffer),
-      ContentType: options?.contentType,
-      Metadata: options?.metadata
-    })
-    await this.client.send(command)
-  }
-
-  private async streamToUint8Array(stream: ReadableStream): Promise<Uint8Array> {
-    const reader = stream.getReader()
-    const chunks: Uint8Array[] = []
-    let totalLength = 0
-    while (true) {
-      const { done, value } = await reader.read()
-      if (done) break
-      chunks.push(value)
-      totalLength += value.length
-    }
-    const result = new Uint8Array(totalLength)
-    let offset = 0
-    for (const chunk of chunks) {
-      result.set(chunk, offset)
-      offset += chunk.length
-    }
-    return result
-  }
-
-  async get(key: string): Promise<GetBucketResult | null> {
-    try {
-      const command = new GetObjectCommand({
-        Bucket: this.bucketName,
-        Key: key
-      })
-      const response = await this.client.send(command)
-      
-      if (!response.Body) return null
-
-      const rawBody = response.Body as any
-      const body: ReadableStream = typeof rawBody.transformToWebStream === 'function'
-        ? rawBody.transformToWebStream()
-        : rawBody as ReadableStream
-
-      return {
-        body,
-        contentType: response.ContentType,
-        size: response.ContentLength ?? 0,
-        metadata: response.Metadata
-      }
-    } catch (err: any) {
-      if (err.name === 'NoSuchKey' || err.name === 'NotFound' || err.message === 'NoSuchKey') {
-        return null
-      }
-      // Rethrow other errors (AccessDenied, Timeout, etc.)
-      throw err
-    }
-  }
-
-  async delete(key: string): Promise<void> {
-    const command = new DeleteObjectCommand({
-      Bucket: this.bucketName,
-      Key: key
-    })
-    await this.client.send(command)
-  }
-
-  async head(key: string): Promise<{ size: number; contentType?: string; metadata?: Record<string, string> } | null> {
-    try {
-      const command = new HeadObjectCommand({
-        Bucket: this.bucketName,
-        Key: key
-      })
-      const response = await this.client.send(command)
-      return {
-        size: response.ContentLength ?? 0,
-        contentType: response.ContentType,
-        metadata: response.Metadata
-      }
-    } catch (err: any) {
-      if (err.name === 'NoSuchKey' || err.name === 'NotFound') return null
-      throw err
-    }
-  }
-
-  getUrl(key: string): string {
-    if (this.cdnUrl) {
-      return `${this.cdnUrl}/${encodeURIComponent(key)}`
-    }
-    return `${this.baseUrl}/api/media/${encodeURIComponent(key)}`
-  }
-
-  async getTotalSize(): Promise<number> {
-    let total = 0
-    let token: string | undefined
-    do {
-      const command = new ListObjectsV2Command({
-        Bucket: this.bucketName,
-        ContinuationToken: token
-      })
-      const response = await this.client.send(command)
-      for (const obj of response.Contents ?? []) {
-        total += obj.Size ?? 0
-      }
-      token = response.NextContinuationToken
-    } while (token)
-    return total
-  }
-
-  async list(options?: { prefix?: string; limit?: number; cursor?: string }): Promise<{ objects: Array<{ key: string; size: number }>; cursor?: string }> {
-    const command = new ListObjectsV2Command({
-      Bucket: this.bucketName,
-      Prefix: options?.prefix,
-      MaxKeys: options?.limit,
-      ContinuationToken: options?.cursor
-    })
-    const response = await this.client.send(command)
-    return {
-      objects: (response.Contents ?? []).map(obj => ({
-        key: obj.Key ?? '',
-        size: obj.Size ?? 0
-      })),
-      cursor: response.NextContinuationToken
-    }
-  }
-}
+// 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 { S3Client, PutObjectCommand, GetObjectCommand, DeleteObjectCommand, HeadObjectCommand, ListObjectsV2Command } from '@aws-sdk/client-s3'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { BeechBucket, PutBucketOptions, GetBucketResult, PresignOptions } from '@beechcms/core'
+
+/**
+ * Implementation of BeechBucket using S3-compatible API (AWS SDK).
+ * Used for production when connecting to R2 or any other S3 provider via HTTP.
+ */
+export class S3Bucket implements BeechBucket {
+  private client: S3Client
+  private bucketName: string
+  private baseUrl: string
+
+  private cdnUrl: string | null
+
+  constructor(config: {
+    endpoint: string,
+    accessKeyId: string,
+    secretAccessKey: string,
+    bucketName: string,
+    baseUrl: string,
+    cdnUrl?: string,
+  }) {
+    // requestChecksumCalculation/responseChecksumValidation exist at runtime in AWS SDK v3
+    // but are not yet in the TypeScript types for this version. Casting via unknown to pass them
+    // through: without them the SDK adds x-amz-checksum-crc32 to presigned URLs, which causes
+    // R2 to reject PUT requests when the CRC32 of the uploaded file doesn't match.
+    this.client = new S3Client({
+      region: 'auto',
+      endpoint: config.endpoint,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+      },
+      forcePathStyle: true,
+      requestChecksumCalculation: 'when_required',
+      responseChecksumValidation: 'when_required',
+    } as unknown as import('@aws-sdk/client-s3').S3ClientConfig)
+    this.bucketName = config.bucketName
+    this.baseUrl = config.baseUrl
+    this.cdnUrl = config.cdnUrl ?? null
+  }
+
+  async put(key: string, body: ArrayBuffer | Uint8Array | ReadableStream, options?: PutBucketOptions): Promise<void> {
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body instanceof ReadableStream ? await this.streamToUint8Array(body) : new Uint8Array(body as ArrayBuffer),
+      ContentType: options?.contentType,
+      Metadata: options?.metadata
+    })
+    await this.client.send(command)
+  }
+
+  private async streamToUint8Array(stream: ReadableStream): Promise<Uint8Array> {
+    const reader = stream.getReader()
+    const chunks: Uint8Array[] = []
+    let totalLength = 0
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      chunks.push(value)
+      totalLength += value.length
+    }
+    const result = new Uint8Array(totalLength)
+    let offset = 0
+    for (const chunk of chunks) {
+      result.set(chunk, offset)
+      offset += chunk.length
+    }
+    return result
+  }
+
+  async get(key: string): Promise<GetBucketResult | null> {
+    try {
+      const command = new GetObjectCommand({
+        Bucket: this.bucketName,
+        Key: key
+      })
+      const response = await this.client.send(command)
+      
+      if (!response.Body) return null
+
+      const rawBody = response.Body as any
+      const body: ReadableStream = typeof rawBody.transformToWebStream === 'function'
+        ? rawBody.transformToWebStream()
+        : rawBody as ReadableStream
+
+      return {
+        body,
+        contentType: response.ContentType,
+        size: response.ContentLength ?? 0,
+        metadata: response.Metadata
+      }
+    } catch (err: any) {
+      if (err.name === 'NoSuchKey' || err.name === 'NotFound' || err.message === 'NoSuchKey') {
+        return null
+      }
+      // Rethrow other errors (AccessDenied, Timeout, etc.)
+      throw err
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    const command = new DeleteObjectCommand({
+      Bucket: this.bucketName,
+      Key: key
+    })
+    await this.client.send(command)
+  }
+
+  async head(key: string): Promise<{ size: number; contentType?: string; metadata?: Record<string, string> } | null> {
+    try {
+      const command = new HeadObjectCommand({
+        Bucket: this.bucketName,
+        Key: key
+      })
+      const response = await this.client.send(command)
+      return {
+        size: response.ContentLength ?? 0,
+        contentType: response.ContentType,
+        metadata: response.Metadata
+      }
+    } catch (err: any) {
+      if (err.name === 'NoSuchKey' || err.name === 'NotFound') return null
+      throw err
+    }
+  }
+
+  getUrl(key: string): string {
+    if (this.cdnUrl) {
+      return `${this.cdnUrl}/${encodeURIComponent(key)}`
+    }
+    return `${this.baseUrl}/api/media/${encodeURIComponent(key)}`
+  }
+
+  async getTotalSize(): Promise<number> {
+    let total = 0
+    let token: string | undefined
+    do {
+      const command = new ListObjectsV2Command({
+        Bucket: this.bucketName,
+        ContinuationToken: token
+      })
+      const response = await this.client.send(command)
+      for (const obj of response.Contents ?? []) {
+        total += obj.Size ?? 0
+      }
+      token = response.NextContinuationToken
+    } while (token)
+    return total
+  }
+
+  async presignPut(key: string, options: PresignOptions): Promise<string> {
+    // ContentLength intentionally excluded: including it adds content-length to
+    // X-Amz-SignedHeaders, requiring the uploading client to send an exact
+    // Content-Length header. Some fetch implementations omit it, causing MinIO/R2
+    // to reject the PUT with 400. Size validation already happened server-side.
+    const command = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      ContentType: options.contentType,
+    })
+    return getSignedUrl(this.client, command, { expiresIn: options.expiresIn })
+  }
+
+  async presignGet(key: string, options: PresignOptions): Promise<string> {
+    const command = new GetObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+    })
+    return getSignedUrl(this.client, command, { expiresIn: options.expiresIn })
+  }
+
+  async list(options?: { prefix?: string; limit?: number; cursor?: string }): Promise<{ objects: Array<{ key: string; size: number }>; cursor?: string }> {
+    const command = new ListObjectsV2Command({
+      Bucket: this.bucketName,
+      Prefix: options?.prefix,
+      MaxKeys: options?.limit,
+      ContinuationToken: options?.cursor
+    })
+    const response = await this.client.send(command)
+    return {
+      objects: (response.Contents ?? []).map(obj => ({
+        key: obj.Key ?? '',
+        size: obj.Size ?? 0
+      })),
+      cursor: response.NextContinuationToken
+    }
+  }
+}