@uniformdev/transformer 1.1.9 → 1.1.11

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -3574,10 +3574,443 @@ function createPropagateRootComponentSlotCommand() {
   return command;
 }
 
+// src/cli/commands/convert-compositions-to-entries.ts
+import { Command as Command10 } from "commander";
+
+// src/core/services/composition-converter.service.ts
+import * as crypto from "crypto";
+var CompositionConverterService = class {
+  constructor(fileSystem, componentService, compositionService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.compositionService = compositionService;
+    this.logger = logger;
+  }
+  async convert(options) {
+    const {
+      rootDir,
+      compositionsDir,
+      componentsDir,
+      contentTypesDir,
+      entriesDir,
+      compositionTypes,
+      flattenComponentIds,
+      whatIf,
+      strict
+    } = options;
+    const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
+    const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
+    const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
+    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
+    let contentTypesWritten = 0;
+    let entriesFromCompositions = 0;
+    let entriesFromFlattened = 0;
+    this.logger.info(`Composition types: ${compositionTypes.join(", ")}`);
+    if (flattenComponentIds.length > 0) {
+      this.logger.info(`Flatten component types: ${flattenComponentIds.join(", ")}`);
+    }
+    const compositionResults = await this.compositionService.findCompositionsByTypes(
+      compositionsDirFull,
+      compositionTypes,
+      { strict }
+    );
+    if (compositionResults.length === 0) {
+      this.logger.warn("No compositions found matching the specified types");
+      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromFlattened: 0 };
+    }
+    this.logger.info(`Found ${compositionResults.length} composition(s)`);
+    const rootComponentTypes = /* @__PURE__ */ new Set();
+    for (const { composition } of compositionResults) {
+      rootComponentTypes.add(composition.composition.type);
+    }
+    const contentTypeMap = /* @__PURE__ */ new Map();
+    for (const rootType of rootComponentTypes) {
+      const { component } = await this.componentService.loadComponent(
+        componentsDirFull,
+        rootType,
+        { strict }
+      );
+      const contentType = this.generateContentType(component);
+      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)
+      );
+      if (isRootType) {
+        continue;
+      }
+      try {
+        const { component } = await this.componentService.loadComponent(
+          componentsDirFull,
+          flattenType,
+          { strict }
+        );
+        const contentType = this.generateContentType(component);
+        flattenContentTypeMap.set(flattenType, contentType);
+      } catch (error) {
+        if (error instanceof ComponentNotFoundError) {
+          this.logger.info(`Flatten component type not found: ${flattenType}`);
+          missingFlattenTypes.push(flattenType);
+          continue;
+        }
+        throw error;
+      }
+    }
+    for (const { composition } of compositionResults) {
+      const comp = composition.composition;
+      const compositionId = comp._id;
+      const compositionName = comp._name ?? compositionId;
+      const compositionType = comp.type;
+      const entry = this.generateEntryFromComposition(composition);
+      const flattenedByType = /* @__PURE__ */ new Map();
+      if (flattenComponentIds.length > 0 && comp.slots) {
+        for (const flattenType of flattenComponentIds) {
+          if (this.compareTypes(flattenType, compositionType, strict)) {
+            this.logger.warn(
+              `Skipping flatten of "${flattenType}" \u2014 same as root component type`
+            );
+            continue;
+          }
+          const instances = this.findFlattenTargets(
+            comp.slots,
+            flattenType,
+            compositionId,
+            compositionName,
+            strict
+          );
+          if (instances.length > 0) {
+            flattenedByType.set(flattenType, instances);
+            if (missingFlattenTypes.includes(flattenType)) {
+              foundMissingFlattenTypes.add(flattenType);
+            }
+          }
+        }
+      }
+      for (const [flattenType, instances] of flattenedByType) {
+        entry.entry.fields[flattenType] = {
+          type: "contentReference",
+          value: instances.map((inst) => inst.determinisiticId)
+        };
+      }
+      const entryFilePath = this.fileSystem.joinPath(entriesDirFull, `${compositionId}.json`);
+      this.logger.action(
+        whatIf,
+        "WRITE",
+        `${entriesDir}/${compositionId}.json (${compositionType}, "${this.truncate(compositionName, 50)}")`
+      );
+      if (!whatIf) {
+        await this.fileSystem.writeFile(entryFilePath, entry);
+      }
+      entriesFromCompositions++;
+      for (const [flattenType, instances] of flattenedByType) {
+        for (const inst of instances) {
+          const flatEntry = this.generateEntryFromFlattenedInstance(inst);
+          const flatEntryPath = this.fileSystem.joinPath(
+            entriesDirFull,
+            `${inst.determinisiticId}.json`
+          );
+          this.logger.action(
+            whatIf,
+            "WRITE",
+            `${entriesDir}/${inst.determinisiticId}.json (${flattenType} from "${this.truncate(compositionName, 50)}")`
+          );
+          if (!whatIf) {
+            await this.fileSystem.writeFile(flatEntryPath, flatEntry);
+          }
+          entriesFromFlattened++;
+        }
+      }
+    }
+    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 ---
+  generateContentType(component) {
+    const fields = [];
+    if (component.parameters) {
+      for (const param of component.parameters) {
+        fields.push(this.parameterToField(param));
+      }
+    }
+    return {
+      id: component.id,
+      name: component.name,
+      fields
+    };
+  }
+  parameterToField(param) {
+    const field = {
+      id: param.id,
+      name: param.name,
+      type: param.type
+    };
+    if (param.helpText !== void 0) {
+      field.helpText = param.helpText;
+    }
+    if (param.localizable !== void 0) {
+      field.localizable = param.localizable;
+    }
+    if (param.typeConfig !== void 0) {
+      field.typeConfig = param.typeConfig;
+    }
+    return field;
+  }
+  // --- Entry Generation ---
+  generateEntryFromComposition(composition) {
+    const comp = composition.composition;
+    return {
+      entry: {
+        _id: comp._id,
+        _name: comp._name ?? comp._id,
+        type: comp.type,
+        fields: { ...comp.parameters ?? {} }
+      }
+    };
+  }
+  generateEntryFromFlattenedInstance(inst) {
+    return {
+      entry: {
+        _id: inst.determinisiticId,
+        _name: `${inst.componentType} (from ${inst.compositionName})`,
+        type: inst.componentType,
+        fields: { ...inst.instance.parameters ?? {} }
+      }
+    };
+  }
+  // --- Flatten Tree Walking ---
+  findFlattenTargets(slots, targetType, compositionId, compositionName, strict) {
+    const results = [];
+    this.walkSlots(slots, targetType, compositionId, compositionName, "", results, strict);
+    return results;
+  }
+  walkSlots(slots, targetType, compositionId, compositionName, pathPrefix, results, strict) {
+    for (const [slotName, instances] of Object.entries(slots)) {
+      if (!Array.isArray(instances)) continue;
+      for (let i = 0; i < instances.length; i++) {
+        const instance = instances[i];
+        if (instance._pattern) {
+          continue;
+        }
+        const currentPath = pathPrefix ? `${pathPrefix}-${slotName}-[${i}]-${instance.type}` : `${slotName}-[${i}]-${instance.type}`;
+        if (this.compareTypes(instance.type, targetType, strict)) {
+          const fullPath = `${compositionId}-${currentPath}`;
+          const deterministicId = computeGuidHash(fullPath);
+          results.push({
+            instance,
+            path: fullPath,
+            determinisiticId: deterministicId,
+            componentType: instance.type,
+            compositionId,
+            compositionName
+          });
+        }
+        if (instance.slots) {
+          this.walkSlots(
+            instance.slots,
+            targetType,
+            compositionId,
+            compositionName,
+            currentPath,
+            results,
+            strict
+          );
+        }
+      }
+    }
+  }
+  // --- Utilities ---
+  compareTypes(type1, type2, strict) {
+    if (strict) {
+      return type1 === type2;
+    }
+    return type1.toLowerCase() === type2.toLowerCase();
+  }
+  truncate(str, maxLength) {
+    if (str.length <= maxLength) return str;
+    return str.substring(0, maxLength - 3) + "...";
+  }
+};
+function computeGuidHash(guidOrSeed) {
+  let uuidStr;
+  if (isValidUuid(guidOrSeed)) {
+    uuidStr = formatAsBracedUuid(guidOrSeed);
+  } else {
+    const hash = crypto.createHash("md5").update(guidOrSeed, "utf-8").digest();
+    const hex = [
+      // First 4 bytes: little-endian in .NET Guid
+      hash[3].toString(16).padStart(2, "0"),
+      hash[2].toString(16).padStart(2, "0"),
+      hash[1].toString(16).padStart(2, "0"),
+      hash[0].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 4-5: little-endian
+      hash[5].toString(16).padStart(2, "0"),
+      hash[4].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 6-7: little-endian
+      hash[7].toString(16).padStart(2, "0"),
+      hash[6].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 8-9: big-endian
+      hash[8].toString(16).padStart(2, "0"),
+      hash[9].toString(16).padStart(2, "0"),
+      "-",
+      // Bytes 10-15: big-endian
+      hash[10].toString(16).padStart(2, "0"),
+      hash[11].toString(16).padStart(2, "0"),
+      hash[12].toString(16).padStart(2, "0"),
+      hash[13].toString(16).padStart(2, "0"),
+      hash[14].toString(16).padStart(2, "0"),
+      hash[15].toString(16).padStart(2, "0")
+    ].join("");
+    uuidStr = `{${hex}}`.toUpperCase();
+  }
+  const chars = uuidStr.split("");
+  chars[15] = "4";
+  const arr20 = ["8", "9", "A", "B"];
+  const hexVal = parseInt(chars[20], 16);
+  chars[20] = arr20[hexVal % 4];
+  return chars.join("").slice(1, -1).toLowerCase();
+}
+function isValidUuid(str) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(str);
+}
+function formatAsBracedUuid(uuid) {
+  const clean = uuid.replace(/[{}]/g, "").toUpperCase();
+  return `{${clean}}`;
+}
+
+// src/cli/commands/convert-compositions-to-entries.ts
+function createConvertCompositionsToEntriesCommand() {
+  const command = new Command10("convert-compositions-to-entries");
+  command.description(
+    "Converts compositions into content entries, optionally flattening nested components into separate referenced entries."
+  ).option(
+    "--compositionTypes <types>",
+    "Pipe-separated list of composition types to convert (e.g., ProductDetailPage|ArticlePage)"
+  ).option(
+    "--flattenComponentIds <types>",
+    "Pipe-separated list of component types to flatten into separate entries (e.g., DetailHero|ArticleDetail)"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "compositionTypes", flag: "--compositionTypes" }
+    ];
+    const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
+    if (missing.length > 0) {
+      console.error(`error: missing required options: ${missing.join(", ")}`);
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      compositionTypes: opts.compositionTypes,
+      flattenComponentIds: opts.flattenComponentIds
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const compositionService = new CompositionService(fileSystem);
+    const converter = new CompositionConverterService(
+      fileSystem,
+      componentService,
+      compositionService,
+      logger
+    );
+    try {
+      const compositionTypes = options.compositionTypes.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
+      const flattenComponentIds = options.flattenComponentIds ? options.flattenComponentIds.split("|").map((t) => t.trim()).filter((t) => t.length > 0) : [];
+      const result = await converter.convert({
+        rootDir: options.rootDir,
+        compositionsDir: options.compositionsDir,
+        componentsDir: options.componentsDir,
+        contentTypesDir: options.contentTypesDir,
+        entriesDir: options.entriesDir,
+        compositionTypes,
+        flattenComponentIds,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      const flatInfo = result.entriesFromFlattened > 0 ? `, ${result.entriesFromFlattened} from flattened components` : "";
+      logger.success(
+        `${result.contentTypesWritten} content type(s), ${result.entriesFromCompositions} entry(ies) from compositions${flatInfo}`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.9",
+  version: "1.1.11",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -3646,7 +4079,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command10();
+var program = new Command11();
 var appVersion = package_default.version;
 console.error(`uniform-transform v${appVersion}`);
 program.name("uniform-transform").description("CLI tool for transforming Uniform.dev serialization files offline").version(appVersion);
@@ -3668,5 +4101,6 @@ program.addCommand(createRenameComponentCommand());
 program.addCommand(createAddComponentCommand());
 program.addCommand(createAddComponentPatternCommand());
 program.addCommand(createPropagateRootComponentSlotCommand());
+program.addCommand(createConvertCompositionsToEntriesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map