@uniformdev/transformer 1.1.10 → 1.1.12

package/dist/index.d.ts

@@ -417,13 +417,20 @@ interface ContentTypeField {
     localizable?: boolean;
     typeConfig?: Record<string, unknown>;
 }
+interface DataResourceDefinition {
+    type: string;
+    variables?: Record<string, string>;
+}
 interface EntryDefinition {
     entry: {
         _id: string;
         _name: string;
         type: string;
         fields: Record<string, ParameterValue>;
+        _dataResources?: Record<string, DataResourceDefinition>;
+        [key: string]: unknown;
     };
+    [key: string]: unknown;
 }
 interface FlattenedInstance {
     instance: ComponentInstance;
@@ -451,6 +458,7 @@ declare class CompositionConverterService {
     generateEntryFromFlattenedInstance(inst: FlattenedInstance): EntryDefinition;
     findFlattenTargets(slots: Record<string, ComponentInstance[]>, targetType: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
     private walkSlots;
+    private transformContentReferences;
     private compareTypes;
     private truncate;
 }

package/dist/index.js

@@ -1705,6 +1705,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)
@@ -1722,57 +1724,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;
@@ -1797,6 +1755,9 @@ var CompositionConverterService = class {
           );
           if (instances.length > 0) {
             flattenedByType.set(flattenType, instances);
+            if (missingFlattenTypes.includes(flattenType)) {
+              foundMissingFlattenTypes.add(flattenType);
+            }
           }
         }
       }
@@ -1806,6 +1767,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,
@@ -1835,6 +1799,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 ---
@@ -1871,13 +1892,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) {
@@ -1931,6 +1968,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) {