@uniformdev/transformer 1.1.55 → 1.1.56

package/dist/cli/index.js

@@ -70,6 +70,14 @@ var SlotAlreadyExistsError = class extends TransformError {
     this.name = "SlotAlreadyExistsError";
   }
 };
+var ContentTypeFieldConflictError = class extends TransformError {
+  constructor(contentTypeId, fieldId, existingType, newType) {
+    super(
+      `Content type "${contentTypeId}" field "${fieldId}" type conflict: existing type "${existingType}" differs from generated type "${newType}"`
+    );
+    this.name = "ContentTypeFieldConflictError";
+  }
+};
 
 // src/core/services/file-system.service.ts
 var FileSystemService = class {
@@ -621,6 +629,7 @@ var CompositionConverterService = class {
     const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
     const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
     let contentTypesWritten = 0;
+    let contentTypesMerged = 0;
     let entriesFromCompositions = 0;
     let entriesFromReferences = 0;
     let entriesReused = 0;
@@ -650,7 +659,7 @@ var CompositionConverterService = class {
     );
     if (compositionResults.length === 0) {
       this.logger.warn("No compositions found matching the specified types");
-      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromReferences: 0, entriesReused: 0, blocksEmbedded: 0 };
+      return { contentTypesWritten: 0, contentTypesMerged: 0, entriesFromCompositions: 0, entriesFromReferences: 0, entriesReused: 0, blocksEmbedded: 0 };
     }
     this.logger.info(`Found ${compositionResults.length} composition(s)`);
     const componentsToReferences = this.expandWildcardTypes(compositionResults, initialComponentsToReferences, strict);
@@ -1164,37 +1173,49 @@ var CompositionConverterService = class {
     }
     for (const [typeName, contentType] of contentTypeMap) {
       const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
-      const baseFieldCount = contentType.fields.filter((f) => f.type !== "contentReference" && f.type !== "$block").length;
-      const refCount = contentType.fields.filter((f) => f.type === "contentReference").length;
-      const blockCount = contentType.fields.filter((f) => f.type === "$block").length;
+      const merged = await this.mergeWithExistingContentType(filePath, contentType);
+      const baseFieldCount = merged.fields.filter((f) => f.type !== "contentReference" && f.type !== "$block").length;
+      const refCount = merged.fields.filter((f) => f.type === "contentReference").length;
+      const blockCount = merged.fields.filter((f) => f.type === "$block").length;
       const extras = [
         refCount > 0 ? `${refCount} reference(s)` : "",
         blockCount > 0 ? `${blockCount} block(s)` : ""
       ].filter(Boolean).join(", ");
       const extrasInfo = extras ? ` + ${extras}` : "";
+      const isMerged = merged !== contentType;
       this.logger.action(
         whatIf,
-        "WRITE",
+        isMerged ? "MERGE" : "WRITE",
         `${contentTypesDir}/${typeName}.json (${baseFieldCount} fields${extrasInfo})`
       );
-      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
+      this.logger.debug(`Content type "${typeName}" fields: ${merged.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
-        await this.fileSystem.writeFile(filePath, contentType);
+        await this.fileSystem.writeFile(filePath, merged);
+      }
+      if (isMerged) {
+        contentTypesMerged++;
+      } else {
+        contentTypesWritten++;
       }
-      contentTypesWritten++;
     }
     for (const [typeName, contentType] of targetContentTypeMap) {
       const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
+      const merged = await this.mergeWithExistingContentType(filePath, contentType);
+      const isMerged = merged !== contentType;
       this.logger.action(
         whatIf,
-        "WRITE",
-        `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
+        isMerged ? "MERGE" : "WRITE",
+        `${contentTypesDir}/${typeName}.json (${merged.fields.length} fields)`
       );
-      this.logger.debug(`Content type "${typeName}" fields: ${contentType.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
+      this.logger.debug(`Content type "${typeName}" fields: ${merged.fields.map((f) => `${f.id}:${f.type}`).join(", ")}`);
       if (!whatIf) {
-        await this.fileSystem.writeFile(filePath, contentType);
+        await this.fileSystem.writeFile(filePath, merged);
+      }
+      if (isMerged) {
+        contentTypesMerged++;
+      } else {
+        contentTypesWritten++;
       }
-      contentTypesWritten++;
     }
     const neverFoundMissingTypes = missingTargetTypes.filter(
       (type) => !foundMissingTargetTypes.has(type)
@@ -1204,7 +1225,7 @@ var CompositionConverterService = class {
         `Component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
       );
     }
-    return { contentTypesWritten, entriesFromCompositions, entriesFromReferences, entriesReused, blocksEmbedded };
+    return { contentTypesWritten, contentTypesMerged, entriesFromCompositions, entriesFromReferences, entriesReused, blocksEmbedded };
   }
   // --- Content Type Generation ---
   generateContentType(component) {
@@ -1237,6 +1258,37 @@ var CompositionConverterService = class {
     }
     return field;
   }
+  async mergeWithExistingContentType(filePath, generated) {
+    const exists = await this.fileSystem.fileExists(filePath);
+    if (!exists) {
+      return generated;
+    }
+    const existing = await this.fileSystem.readFile(filePath);
+    const existingFieldMap = /* @__PURE__ */ new Map();
+    for (const field of existing.fields) {
+      existingFieldMap.set(field.id, field);
+    }
+    for (const newField of generated.fields) {
+      const existingField = existingFieldMap.get(newField.id);
+      if (existingField && existingField.type !== newField.type) {
+        throw new ContentTypeFieldConflictError(
+          generated.id,
+          newField.id,
+          existingField.type,
+          newField.type
+        );
+      }
+    }
+    const generatedFieldIds = new Set(generated.fields.map((f) => f.id));
+    const extraFields = existing.fields.filter((f) => !generatedFieldIds.has(f.id));
+    if (extraFields.length === 0) {
+      return generated;
+    }
+    return {
+      ...generated,
+      fields: [...generated.fields, ...extraFields]
+    };
+  }
   // --- Entry Generation ---
   generateEntryFromComposition(composition) {
     const comp = composition.composition;
@@ -4843,9 +4895,10 @@ function createConvertCompositionsToEntriesCommand() {
       });
       const refInfo = result.entriesFromReferences > 0 ? `, ${result.entriesFromReferences} from references` : "";
       const reusedInfo = result.entriesReused > 0 ? `, ${result.entriesReused} reused existing` : "";
+      const mergedInfo = result.contentTypesMerged > 0 ? `, ${result.contentTypesMerged} merged` : "";
       const blocksInfo = result.blocksEmbedded > 0 ? `, ${result.blocksEmbedded} block(s) embedded` : "";
       logger.success(
-        `${result.contentTypesWritten} content type(s), ${result.entriesFromCompositions} entry(ies) from compositions${refInfo}${reusedInfo}${blocksInfo}`
+        `${result.contentTypesWritten} content type(s)${mergedInfo}, ${result.entriesFromCompositions} entry(ies) from compositions${refInfo}${reusedInfo}${blocksInfo}`
       );
     } catch (error) {
       if (error instanceof ComponentNotFoundError) {
@@ -7852,7 +7905,7 @@ function createClearSlotCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.55",
+  version: "1.1.56",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {