@open-mercato/sync-akeneo 0.9.1-develop.7566.1.b9de0a5eb7 → 0.9.1-develop.7572.1.e9bdaac5f1

package/dist/modules/sync_akeneo/lib/catalog-importer.js

@@ -3,6 +3,8 @@ import { createRequestContainer } from "@open-mercato/shared/lib/di/container";
 import { emitCrudSideEffects, setCustomFieldsIfAny } from "@open-mercato/shared/lib/commands/helpers";
 import { withAtomicFlush } from "@open-mercato/shared/lib/commands/flush";
 import { findOneWithDecryption, findWithDecryption } from "@open-mercato/shared/lib/encryption/find";
+import { isCrudHttpError } from "@open-mercato/shared/lib/crud/errors";
+import { resolveTranslations } from "@open-mercato/shared/lib/i18n/server";
 import { SyncExternalIdMapping } from "@open-mercato/core/modules/integrations/data/entities";
 import {
   CatalogOffer,
@@ -20,9 +22,9 @@ import { normalizeEntityFieldsetConfig } from "@open-mercato/core/modules/entiti
 import { invalidateDefinitionsCache } from "@open-mercato/core/modules/entities/api/definitions.cache";
 import { Attachment } from "@open-mercato/core/modules/attachments/data/entities";
 import { buildAttachmentFileUrl, buildAttachmentImageUrl, slugifyAttachmentFileName } from "@open-mercato/core/modules/attachments/lib/imageUrls";
-import { deletePartitionFile, storePartitionFile } from "@open-mercato/core/modules/attachments/lib/storage";
-import { ensureDefaultPartitions, resolveDefaultPartitionCode } from "@open-mercato/core/modules/attachments/lib/partitions";
-import { mergeAttachmentMetadata } from "@open-mercato/core/modules/attachments/lib/metadata";
+import {
+  isScopedAttachmentUploadError
+} from "@open-mercato/core/modules/attachments/lib/scoped-upload-service";
 import { attachmentCrudEvents, attachmentCrudIndexer } from "@open-mercato/core/modules/attachments/lib/crud";
 import { emitCatalogQueryIndexEvent } from "@open-mercato/core/modules/catalog/commands/shared";
 import { SalesChannel } from "@open-mercato/core/modules/sales/data/entities";
@@ -35,8 +37,14 @@ import {
   slugifyAkeneoCode,
   buildDefaultAkeneoMapping
 } from "./shared.js";
+import { isAkeneoResponseTooLargeError } from "./client.js";
 import { inferAkeneoProductMapping } from "./inference.js";
 import { normalizeMarkdownText } from "./markdown.js";
+const REJECTED_MEDIA_UPLOAD_CODES = /* @__PURE__ */ new Set([
+  "dangerous_executable",
+  "max_upload_size",
+  "active_content"
+]);
 const PRODUCT_ENTITY_ID = "catalog:catalog_product";
 const VARIANT_ENTITY_ID = "catalog:catalog_product_variant";
 function readPreferredAkeneoValue(values, attributeCode, locale, channel) {
@@ -1748,40 +1756,61 @@ async function createAkeneoImporter(client, scope) {
       }
     }
   }
+  async function recordRejectedMedia(asset, reason) {
+    const integrationLogService = container.resolve("integrationLogService");
+    await integrationLogService.write({
+      integrationId: "sync_akeneo",
+      level: "warn",
+      code: "sync_akeneo.media_rejected",
+      message: `Akeneo media ${asset.remote.codeOrUrl} was not imported: ${reason}`,
+      scopeEntityType: asset.entityId,
+      scopeEntityId: asset.recordId,
+      payload: {
+        externalId: asset.externalId,
+        remoteCode: asset.remote.codeOrUrl,
+        kind: asset.kind,
+        reason
+      }
+    }, scope);
+  }
   async function upsertAsset(asset) {
     const existingAttachmentId = await externalIdMappingService.lookupLocalId("sync_akeneo", "attachment", asset.externalId, scope);
     if (existingAttachmentId) return existingAttachmentId;
-    await ensureDefaultPartitions(em);
-    const binary = await client.downloadMediaFile(asset.remote.codeOrUrl);
+    let binary;
+    try {
+      binary = await client.downloadMediaFile(asset.remote.codeOrUrl);
+    } catch (error) {
+      if (!isAkeneoResponseTooLargeError(error)) throw error;
+      await recordRejectedMedia(asset, "max_upload_size");
+      return null;
+    }
     const fileName = asset.remote.fileNameHint ?? binary.fileName ?? `akeneo-${randomUUID().slice(0, 8)}`;
-    const partitionCode = resolveDefaultPartitionCode(asset.entityId);
-    const stored = await storePartitionFile({
-      partitionCode,
-      orgId: scope.organizationId,
-      tenantId: scope.tenantId,
-      fileName,
-      buffer: binary.buffer
-    });
-    const attachment = em.create(Attachment, {
-      entityId: asset.entityId,
-      recordId: asset.recordId,
-      organizationId: scope.organizationId,
-      tenantId: scope.tenantId,
-      partitionCode,
-      fileName,
-      mimeType: asset.remote.mimeTypeHint ?? binary.contentType ?? "application/octet-stream",
-      fileSize: binary.contentLength ?? binary.buffer.byteLength,
-      storageDriver: "local",
-      storagePath: stored.storagePath,
-      storageMetadata: mergeAttachmentMetadata(null, {
-        assignments: [{ type: asset.entityId, id: asset.recordId }]
-      }),
-      url: buildAttachmentFileUrl("pending"),
-      content: null
-    });
-    em.persist(attachment);
-    await em.flush();
-    attachment.url = asset.kind === "image" ? buildAttachmentImageUrl(attachment.id, { slug: slugifyAttachmentFileName(fileName) }) : buildAttachmentFileUrl(attachment.id);
+    const uploadService = container.resolve("attachmentScopedUploadService");
+    let attachment;
+    try {
+      attachment = await uploadService.upload({
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+        entityId: asset.entityId,
+        recordId: asset.recordId,
+        fileName,
+        declaredMimeType: asset.remote.mimeTypeHint ?? binary.contentType,
+        buffer: binary.buffer
+      });
+    } catch (error) {
+      if (!isScopedAttachmentUploadError(error)) throw error;
+      if (REJECTED_MEDIA_UPLOAD_CODES.has(error.code)) {
+        await recordRejectedMedia(asset, error.code);
+        return null;
+      }
+      const { translate } = await resolveTranslations();
+      throw new Error(translate(
+        "sync_akeneo.errors.mediaStorageRejected",
+        "Akeneo media {code} was rejected by attachment storage ({reason}).",
+        { code: asset.remote.codeOrUrl, reason: error.code }
+      ));
+    }
+    attachment.url = asset.kind === "image" ? buildAttachmentImageUrl(attachment.id, { slug: slugifyAttachmentFileName(attachment.fileName) }) : buildAttachmentFileUrl(attachment.id);
     attachment.storageMetadata = {
       ...attachment.storageMetadata ?? {},
       source: "akeneo",
@@ -1790,16 +1819,37 @@ async function createAkeneoImporter(client, scope) {
       remoteCode: asset.remote.codeOrUrl
     };
     await em.flush();
-    await emitAttachmentCrudChange("created", attachment);
+    await emitAttachmentCrudChange("updated", attachment);
     await externalIdMappingService.storeExternalIdMapping("sync_akeneo", "attachment", attachment.id, asset.externalId, scope);
     return attachment.id;
   }
+  async function releaseImportedAttachment(attachment) {
+    const attachmentService = container.resolve("attachmentService");
+    if (!attachmentService.releaseScoped) {
+      throw new Error("[internal] attachmentService.releaseScoped is not available");
+    }
+    try {
+      await attachmentService.releaseScoped({
+        attachmentId: attachment.id,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+        expectedOwner: { entityId: attachment.entityId, recordId: attachment.recordId },
+        expectedAssignment: { type: attachment.entityId, id: attachment.recordId },
+        expectedPartitionCode: attachment.partitionCode
+      });
+      return true;
+    } catch (error) {
+      if (isCrudHttpError(error) && error.status === 409) return false;
+      throw error;
+    }
+  }
   async function reconcileAttachments(params) {
     const desiredExternalIds = new Set(params.desiredAssets.map((asset) => asset.externalId));
-    const desiredImages = params.desiredAssets.filter((asset) => asset.kind === "image");
-    const desiredFiles = params.desiredAssets.filter((asset) => asset.kind === "file");
-    const desiredAttachmentIds = await Promise.all(params.desiredAssets.map((asset) => upsertAsset(asset)));
-    const heroAttachmentId = desiredImages.length > 0 ? desiredAttachmentIds[params.desiredAssets.findIndex((asset) => asset.externalId === desiredImages[0]?.externalId)] : null;
+    let heroAttachmentId = null;
+    for (const asset of params.desiredAssets) {
+      const attachmentId = await upsertAsset(asset);
+      if (!heroAttachmentId && attachmentId && asset.kind === "image") heroAttachmentId = attachmentId;
+    }
     const heroAttachmentUrl = heroAttachmentId ? buildAttachmentImageUrl(heroAttachmentId) : null;
     const existing = await findWithDecryption(em, Attachment, {
       entityId: params.entityId,
@@ -1814,8 +1864,7 @@ async function createAkeneoImporter(client, scope) {
       if (!externalId || !kind) continue;
       const shouldDelete = kind === "image" ? params.reconciliation.deleteMissingMedia : params.reconciliation.deleteMissingAttachments;
       if (!shouldDelete || desiredExternalIds.has(externalId)) continue;
-      await deletePartitionFile(attachment.partitionCode, attachment.storagePath, attachment.storageDriver);
-      await em.remove(attachment).flush();
+      if (!await releaseImportedAttachment(attachment)) continue;
       await emitAttachmentCrudChange("deleted", attachment);
     }
     return {