@uniformdev/transformer 1.1.10 → 1.1.12

package/dist/cli/index.js

@@ -3634,6 +3634,8 @@ var CompositionConverterService = class {
       contentTypeMap.set(rootType, contentType);
     }
     const flattenContentTypeMap = /* @__PURE__ */ new Map();
+    const missingFlattenTypes = [];
+    const foundMissingFlattenTypes = /* @__PURE__ */ new Set();
     for (const flattenType of flattenComponentIds) {
       const isRootType = [...rootComponentTypes].some(
         (rt) => this.compareTypes(rt, flattenType, strict)
@@ -3651,57 +3653,13 @@ var CompositionConverterService = class {
         flattenContentTypeMap.set(flattenType, contentType);
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
-          throw new ComponentNotFoundError(flattenType, componentsDirFull);
+          this.logger.info(`Flatten component type not found: ${flattenType}`);
+          missingFlattenTypes.push(flattenType);
+          continue;
         }
         throw error;
       }
     }
-    if (flattenComponentIds.length > 0) {
-      for (const contentType of contentTypeMap.values()) {
-        for (const flattenType of flattenComponentIds) {
-          if (this.compareTypes(flattenType, contentType.id, strict)) {
-            continue;
-          }
-          contentType.fields.push({
-            id: flattenType,
-            name: flattenType,
-            type: "contentReference",
-            typeConfig: {
-              isMulti: true,
-              allowedContentTypes: [flattenType]
-            },
-            localizable: false
-          });
-        }
-      }
-    }
-    for (const [typeName, contentType] of contentTypeMap) {
-      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
-      const fieldCount = contentType.fields.filter((f) => f.type !== "contentReference").length;
-      const refCount = contentType.fields.filter((f) => f.type === "contentReference").length;
-      const refInfo = refCount > 0 ? ` + ${refCount} reference(s)` : "";
-      this.logger.action(
-        whatIf,
-        "WRITE",
-        `${contentTypesDir}/${typeName}.json (${fieldCount} fields${refInfo})`
-      );
-      if (!whatIf) {
-        await this.fileSystem.writeFile(filePath, contentType);
-      }
-      contentTypesWritten++;
-    }
-    for (const [typeName, contentType] of flattenContentTypeMap) {
-      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
-      this.logger.action(
-        whatIf,
-        "WRITE",
-        `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
-      );
-      if (!whatIf) {
-        await this.fileSystem.writeFile(filePath, contentType);
-      }
-      contentTypesWritten++;
-    }
     for (const { composition } of compositionResults) {
       const comp = composition.composition;
       const compositionId = comp._id;
@@ -3726,6 +3684,9 @@ var CompositionConverterService = class {
           );
           if (instances.length > 0) {
             flattenedByType.set(flattenType, instances);
+            if (missingFlattenTypes.includes(flattenType)) {
+              foundMissingFlattenTypes.add(flattenType);
+            }
           }
         }
       }
@@ -3735,6 +3696,9 @@ var CompositionConverterService = class {
           value: instances.map((inst) => inst.determinisiticId)
         };
       }
+      if (flattenComponentIds.length > 0) {
+        this.transformContentReferences(entry);
+      }
       const entryFilePath = this.fileSystem.joinPath(entriesDirFull, `${compositionId}.json`);
       this.logger.action(
         whatIf,
@@ -3764,6 +3728,63 @@ var CompositionConverterService = class {
         }
       }
     }
+    if (flattenComponentIds.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const flattenType of flattenComponentIds) {
+          if (this.compareTypes(flattenType, contentType.id, strict)) {
+            continue;
+          }
+          if (missingFlattenTypes.includes(flattenType) && !foundMissingFlattenTypes.has(flattenType)) {
+            continue;
+          }
+          contentType.fields.push({
+            id: flattenType,
+            name: flattenType,
+            type: "contentReference",
+            typeConfig: {
+              isMulti: true,
+              allowedContentTypes: [flattenType]
+            },
+            localizable: false
+          });
+        }
+      }
+    }
+    for (const [typeName, contentType] of contentTypeMap) {
+      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
+      const fieldCount = contentType.fields.filter((f) => f.type !== "contentReference").length;
+      const refCount = contentType.fields.filter((f) => f.type === "contentReference").length;
+      const refInfo = refCount > 0 ? ` + ${refCount} reference(s)` : "";
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${contentTypesDir}/${typeName}.json (${fieldCount} fields${refInfo})`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(filePath, contentType);
+      }
+      contentTypesWritten++;
+    }
+    for (const [typeName, contentType] of flattenContentTypeMap) {
+      const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${contentTypesDir}/${typeName}.json (${contentType.fields.length} fields)`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(filePath, contentType);
+      }
+      contentTypesWritten++;
+    }
+    const neverFoundMissingTypes = missingFlattenTypes.filter(
+      (type) => !foundMissingFlattenTypes.has(type)
+    );
+    if (neverFoundMissingTypes.length > 0) {
+      this.logger.warn(
+        `Flatten component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
+      );
+    }
     return { contentTypesWritten, entriesFromCompositions, entriesFromFlattened };
   }
   // --- Content Type Generation ---
@@ -3800,13 +3821,29 @@ var CompositionConverterService = class {
   // --- Entry Generation ---
   generateEntryFromComposition(composition) {
     const comp = composition.composition;
+    const compositionSpecificKeys = /* @__PURE__ */ new Set(["_id", "_name", "type", "parameters", "slots", "_overrides"]);
+    const extraRootProps = {};
+    for (const [key, value] of Object.entries(comp)) {
+      if (!compositionSpecificKeys.has(key) && value != null) {
+        extraRootProps[key] = value;
+      }
+    }
+    const wrapperKeys = /* @__PURE__ */ new Set(["composition"]);
+    const extraWrapperProps = {};
+    for (const [key, value] of Object.entries(composition)) {
+      if (!wrapperKeys.has(key) && value != null) {
+        extraWrapperProps[key] = value;
+      }
+    }
     return {
       entry: {
         _id: comp._id,
         _name: comp._name ?? comp._id,
         type: comp.type,
-        fields: { ...comp.parameters ?? {} }
-      }
+        fields: { ...comp.parameters ?? {} },
+        ...extraRootProps
+      },
+      ...extraWrapperProps
     };
   }
   generateEntryFromFlattenedInstance(inst) {
@@ -3860,6 +3897,30 @@ var CompositionConverterService = class {
       }
     }
   }
+  // --- Content Reference Transformation ---
+  transformContentReferences(entry) {
+    const dataResources = {};
+    for (const [fieldName, field] of Object.entries(entry.entry.fields)) {
+      if (field.type === "contentReference" && Array.isArray(field.value)) {
+        const entryIds = field.value;
+        const resourceKey = `ref-${entry.entry._id}-${fieldName}`;
+        field.value = `\${#jptr:/${resourceKey}/entries}`;
+        dataResources[resourceKey] = {
+          type: "uniformContentInternalReference",
+          variables: {
+            locale: "${locale}",
+            entryIds: entryIds.join(",")
+          }
+        };
+      }
+    }
+    if (Object.keys(dataResources).length > 0) {
+      entry.entry._dataResources = {
+        ...entry.entry._dataResources ?? {},
+        ...dataResources
+      };
+    }
+  }
   // --- Utilities ---
   compareTypes(type1, type2, strict) {
     if (strict) {
@@ -3992,7 +4053,7 @@ function createConvertCompositionsToEntriesCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.10",
+  version: "1.1.12",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {