@open-mercato/sync-akeneo 0.9.1-develop.7574.1.837288eec1 → 0.9.1-develop.7575.1.8480826a9b

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

@@ -3,8 +3,6 @@ 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,
@@ -22,9 +20,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 {
-  isScopedAttachmentUploadError
-} from "@open-mercato/core/modules/attachments/lib/scoped-upload-service";
+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 { 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";
@@ -37,14 +35,8 @@ 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) {
@@ -1756,61 +1748,40 @@ 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;
-    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;
-    }
+    await ensureDefaultPartitions(em);
+    const binary = await client.downloadMediaFile(asset.remote.codeOrUrl);
     const fileName = asset.remote.fileNameHint ?? binary.fileName ?? `akeneo-${randomUUID().slice(0, 8)}`;
-    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);
+    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);
     attachment.storageMetadata = {
       ...attachment.storageMetadata ?? {},
       source: "akeneo",
@@ -1819,37 +1790,16 @@ async function createAkeneoImporter(client, scope) {
       remoteCode: asset.remote.codeOrUrl
     };
     await em.flush();
-    await emitAttachmentCrudChange("updated", attachment);
+    await emitAttachmentCrudChange("created", 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));
-    let heroAttachmentId = null;
-    for (const asset of params.desiredAssets) {
-      const attachmentId = await upsertAsset(asset);
-      if (!heroAttachmentId && attachmentId && asset.kind === "image") heroAttachmentId = attachmentId;
-    }
+    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;
     const heroAttachmentUrl = heroAttachmentId ? buildAttachmentImageUrl(heroAttachmentId) : null;
     const existing = await findWithDecryption(em, Attachment, {
       entityId: params.entityId,
@@ -1864,7 +1814,8 @@ 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;
-      if (!await releaseImportedAttachment(attachment)) continue;
+      await deletePartitionFile(attachment.partitionCode, attachment.storagePath, attachment.storageDriver);
+      await em.remove(attachment).flush();
       await emitAttachmentCrudChange("deleted", attachment);
     }
     return {