@uniformdev/transformer 1.1.9 → 1.1.10

package/dist/index.d.ts

@@ -128,6 +128,10 @@ interface PropagateRootComponentSlotOptions extends GlobalOptions {
     targetSlot: string;
     deleteSourceSlot?: boolean;
 }
+interface ConvertCompositionsToEntriesOptions extends GlobalOptions {
+    compositionTypes: string;
+    flattenComponentIds?: string;
+}
 
 declare class TransformError extends Error {
     constructor(message: string);
@@ -389,4 +393,77 @@ declare class ComponentAdderService {
     private addComponentToNestedSlots;
 }
 
-export { type AddComponentOptions, type AddComponentPatternOptions, ComponentAdderService, ComponentAlreadyExistsError, type ComponentDefinition, type ComponentInstance, ComponentNotFoundError, ComponentRenamerService, ComponentService, type Composition, type CompositionOverrides, type CompositionPatternCandidatesOptions, type CompositionRoot, CompositionService, DuplicateIdError, FileNotFoundError, FileSystemService, type GlobalOptions, InvalidYamlError, Logger, type PackSerializationOptions, type Parameter, type ParameterValue, type PropagateRootComponentPropertyOptions, type PropagateRootComponentSlotOptions, PropertyNotFoundError, PropertyPropagatorService, type RenameComponentOptions, type RenameSlotOptions, SlotAlreadyExistsError, type SlotDefinition, SlotNotFoundError, SlotRenamerService, TransformError, type UnpackSerializationOptions };
+interface ConvertCompositionsToEntriesInternalOptions {
+    rootDir: string;
+    compositionsDir: string;
+    componentsDir: string;
+    contentTypesDir: string;
+    entriesDir: string;
+    compositionTypes: string[];
+    flattenComponentIds: string[];
+    whatIf: boolean;
+    strict: boolean;
+}
+interface ContentTypeDefinition {
+    id: string;
+    name: string;
+    fields: ContentTypeField[];
+}
+interface ContentTypeField {
+    id: string;
+    name: string;
+    type: string;
+    helpText?: string;
+    localizable?: boolean;
+    typeConfig?: Record<string, unknown>;
+}
+interface EntryDefinition {
+    entry: {
+        _id: string;
+        _name: string;
+        type: string;
+        fields: Record<string, ParameterValue>;
+    };
+}
+interface FlattenedInstance {
+    instance: ComponentInstance;
+    path: string;
+    determinisiticId: string;
+    componentType: string;
+    compositionId: string;
+    compositionName: string;
+}
+interface ConvertResult {
+    contentTypesWritten: number;
+    entriesFromCompositions: number;
+    entriesFromFlattened: number;
+}
+declare class CompositionConverterService {
+    private fileSystem;
+    private componentService;
+    private compositionService;
+    private logger;
+    constructor(fileSystem: FileSystemService, componentService: ComponentService, compositionService: CompositionService, logger: Logger);
+    convert(options: ConvertCompositionsToEntriesInternalOptions): Promise<ConvertResult>;
+    generateContentType(component: ComponentDefinition): ContentTypeDefinition;
+    private parameterToField;
+    generateEntryFromComposition(composition: Composition): EntryDefinition;
+    generateEntryFromFlattenedInstance(inst: FlattenedInstance): EntryDefinition;
+    findFlattenTargets(slots: Record<string, ComponentInstance[]>, targetType: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
+    private walkSlots;
+    private compareTypes;
+    private truncate;
+}
+/**
+ * Computes a deterministic UUID v4 from a string seed.
+ * This is a TypeScript port of the C# ComputeGuidHash method.
+ *
+ * Algorithm:
+ * 1. If the input is already a valid UUID, parse it; otherwise MD5 hash the string
+ * 2. Format as UUID
+ * 3. Force position 15 to '4' (UUID v4 version nibble)
+ * 4. Force position 20 to one of '8','9','A','B' (UUID v4 variant)
+ */
+declare function computeGuidHash(guidOrSeed: string): string;
+
+export { type AddComponentOptions, type AddComponentPatternOptions, ComponentAdderService, ComponentAlreadyExistsError, type ComponentDefinition, type ComponentInstance, ComponentNotFoundError, ComponentRenamerService, ComponentService, type Composition, CompositionConverterService, type CompositionOverrides, type CompositionPatternCandidatesOptions, type CompositionRoot, CompositionService, type ConvertCompositionsToEntriesOptions, DuplicateIdError, FileNotFoundError, FileSystemService, type GlobalOptions, InvalidYamlError, Logger, type PackSerializationOptions, type Parameter, type ParameterValue, type PropagateRootComponentPropertyOptions, type PropagateRootComponentSlotOptions, PropertyNotFoundError, PropertyPropagatorService, type RenameComponentOptions, type RenameSlotOptions, SlotAlreadyExistsError, type SlotDefinition, SlotNotFoundError, SlotRenamerService, TransformError, type UnpackSerializationOptions, computeGuidHash };

package/dist/index.js

@@ -1648,6 +1648,351 @@ var ComponentAdderService = class {
   }
 };
 
+// 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();
+    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) {
+          throw new ComponentNotFoundError(flattenType, componentsDirFull);
+        }
+        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;
+      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);
+          }
+        }
+      }
+      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++;
+        }
+      }
+    }
+    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/logger.ts
 import chalk from "chalk";
 var Logger = class {
@@ -1677,6 +2022,7 @@ export {
   ComponentNotFoundError,
   ComponentRenamerService,
   ComponentService,
+  CompositionConverterService,
   CompositionService,
   DuplicateIdError,
   FileNotFoundError,
@@ -1688,6 +2034,7 @@ export {
   SlotAlreadyExistsError,
   SlotNotFoundError,
   SlotRenamerService,
-  TransformError
+  TransformError,
+  computeGuidHash
 };
 //# sourceMappingURL=index.js.map