@open-mercato/core 0.6.7-develop.6863.1.61001cf9a8 → 0.6.7

package/src/modules/attachments/api/route.ts

@@ -37,15 +37,12 @@ import {
   sanitizeUploadedFileName,
 } from '../lib/security'
 import {
-  isMultipartUploadLimitError,
   isMultipartRequestWithinUploadLimit,
-  parseMultipartFormDataWithinUploadLimit,
   resolveAttachmentMaxBytes,
   willExceedAttachmentTenantQuota,
 } from '../lib/upload-limits'
 import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
 import { createLogger } from '@open-mercato/shared/lib/logger'
-import type { AttachmentQuotaService } from '../lib/quota-service'
 
 const logger = createLogger('attachments')
 
@@ -286,22 +283,10 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: 'Expected multipart/form-data' }, { status: 400 })
   }
   if (!isMultipartRequestWithinUploadLimit(req.headers.get('content-length'))) {
-    return NextResponse.json({
-      error: t('attachments.errors.maxUploadSize', 'Attachment exceeds the maximum upload size.'),
-    }, { status: 413 })
+    return NextResponse.json({ error: 'Attachment exceeds the maximum upload size.' }, { status: 413 })
   }
 
-  let form: FormData
-  try {
-    form = await parseMultipartFormDataWithinUploadLimit(req)
-  } catch (error) {
-    if (isMultipartUploadLimitError(error)) {
-      return NextResponse.json({
-        error: t('attachments.errors.maxUploadSize', 'Attachment exceeds the maximum upload size.'),
-      }, { status: 413 })
-    }
-    throw error
-  }
+  const form = await req.formData()
   const formPayload = buildFormPayload(form)
   const customFieldValues = splitCustomFieldPayload(formPayload).custom
   const entityId = String(form.get('entityId') || '')
@@ -320,20 +305,6 @@ export async function POST(req: Request) {
   const container = await createRequestContainer()
   const em = container.resolve('em') as EntityManager
   const dataEngine = container.resolve('dataEngine')
-  let attachmentQuotaService: AttachmentQuotaService | null = null
-  let attachmentQuotaRecoveryScheduler: ((
-    payload: { reservationId: string; tenantId: string; organizationId: string },
-    delayMs: number,
-  ) => Promise<void>) | null = null
-  try {
-    attachmentQuotaService = container.resolve('attachmentQuotaService') as AttachmentQuotaService
-    attachmentQuotaRecoveryScheduler = container.resolve('attachmentQuotaRecoveryScheduler') as (
-      payload: { reservationId: string; tenantId: string; organizationId: string },
-      delayMs: number,
-    ) => Promise<void>
-  } catch {
-    // Legacy fallback below when the quota service is not registered in this container.
-  }
   const storageDriverFactory =
     (container.resolve('storageDriverFactory') as StorageDriverFactory | null) ?? new StorageDriverFactory(em)
   const orgId = await resolveAttachmentOrganizationId(container, auth, req)
@@ -378,20 +349,11 @@ export async function POST(req: Request) {
       error: t('attachments.errors.maxUploadSize', 'Attachment exceeds the maximum upload size.'),
     }, { status: 413 })
   }
-  if (!attachmentQuotaService) {
-    try {
-      const tenantUsageBytes = await readTenantAttachmentUsageBytes(em, tenantId)
-      if (willExceedAttachmentTenantQuota(tenantUsageBytes, file.size)) {
-        return NextResponse.json({
-          error: t('attachments.errors.quotaExceeded', 'Attachment storage quota exceeded for this tenant.'),
-        }, { status: 413 })
-      }
-    } catch (error) {
-      logger.error('Attachment quota accounting failed', { err: error })
-      return NextResponse.json({
-        error: t('attachments.errors.quotaUnavailable', 'Storage quota accounting is unavailable.'),
-      }, { status: 500 })
-    }
+  const tenantUsageBytes = await readTenantAttachmentUsageBytes(em, tenantId)
+  if (willExceedAttachmentTenantQuota(tenantUsageBytes, file.size)) {
+    return NextResponse.json({
+      error: t('attachments.errors.quotaExceeded', 'Attachment storage quota exceeded for this tenant.'),
+    }, { status: 413 })
   }
   const buf = Buffer.from(await file.arrayBuffer())
   const safeName = sanitizeUploadedFileName(file.name)
@@ -433,62 +395,6 @@ export async function POST(req: Request) {
     return NextResponse.json({ error: t('attachments.errors.publicPartitionBlocked', 'Public storage partitions cannot be selected explicitly for this upload.') }, { status: 403 })
   }
   const uploadDriver = await storageDriverFactory.resolveForPartition(partition.code, { tenantId, organizationId: orgId })
-  const preparedStoragePath = attachmentQuotaService
-    ? uploadDriver.prepareStoragePath?.({
-        partitionCode: partition.code,
-        orgId,
-        tenantId,
-        fileName: safeName,
-      })
-    : undefined
-  if (attachmentQuotaService && !preparedStoragePath) {
-    return NextResponse.json({
-      error: t('attachments.errors.quotaRecoveryUnsupported', 'Storage driver cannot participate in quota recovery.'),
-    }, { status: 500 })
-  }
-  let quotaReservation: { id: string; leaseToken: string; expiresAt: Date } | null = null
-  if (attachmentQuotaService) {
-    try {
-      quotaReservation = await attachmentQuotaService.reserve({
-        tenantId,
-        organizationId: orgId,
-        bytes: buf.length,
-        source: 'attachment',
-        storageDriver: uploadDriver.key,
-        storagePath: preparedStoragePath!,
-        partitionCode: partition.code,
-      })
-      if (!attachmentQuotaRecoveryScheduler) throw new Error('Attachment quota recovery is unavailable.')
-      await attachmentQuotaRecoveryScheduler({
-        reservationId: quotaReservation.id,
-        tenantId,
-        organizationId: orgId,
-      }, Math.max(1_000, quotaReservation.expiresAt.getTime() - Date.now()))
-      if (typeof attachmentQuotaService.beginStorage === 'function') {
-        await attachmentQuotaService.beginStorage(quotaReservation.id, quotaReservation.leaseToken)
-      }
-    } catch (error) {
-      if (quotaReservation) {
-        await attachmentQuotaService.release(quotaReservation.id, quotaReservation.leaseToken).catch(() => {})
-        quotaReservation = null
-      }
-      const code = (error as { code?: unknown })?.code
-      if (code === 'quota_exceeded') {
-        return NextResponse.json({
-          error: t('attachments.errors.quotaExceeded', 'Attachment storage quota exceeded for this tenant.'),
-        }, { status: 413 })
-      }
-      if (code === 'quota_target_exists') {
-        return NextResponse.json({
-          error: t('attachments.errors.storagePathExists', 'The target storage path already exists.'),
-        }, { status: 409 })
-      }
-      logger.error('Attachment quota reservation failed', { err: error })
-      return NextResponse.json({
-        error: t('attachments.errors.quotaUnavailable', 'Storage quota accounting is unavailable.'),
-      }, { status: 500 })
-    }
-  }
   let storedPath: string
   try {
     const stored = await uploadDriver.store({
@@ -497,25 +403,10 @@ export async function POST(req: Request) {
       tenantId,
       fileName: safeName,
       buffer: buf,
-      storagePath: preparedStoragePath,
     })
     storedPath = stored.storagePath
-    if (quotaReservation) {
-      await attachmentQuotaService!.markStored(quotaReservation.id, quotaReservation.leaseToken)
-    }
   } catch (error) {
     logger.error('Failed to persist file', { err: error })
-    if (preparedStoragePath) {
-      try {
-        await (uploadDriver.deleteStrict?.(partition.code, preparedStoragePath)
-          ?? uploadDriver.delete(partition.code, preparedStoragePath))
-        if (quotaReservation) {
-          await attachmentQuotaService!.release(quotaReservation.id, quotaReservation.leaseToken)
-        }
-      } catch (cleanupError) {
-        logger.error('Failed to compensate attachment storage', { err: cleanupError })
-      }
-    }
     return NextResponse.json({ error: 'Failed to persist attachment.' }, { status: 500 })
   }
 
@@ -580,21 +471,9 @@ export async function POST(req: Request) {
           values: customFieldValues,
         })
       }
-      if (quotaReservation) {
-        await attachmentQuotaService!.completeAttachment(quotaReservation.id, quotaReservation.leaseToken, tx)
-      }
     })
   } catch (error) {
     logger.error('Failed to persist attachment with custom attributes', { err: error })
-    try {
-      await (uploadDriver.deleteStrict?.(partition.code, storedPath)
-        ?? uploadDriver.delete(partition.code, storedPath))
-      if (quotaReservation) {
-        await attachmentQuotaService!.release(quotaReservation.id, quotaReservation.leaseToken)
-      }
-    } catch (cleanupError) {
-      logger.error('Failed to compensate attachment persistence', { err: cleanupError })
-    }
     return NextResponse.json({ error: 'Failed to save attachment attributes.' }, { status: 500 })
   }
 
@@ -658,8 +537,8 @@ async function readTenantAttachmentUsageBytes(em: EntityManager, tenantId: strin
       return Number.isFinite(parsed) ? parsed : 0
     }
     return 0
-  } catch (error) {
-    throw new Error('Attachment quota accounting is unavailable.', { cause: error })
+  } catch {
+    return 0
   }
 }
 

package/src/modules/attachments/data/entities.ts

@@ -99,62 +99,3 @@ export class Attachment {
   @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
   createdAt: Date = new Date()
 }
-
-@Entity({ tableName: 'attachment_quota_reservations' })
-@Unique({
-  name: 'attachment_quota_reservations_scope_path_unique',
-  properties: ['tenantId', 'storageDriver', 'storagePath'],
-})
-@Index({
-  name: 'attachment_quota_reservations_tenant_status_idx',
-  properties: ['tenantId', 'status'],
-})
-export class AttachmentQuotaReservation {
-  [OptionalProps]?: 'actualBytes' | 'createdAt' | 'status' | 'updatedAt' | 'uploadTokenHash'
-
-  @PrimaryKey({ type: 'uuid' })
-  id!: string
-
-  @Property({ name: 'tenant_id', type: 'uuid' })
-  tenantId!: string
-
-  @Property({ name: 'organization_id', type: 'uuid' })
-  organizationId!: string
-
-  @Property({ name: 'reserved_bytes', type: 'bigint' })
-  reservedBytes!: number
-
-  @Property({ name: 'actual_bytes', type: 'bigint', nullable: true })
-  actualBytes?: number | null
-
-  @Property({ type: 'text', default: 'reserved' })
-  status: 'reserved' | 'storing' | 'stored' | 'recovering' | 'committed' = 'reserved'
-
-  @Property({ type: 'text' })
-  source!: string
-
-  @Property({ name: 'storage_driver', type: 'text' })
-  storageDriver!: string
-
-  @Property({ name: 'partition_code', type: 'text', nullable: true })
-  partitionCode?: string | null
-
-  @Property({ name: 'storage_path', type: 'text' })
-  storagePath!: string
-
-  @Property({ name: 'lease_token', type: 'uuid' })
-  leaseToken!: string
-
-  @Property({ name: 'upload_token_hash', type: 'text', nullable: true })
-  uploadTokenHash?: string | null
-
-  @Property({ name: 'expires_at', type: Date, nullable: true })
-  @Index({ name: 'attachment_quota_reservations_expires_idx' })
-  expiresAt?: Date | null
-
-  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
-  createdAt: Date = new Date()
-
-  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
-  updatedAt: Date = new Date()
-}

package/src/modules/attachments/di.ts

@@ -1,17 +1,9 @@
-import { asFunction, asValue } from 'awilix'
+import { asFunction } from 'awilix'
 import type { AppContainer } from '@open-mercato/shared/lib/di/container'
 import { StorageDriverFactory } from './lib/drivers/driverFactory'
-import { createAttachmentQuotaService } from './lib/quota-service'
-import { scheduleAttachmentQuotaRecovery } from './lib/quota-recovery-queue'
 
 export function register(container: AppContainer) {
   container.register({
-    attachmentQuotaRecoveryScheduler: asValue(scheduleAttachmentQuotaRecovery),
-    attachmentQuotaService: asFunction(({ em }: { em: ConstructorParameters<typeof StorageDriverFactory>[0] }) =>
-      createAttachmentQuotaService(em),
-    )
-      .scoped()
-      .proxy(),
     storageDriverFactory: asFunction(({ em }: { em: ConstructorParameters<typeof StorageDriverFactory>[0] }) =>
       new StorageDriverFactory(em),
     )

package/src/modules/attachments/fields/attachment.tsx

@@ -162,7 +162,7 @@ export const AttachmentInput = ({
           />
         </div>
       )}
-      {error ? <div className="text-xs text-status-error-text">{error}</div> : null}
+      {error ? <div className="text-xs text-red-600">{error}</div> : null}
       <div className="space-y-1">
         {loading ? <div className="text-xs text-muted-foreground">{t('attachments.library.loading', 'Loading attachments…')}</div> : null}
         {items.map(it => (

package/src/modules/attachments/i18n/de.json

@@ -4,10 +4,7 @@
   "attachments.errors.maxUploadSize": "Der Anhang überschreitet die maximal zulässige Upload-Größe.",
   "attachments.errors.publicPartitionBlocked": "Öffentliche Speicherpartitionen können für diesen Upload nicht explizit ausgewählt werden.",
   "attachments.errors.quotaExceeded": "Das Speicherlimit für Anhänge dieses Tenants wurde überschritten.",
-  "attachments.errors.quotaRecoveryUnsupported": "Der Speichertreiber kann nicht an der Kontingent-Wiederherstellung teilnehmen.",
-  "attachments.errors.quotaUnavailable": "Die Speicherkontingent-Abrechnung ist nicht verfügbar.",
   "attachments.errors.selectOrganization": "Wählen Sie eine bestimmte Organisation aus, bevor Sie einen Anhang hochladen.",
-  "attachments.errors.storagePathExists": "Der Zielspeicherpfad existiert bereits.",
   "attachments.library.actions.copied": "Link kopiert.",
   "attachments.library.actions.copyError": "Link konnte nicht kopiert werden.",
   "attachments.library.actions.copyUrl": "URL kopieren",
@@ -113,9 +110,6 @@
   "attachments.partitions.errors.delete": "Partition konnte nicht gelöscht werden.",
   "attachments.partitions.errors.load": "Partitionen konnten nicht geladen werden.",
   "attachments.partitions.errors.required": "Code und Titel sind erforderlich.",
-  "attachments.partitions.errors.s3BucketRequired": "Der Bucket ist erforderlich, wenn eine separate Zugangsdatenquelle verwendet wird.",
-  "attachments.partitions.errors.s3Disabled": "Diese Partition verwendet S3, aber S3 ist deaktiviert. Setze OM_ENABLE_STORAGE_S3=true und starte die Anwendung neu.",
-  "attachments.partitions.errors.s3EnvPrefixRequired": "Das Präfix der Umgebungsvariablen ist erforderlich, wenn eine separate Zugangsdatenquelle verwendet wird.",
   "attachments.partitions.errors.save": "Partition konnte nicht gespeichert werden.",
   "attachments.partitions.form.codeLabel": "Code",
   "attachments.partitions.form.codePlaceholder": "z. B. marketingAssets",
@@ -131,25 +125,16 @@
   "attachments.partitions.form.publicLabel": "Öffentlich zugänglich",
   "attachments.partitions.form.s3BucketLabel": "Bucket",
   "attachments.partitions.form.s3BucketOverrideLabel": "Bucket überschreiben (optional)",
-  "attachments.partitions.form.s3BucketOverridePlaceholder": "Leer lassen, um den Bucket der Integration zu verwenden",
   "attachments.partitions.form.s3ConfigTitle": "S3-Konfiguration",
-  "attachments.partitions.form.s3CredsPrefixHelp": "Liest {PREFIX}_ACCESS_KEY_ID und {PREFIX}_SECRET_ACCESS_KEY aus den Umgebungsvariablen.",
   "attachments.partitions.form.s3CredsPrefixLabel": "Präfix für Zugangsdaten-Umgebungsvariablen",
-  "attachments.partitions.form.s3CredsSourceEnv": "Separate Zugangsdaten aus Umgebungsvariablen verwenden",
-  "attachments.partitions.form.s3CredsSourceEnvHelp": "Diese Partition verwendet eigene Zugangsdaten aus Umgebungsvariablen. Die Zugangsdaten der Integration werden ignoriert. Bucket und Zugangsdaten-Präfix sind erforderlich.",
-  "attachments.partitions.form.s3CredsSourceIntegration": "Zugangsdaten aus dem Integrations-Marktplatz verwenden",
-  "attachments.partitions.form.s3CredsSourceIntegrationHelp": "Diese Partition verwendet die in der S3-Integration konfigurierten Zugangsdaten, Bucket, Region und Endpoint. Überschreibe einzelne Felder unten nur bei Bedarf.",
   "attachments.partitions.form.s3CredsSourceLabel": "Quelle der Zugangsdaten",
   "attachments.partitions.form.s3EndpointHelp": "Für AWS S3 leer lassen. Erforderlich für MinIO, DigitalOcean Spaces usw.",
   "attachments.partitions.form.s3EndpointLabel": "Benutzerdefinierter Endpoint",
   "attachments.partitions.form.s3EndpointOverrideLabel": "Benutzerdefinierten Endpoint überschreiben (optional)",
-  "attachments.partitions.form.s3EndpointOverridePlaceholder": "Leer lassen, um den Endpoint der Integration zu verwenden",
   "attachments.partitions.form.s3ForcePathStyleLabel": "Path-Style erzwingen (für MinIO erforderlich)",
   "attachments.partitions.form.s3RegionLabel": "Region",
   "attachments.partitions.form.s3RegionOverrideLabel": "Region überschreiben (optional)",
-  "attachments.partitions.form.s3RegionOverridePlaceholder": "Leer lassen, um die Region der Integration zu verwenden",
   "attachments.partitions.form.storageDriverLabel": "Speichertreiber",
-  "attachments.partitions.form.storageDriverS3DisabledHelp": "S3 ist deaktiviert. Setze OM_ENABLE_STORAGE_S3=true und starte neu, um S3-Partitionen zu aktivieren.",
   "attachments.partitions.form.titleLabel": "Titel",
   "attachments.partitions.form.titlePlaceholder": "z. B. Marketing-Assets",
   "attachments.partitions.locked.description": "Anhang-Partitionen werden durch Umgebungsstandardwerte verwaltet, solange der Demo- oder Onboarding-Modus aktiv ist.",

package/src/modules/attachments/i18n/en.json

@@ -4,10 +4,7 @@
   "attachments.errors.maxUploadSize": "Attachment exceeds the maximum upload size.",
   "attachments.errors.publicPartitionBlocked": "Public storage partitions cannot be selected explicitly for this upload.",
   "attachments.errors.quotaExceeded": "Attachment storage quota exceeded for this tenant.",
-  "attachments.errors.quotaRecoveryUnsupported": "Storage driver cannot participate in quota recovery.",
-  "attachments.errors.quotaUnavailable": "Storage quota accounting is unavailable.",
   "attachments.errors.selectOrganization": "Select a specific organization before uploading an attachment.",
-  "attachments.errors.storagePathExists": "The target storage path already exists.",
   "attachments.library.actions.copied": "Link copied.",
   "attachments.library.actions.copyError": "Unable to copy link.",
   "attachments.library.actions.copyUrl": "Copy URL",
@@ -113,9 +110,6 @@
   "attachments.partitions.errors.delete": "Failed to delete partition.",
   "attachments.partitions.errors.load": "Failed to load partitions.",
   "attachments.partitions.errors.required": "Code and title are required.",
-  "attachments.partitions.errors.s3BucketRequired": "Bucket is required when using a separate credentials source.",
-  "attachments.partitions.errors.s3Disabled": "This partition uses S3, but S3 is disabled. Set OM_ENABLE_STORAGE_S3=true and restart the app.",
-  "attachments.partitions.errors.s3EnvPrefixRequired": "Credentials env prefix is required when using a separate credentials source.",
   "attachments.partitions.errors.save": "Failed to save partition.",
   "attachments.partitions.form.codeLabel": "Code",
   "attachments.partitions.form.codePlaceholder": "e.g. marketingAssets",
@@ -131,25 +125,16 @@
   "attachments.partitions.form.publicLabel": "Publicly accessible",
   "attachments.partitions.form.s3BucketLabel": "Bucket",
   "attachments.partitions.form.s3BucketOverrideLabel": "Bucket override (optional)",
-  "attachments.partitions.form.s3BucketOverridePlaceholder": "Leave empty to use integration bucket",
   "attachments.partitions.form.s3ConfigTitle": "S3 Configuration",
-  "attachments.partitions.form.s3CredsPrefixHelp": "Reads {PREFIX}_ACCESS_KEY_ID and {PREFIX}_SECRET_ACCESS_KEY from environment variables.",
   "attachments.partitions.form.s3CredsPrefixLabel": "Credentials Env Prefix",
-  "attachments.partitions.form.s3CredsSourceEnv": "Use separate env-based credentials",
-  "attachments.partitions.form.s3CredsSourceEnvHelp": "This partition uses its own credentials read from environment variables. The integration credentials are ignored. Bucket and credentials prefix are required.",
-  "attachments.partitions.form.s3CredsSourceIntegration": "Use Integration Marketplace credentials",
-  "attachments.partitions.form.s3CredsSourceIntegrationHelp": "This partition reuses the credentials, bucket, region and endpoint configured in the S3 integration. Override individual fields below only when needed.",
   "attachments.partitions.form.s3CredsSourceLabel": "Credentials source",
   "attachments.partitions.form.s3EndpointHelp": "Leave empty for AWS S3. Required for MinIO, DigitalOcean Spaces, etc.",
   "attachments.partitions.form.s3EndpointLabel": "Custom Endpoint",
   "attachments.partitions.form.s3EndpointOverrideLabel": "Custom endpoint override (optional)",
-  "attachments.partitions.form.s3EndpointOverridePlaceholder": "Leave empty to use integration endpoint",
   "attachments.partitions.form.s3ForcePathStyleLabel": "Force Path Style (required for MinIO)",
   "attachments.partitions.form.s3RegionLabel": "Region",
   "attachments.partitions.form.s3RegionOverrideLabel": "Region override (optional)",
-  "attachments.partitions.form.s3RegionOverridePlaceholder": "Leave empty to use integration region",
   "attachments.partitions.form.storageDriverLabel": "Storage Driver",
-  "attachments.partitions.form.storageDriverS3DisabledHelp": "S3 is disabled. Set OM_ENABLE_STORAGE_S3=true and restart to enable S3 partitions.",
   "attachments.partitions.form.titleLabel": "Title",
   "attachments.partitions.form.titlePlaceholder": "e.g. Marketing assets",
   "attachments.partitions.locked.description": "Attachment partitions are managed by environment defaults while demo or onboarding mode is enabled.",

package/src/modules/attachments/i18n/es.json

@@ -4,10 +4,7 @@
   "attachments.errors.maxUploadSize": "El archivo adjunto supera el tamaño máximo de carga permitido.",
   "attachments.errors.publicPartitionBlocked": "No se pueden seleccionar explícitamente particiones de almacenamiento públicas para esta carga.",
   "attachments.errors.quotaExceeded": "Se superó la cuota de almacenamiento de adjuntos para este tenant.",
-  "attachments.errors.quotaRecoveryUnsupported": "El controlador de almacenamiento no puede participar en la recuperación de cuota.",
-  "attachments.errors.quotaUnavailable": "La contabilidad de la cuota de almacenamiento no está disponible.",
   "attachments.errors.selectOrganization": "Selecciona una organización específica antes de subir un adjunto.",
-  "attachments.errors.storagePathExists": "La ruta de almacenamiento de destino ya existe.",
   "attachments.library.actions.copied": "Enlace copiado.",
   "attachments.library.actions.copyError": "No se pudo copiar el enlace.",
   "attachments.library.actions.copyUrl": "Copiar URL",
@@ -113,9 +110,6 @@
   "attachments.partitions.errors.delete": "No se pudo eliminar la partición.",
   "attachments.partitions.errors.load": "No se pudieron cargar las particiones.",
   "attachments.partitions.errors.required": "El código y el título son obligatorios.",
-  "attachments.partitions.errors.s3BucketRequired": "El bucket es obligatorio cuando se usa una fuente de credenciales independiente.",
-  "attachments.partitions.errors.s3Disabled": "Esta partición usa S3, pero S3 está desactivado. Configura OM_ENABLE_STORAGE_S3=true y reinicia la aplicación.",
-  "attachments.partitions.errors.s3EnvPrefixRequired": "El prefijo de variables de entorno es obligatorio cuando se usa una fuente de credenciales independiente.",
   "attachments.partitions.errors.save": "No se pudo guardar la partición.",
   "attachments.partitions.form.codeLabel": "Código",
   "attachments.partitions.form.codePlaceholder": "ej. marketingAssets",
@@ -131,25 +125,16 @@
   "attachments.partitions.form.publicLabel": "Acceso público",
   "attachments.partitions.form.s3BucketLabel": "Bucket",
   "attachments.partitions.form.s3BucketOverrideLabel": "Sobrescribir bucket (opcional)",
-  "attachments.partitions.form.s3BucketOverridePlaceholder": "Déjalo vacío para usar el bucket de la integración",
   "attachments.partitions.form.s3ConfigTitle": "Configuración S3",
-  "attachments.partitions.form.s3CredsPrefixHelp": "Lee {PREFIX}_ACCESS_KEY_ID y {PREFIX}_SECRET_ACCESS_KEY de las variables de entorno.",
   "attachments.partitions.form.s3CredsPrefixLabel": "Prefijo de variables de entorno de credenciales",
-  "attachments.partitions.form.s3CredsSourceEnv": "Usar credenciales independientes basadas en el entorno",
-  "attachments.partitions.form.s3CredsSourceEnvHelp": "Esta partición usa sus propias credenciales leídas de variables de entorno. Las credenciales de la integración se ignoran. El bucket y el prefijo de credenciales son obligatorios.",
-  "attachments.partitions.form.s3CredsSourceIntegration": "Usar credenciales del Marketplace de integraciones",
-  "attachments.partitions.form.s3CredsSourceIntegrationHelp": "Esta partición reutiliza las credenciales, el bucket, la región y el endpoint configurados en la integración de S3. Anula los campos individuales de abajo solo cuando sea necesario.",
   "attachments.partitions.form.s3CredsSourceLabel": "Origen de credenciales",
   "attachments.partitions.form.s3EndpointHelp": "Déjelo vacío para AWS S3. Es obligatorio para MinIO, DigitalOcean Spaces, etc.",
   "attachments.partitions.form.s3EndpointLabel": "Endpoint personalizado",
   "attachments.partitions.form.s3EndpointOverrideLabel": "Sobrescribir endpoint personalizado (opcional)",
-  "attachments.partitions.form.s3EndpointOverridePlaceholder": "Déjalo vacío para usar el endpoint de la integración",
   "attachments.partitions.form.s3ForcePathStyleLabel": "Forzar Path Style (obligatorio para MinIO)",
   "attachments.partitions.form.s3RegionLabel": "Región",
   "attachments.partitions.form.s3RegionOverrideLabel": "Sobrescribir región (opcional)",
-  "attachments.partitions.form.s3RegionOverridePlaceholder": "Déjalo vacío para usar la región de la integración",
   "attachments.partitions.form.storageDriverLabel": "Controlador de almacenamiento",
-  "attachments.partitions.form.storageDriverS3DisabledHelp": "S3 está desactivado. Configura OM_ENABLE_STORAGE_S3=true y reinicia para habilitar particiones S3.",
   "attachments.partitions.form.titleLabel": "Título",
   "attachments.partitions.form.titlePlaceholder": "ej. Recursos de marketing",
   "attachments.partitions.locked.description": "Las particiones de archivos adjuntos están administradas por valores predeterminados del entorno mientras el modo demo o de incorporación está activo.",

package/src/modules/attachments/i18n/pl.json

@@ -4,10 +4,7 @@
   "attachments.errors.maxUploadSize": "Załącznik przekracza maksymalny dopuszczalny rozmiar przesyłania.",
   "attachments.errors.publicPartitionBlocked": "Nie można jawnie wybrać publicznej partycji do tego przesyłania.",
   "attachments.errors.quotaExceeded": "Przekroczono limit miejsca na załączniki dla tego tenantu.",
-  "attachments.errors.quotaRecoveryUnsupported": "Sterownik przechowywania nie może uczestniczyć w odzyskiwaniu limitu.",
-  "attachments.errors.quotaUnavailable": "Rozliczanie limitu przestrzeni dyskowej jest niedostępne.",
   "attachments.errors.selectOrganization": "Wybierz konkretną organizację przed przesłaniem załącznika.",
-  "attachments.errors.storagePathExists": "Docelowa ścieżka przechowywania już istnieje.",
   "attachments.library.actions.copied": "Link skopiowany.",
   "attachments.library.actions.copyError": "Nie można skopiować linku.",
   "attachments.library.actions.copyUrl": "Kopiuj URL",
@@ -113,9 +110,6 @@
   "attachments.partitions.errors.delete": "Nie udało się usunąć partycji.",
   "attachments.partitions.errors.load": "Nie udało się załadować partycji.",
   "attachments.partitions.errors.required": "Kod i tytuł są wymagane.",
-  "attachments.partitions.errors.s3BucketRequired": "Bucket jest wymagany przy osobnym źródle poświadczeń.",
-  "attachments.partitions.errors.s3Disabled": "Ta partycja korzysta z S3, ale S3 jest wyłączone. Ustaw OM_ENABLE_STORAGE_S3=true i uruchom ponownie aplikację.",
-  "attachments.partitions.errors.s3EnvPrefixRequired": "Prefiks zmiennych środowiskowych jest wymagany przy osobnym źródle poświadczeń.",
   "attachments.partitions.errors.save": "Nie udało się zapisać partycji.",
   "attachments.partitions.form.codeLabel": "Kod",
   "attachments.partitions.form.codePlaceholder": "np. marketingAssets",
@@ -131,25 +125,16 @@
   "attachments.partitions.form.publicLabel": "Publicznie dostępna",
   "attachments.partitions.form.s3BucketLabel": "Bucket",
   "attachments.partitions.form.s3BucketOverrideLabel": "Nadpisanie bucketu (opcjonalne)",
-  "attachments.partitions.form.s3BucketOverridePlaceholder": "Pozostaw puste, aby użyć bucketu z integracji",
   "attachments.partitions.form.s3ConfigTitle": "Konfiguracja S3",
-  "attachments.partitions.form.s3CredsPrefixHelp": "Odczytuje {PREFIX}_ACCESS_KEY_ID i {PREFIX}_SECRET_ACCESS_KEY ze zmiennych środowiskowych.",
   "attachments.partitions.form.s3CredsPrefixLabel": "Prefiks zmiennych środowiskowych poświadczeń",
-  "attachments.partitions.form.s3CredsSourceEnv": "Użyj osobnych poświadczeń ze zmiennych środowiskowych",
-  "attachments.partitions.form.s3CredsSourceEnvHelp": "Ta partycja używa własnych poświadczeń odczytywanych ze zmiennych środowiskowych. Poświadczenia z integracji są ignorowane. Bucket i prefiks poświadczeń są wymagane.",
-  "attachments.partitions.form.s3CredsSourceIntegration": "Użyj poświadczeń z Marketplace integracji",
-  "attachments.partitions.form.s3CredsSourceIntegrationHelp": "Ta partycja korzysta z poświadczeń, bucketu, regionu i endpointu skonfigurowanych w integracji S3. Nadpisuj poszczególne pola poniżej tylko w razie potrzeby.",
   "attachments.partitions.form.s3CredsSourceLabel": "Źródło poświadczeń",
   "attachments.partitions.form.s3EndpointHelp": "Pozostaw puste dla AWS S3. Wymagane dla MinIO, DigitalOcean Spaces itp.",
   "attachments.partitions.form.s3EndpointLabel": "Niestandardowy endpoint",
   "attachments.partitions.form.s3EndpointOverrideLabel": "Nadpisanie niestandardowego endpointu (opcjonalne)",
-  "attachments.partitions.form.s3EndpointOverridePlaceholder": "Pozostaw puste, aby użyć endpointu z integracji",
   "attachments.partitions.form.s3ForcePathStyleLabel": "Wymuś Path Style (wymagane dla MinIO)",
   "attachments.partitions.form.s3RegionLabel": "Region",
   "attachments.partitions.form.s3RegionOverrideLabel": "Nadpisanie regionu (opcjonalne)",
-  "attachments.partitions.form.s3RegionOverridePlaceholder": "Pozostaw puste, aby użyć regionu z integracji",
   "attachments.partitions.form.storageDriverLabel": "Sterownik magazynu",
-  "attachments.partitions.form.storageDriverS3DisabledHelp": "S3 jest wyłączone. Ustaw OM_ENABLE_STORAGE_S3=true i uruchom ponownie, aby włączyć partycje S3.",
   "attachments.partitions.form.titleLabel": "Tytuł",
   "attachments.partitions.form.titlePlaceholder": "np. Zasoby marketingowe",
   "attachments.partitions.locked.description": "Partycje załączników są zarządzane przez domyślne zmienne środowiskowe, gdy włączony jest tryb demonstracyjny lub onboardingowy.",

package/src/modules/attachments/lib/drivers/index.ts

@@ -1,4 +1,4 @@
-export type { PrepareFilePayload, StorageDriver, StoreFilePayload, StoredFile, ReadFileResult } from './types'
+export type { StorageDriver, StoreFilePayload, StoredFile, ReadFileResult } from './types'
 export { LocalStorageDriver } from './localDriver'
 export { LegacyPublicStorageDriver } from './legacyPublicDriver'
 export { StorageDriverFactory, registerExternalStorageDriver, registerExternalCredentialEnhancer } from './driverFactory'

package/src/modules/attachments/lib/drivers/localDriver.ts

@@ -3,7 +3,7 @@ import path from 'path'
 import { randomUUID } from 'crypto'
 import { resolvePartitionRoot } from '../storage'
 import { resolveContainedPath } from '../pathContainment'
-import type { PrepareFilePayload, StorageDriver, StoreFilePayload, StoredFile, ReadFileResult } from './types'
+import type { StorageDriver, StoreFilePayload, StoredFile, ReadFileResult } from './types'
 
 function sanitizeFileName(fileName: string): string {
   if (!fileName) return 'file'
@@ -23,21 +23,17 @@ function resolveTenantSegment(tenantId: string | null | undefined): string {
 export class LocalStorageDriver implements StorageDriver {
   readonly key = 'local'
 
-  prepareStoragePath(payload: PrepareFilePayload): string {
+  async store(payload: StoreFilePayload): Promise<StoredFile> {
+    const root = resolvePartitionRoot(payload.partitionCode)
     const orgSegment = resolveOrgSegment(payload.orgId ?? null)
     const tenantSegment = resolveTenantSegment(payload.tenantId ?? null)
     const safeName = sanitizeFileName(payload.fileName || 'file')
     const uniqueSuffix = randomUUID().replace(/-/g, '').slice(0, 12)
     const storedName = `${Date.now()}_${uniqueSuffix}_${safeName}`
-    return path.join(orgSegment, tenantSegment, storedName).replace(/\\/g, '/')
-  }
-
-  async store(payload: StoreFilePayload): Promise<StoredFile> {
-    const root = resolvePartitionRoot(payload.partitionCode)
-    const relativePath = payload.storagePath ?? this.prepareStoragePath(payload)
+    const relativePath = path.join(orgSegment, tenantSegment, storedName)
     const absolutePath = path.join(root, relativePath)
     await fs.mkdir(path.dirname(absolutePath), { recursive: true })
-    await fs.writeFile(absolutePath, payload.buffer, { flag: 'wx' })
+    await fs.writeFile(absolutePath, payload.buffer)
     return {
       storagePath: relativePath.replace(/\\/g, '/'),
     }
@@ -50,22 +46,11 @@ export class LocalStorageDriver implements StorageDriver {
   }
 
   async delete(partitionCode: string, storagePath: string): Promise<void> {
-    try {
-      await this.deleteStrict(partitionCode, storagePath)
-    } catch {
-      // Backward-compatible best-effort removal.
-    }
-  }
-
-  async deleteStrict(partitionCode: string, storagePath: string): Promise<void> {
     const absolutePath = this.resolveAbsolutePath(partitionCode, storagePath)
     try {
-      if (typeof fs.rm === 'function') await fs.rm(absolutePath, { force: true })
-      else await fs.unlink(absolutePath)
-    } catch (error) {
-      const code = (error as NodeJS.ErrnoException)?.code
-      const message = error instanceof Error ? error.message : ''
-      if (code !== 'ENOENT' && !message.includes('ENOENT')) throw error
+      await fs.unlink(absolutePath)
+    } catch {
+      // best-effort removal
     }
   }
 

package/src/modules/attachments/lib/drivers/types.ts

@@ -4,11 +4,8 @@ export type StoreFilePayload = {
   tenantId: string | null | undefined
   fileName: string
   buffer: Buffer
-  storagePath?: string
 }
 
-export type PrepareFilePayload = Omit<StoreFilePayload, 'buffer' | 'storagePath'>
-
 export type StoredFile = {
   storagePath: string
   driverMeta?: Record<string, unknown> | null
@@ -21,11 +18,9 @@ export type ReadFileResult = {
 
 export interface StorageDriver {
   readonly key: string
-  prepareStoragePath?(payload: PrepareFilePayload): string
   store(payload: StoreFilePayload): Promise<StoredFile>
   read(partitionCode: string, storagePath: string): Promise<ReadFileResult>
   delete(partitionCode: string, storagePath: string): Promise<void>
-  deleteStrict?(partitionCode: string, storagePath: string): Promise<void>
   toLocalPath(
     partitionCode: string,
     storagePath: string,

package/src/modules/attachments/lib/upload-limits.ts

@@ -46,41 +46,6 @@ export function isMultipartRequestWithinUploadLimit(contentLengthHeader: string
   return contentLength <= (resolveDefaultAttachmentMaxUploadBytes() + MULTIPART_CONTENT_LENGTH_OVERHEAD_BYTES)
 }
 
-export class MultipartUploadLimitError extends Error {
-  constructor() {
-    super('Multipart request exceeds the maximum upload size.')
-    this.name = 'MultipartUploadLimitError'
-  }
-}
-
-export function isMultipartUploadLimitError(error: unknown): error is MultipartUploadLimitError {
-  return error instanceof MultipartUploadLimitError
-}
-
-export async function parseMultipartFormDataWithinUploadLimit(request: Request): Promise<FormData> {
-  if (!isMultipartRequestWithinUploadLimit(request.headers.get('content-length'))) {
-    throw new MultipartUploadLimitError()
-  }
-
-  if (!request.body) return request.formData()
-
-  const maxBytes = resolveDefaultAttachmentMaxUploadBytes() + MULTIPART_CONTENT_LENGTH_OVERHEAD_BYTES
-  let consumedBytes = 0
-  const boundedBody = request.body.pipeThrough(new TransformStream<Uint8Array, Uint8Array>({
-    transform(chunk, controller) {
-      consumedBytes += chunk.byteLength
-      if (consumedBytes > maxBytes) {
-        controller.error(new MultipartUploadLimitError())
-        return
-      }
-      controller.enqueue(chunk)
-    },
-  }))
-  const contentType = request.headers.get('content-type')
-  const headers = contentType ? { 'content-type': contentType } : undefined
-  return new Response(boundedBody, { headers }).formData()
-}
-
 export function willExceedAttachmentTenantQuota(currentUsageBytes: number, incomingFileBytes: number): boolean {
   return (currentUsageBytes + incomingFileBytes) > resolveAttachmentTenantQuotaBytes()
 }