@uniformdev/transformer 1.1.34 → 1.1.35

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -1686,6 +1686,10 @@ function createPropagateRootComponentPropertyCommand() {
         `Modified ${result.modifiedComponents} component, ${result.modifiedCompositions} compositions`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -3215,6 +3219,10 @@ function createRenameSlotCommand() {
         `Renamed slot: ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -3492,6 +3500,10 @@ function createRenameComponentCommand() {
         `Renamed component: ${result.allowedComponentsUpdated} allowedComponents ref(s), ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -3603,16 +3615,7 @@ var ComponentAdderService = class {
       throw new TransformError("parentComponentType cannot be empty");
     }
     this.logger.info(`Validating new component: ${newComponentType}`);
-    try {
-      await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
-    } catch (error) {
-      if (error instanceof ComponentNotFoundError) {
-        throw new TransformError(
-          `Component type "${newComponentType}" not found in ${fullComponentsDir}`
-        );
-      }
-      throw error;
-    }
+    await this.componentService.loadComponent(fullComponentsDir, newComponentType, findOptions);
     let allowedComponentsUpdated = false;
     const resolvedParentTypes = [];
     for (const parentType of parentTypes) {
@@ -4042,6 +4045,10 @@ function createAddComponentCommand() {
         `Added component: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4097,6 +4104,10 @@ function createAddComponentPatternCommand() {
         `Added component pattern: ${result.allowedComponentsUpdated ? "1 component definition updated, " : ""}${result.instancesAdded} instance(s) added across ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s)`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4407,6 +4418,10 @@ function createPropagateRootComponentSlotCommand() {
         `Modified ${result.modifiedComponents} component(s), ${result.modifiedCompositions} composition(s)`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4484,6 +4499,10 @@ function createConvertCompositionsToEntriesCommand() {
         `${result.contentTypesWritten} content type(s), ${result.entriesFromCompositions} entry(ies) from compositions${refInfo}${reusedInfo}${blocksInfo}`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -4811,7 +4830,7 @@ function createRemoveParameterCommand() {
           aggregate.compositionPatternsModified += result.compositionPatternsModified;
           aggregate.componentPatternsModified += result.componentPatternsModified;
         } catch (error) {
-          if (hasWildcard && (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError)) {
+          if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
             logger.warn(error.message);
             continue;
           }
@@ -5254,6 +5273,10 @@ function createAddComponentParameterCommand() {
         `${result.parameterReplaced ? "Replaced" : "Added"} parameter "${options.parameterId}" on component "${options.componentId}"`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -5832,6 +5855,10 @@ function createFlattenBlockFieldCommand() {
         `Flattened parameter "${options.parameterId}" on component "${options.componentId}": ${result.compositionsModified} composition(s), ${result.compositionPatternsModified} composition pattern(s), ${result.componentPatternsModified} component pattern(s) updated`
       );
     } catch (error) {
+      if (error instanceof ComponentNotFoundError || error instanceof PropertyNotFoundError) {
+        logger.warn(error.message);
+        return;
+      }
       if (error instanceof TransformError) {
         logger.error(error.message);
         process.exit(1);
@@ -5842,10 +5869,171 @@ function createFlattenBlockFieldCommand() {
   return command;
 }
 
+// src/cli/commands/remove-orphan-entries.ts
+import { Command as Command16 } from "commander";
+
+// src/core/services/orphan-entry-remover.service.ts
+var OrphanEntryRemoverService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async remove(options) {
+    const { rootDir, entriesDir, rootContentTypes, whatIf, strict } = options;
+    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
+    const dirExists = await this.fileSystem.fileExists(entriesDirFull);
+    if (!dirExists) {
+      this.logger.warn(`Entries directory not found: ${entriesDir} \u2014 nothing to do`);
+      return { totalEntries: 0, whitelistedEntries: 0, removedEntries: 0 };
+    }
+    const entryFiles = await this.fileSystem.findFiles(entriesDirFull, "**/*.{json,yaml,yml}");
+    if (entryFiles.length === 0) {
+      this.logger.warn("No entry files found \u2014 nothing to do");
+      return { totalEntries: 0, whitelistedEntries: 0, removedEntries: 0 };
+    }
+    this.logger.info(`Loaded ${entryFiles.length} entry file(s)`);
+    const entryMap = /* @__PURE__ */ new Map();
+    for (const filePath of entryFiles) {
+      let entryData;
+      try {
+        entryData = await this.fileSystem.readFile(filePath);
+      } catch {
+        this.logger.warn(`Could not read entry file: ${filePath} \u2014 skipping`);
+        continue;
+      }
+      if (!entryData?.entry?._id) {
+        this.logger.warn(`Entry file missing entry._id: ${filePath} \u2014 skipping`);
+        continue;
+      }
+      entryMap.set(entryData.entry._id, { filePath, entryData });
+    }
+    this.logger.info(`Root content types: ${rootContentTypes.join(", ")}`);
+    const whitelist = /* @__PURE__ */ new Set();
+    for (const [entryId, { entryData }] of entryMap) {
+      if (this.matchesContentType(entryData.entry.type, rootContentTypes, strict)) {
+        whitelist.add(entryId);
+      }
+    }
+    this.logger.info(`Whitelisted ${whitelist.size} entry(ies) from root content types`);
+    let round = 0;
+    let frontier = [...whitelist];
+    while (frontier.length > 0) {
+      round++;
+      const nextFrontier = [];
+      for (const entryId of frontier) {
+        const entry = entryMap.get(entryId);
+        if (!entry) continue;
+        const referencedIds = this.extractReferencedEntryIds(entry.entryData);
+        for (const refId of referencedIds) {
+          if (!whitelist.has(refId) && entryMap.has(refId)) {
+            whitelist.add(refId);
+            nextFrontier.push(refId);
+          }
+        }
+      }
+      if (nextFrontier.length > 0) {
+        this.logger.info(`BFS round ${round}: added ${nextFrontier.length} entry(ies) via references`);
+      }
+      frontier = nextFrontier;
+    }
+    this.logger.info(`BFS stable after ${round} round(s)`);
+    let removedEntries = 0;
+    for (const [entryId, { filePath, entryData }] of entryMap) {
+      if (!whitelist.has(entryId)) {
+        const relPath = this.fileSystem.joinPath(entriesDir, this.fileSystem.getBasename(filePath));
+        this.logger.action(whatIf, "DELETE", `${relPath} (${entryData.entry.type})`);
+        if (!whatIf) {
+          this.fileSystem.deleteFile(filePath);
+        }
+        removedEntries++;
+      }
+    }
+    return {
+      totalEntries: entryMap.size,
+      whitelistedEntries: whitelist.size,
+      removedEntries
+    };
+  }
+  extractReferencedEntryIds(entryData) {
+    const ids = [];
+    if (entryData.entry._dataResources) {
+      for (const resource of Object.values(entryData.entry._dataResources)) {
+        if (resource.type === "uniformContentInternalReference" && resource.variables?.entryIds) {
+          const entryIds = resource.variables.entryIds.split(",").map((s) => s.trim()).filter(Boolean);
+          ids.push(...entryIds);
+        }
+      }
+    }
+    if (entryData.entry.fields) {
+      for (const field of Object.values(entryData.entry.fields)) {
+        if (field.type === "contentReference" && Array.isArray(field.value)) {
+          for (const id of field.value) {
+            if (typeof id === "string") {
+              ids.push(id);
+            }
+          }
+        }
+      }
+    }
+    return ids;
+  }
+  matchesContentType(entryType, rootContentTypes, strict) {
+    for (const rootType of rootContentTypes) {
+      if (strict) {
+        if (entryType === rootType) return true;
+      } else {
+        if (entryType.toLowerCase() === rootType.toLowerCase()) return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/cli/commands/remove-orphan-entries.ts
+function createRemoveOrphanEntriesCommand() {
+  const command = new Command16("remove-orphan-entries");
+  command.description(
+    "Removes entry files that are not reachable from root content-type entries by following contentReference links transitively."
+  ).option(
+    "--rootContentTypes <types>",
+    'Pipe-separated list of content-type IDs whose entries are treated as roots and never deleted (e.g. "HomePage|BlogPost")'
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [{ name: "rootContentTypes", flag: "--rootContentTypes" }];
+    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,
+      rootContentTypes: opts.rootContentTypes
+    };
+    const logger = new Logger();
+    logger.info(`rootContentTypes: ${options.rootContentTypes}`);
+    const rootContentTypes = options.rootContentTypes.split("|").map((t) => t.trim()).filter(Boolean);
+    const fileSystem = new FileSystemService();
+    const service = new OrphanEntryRemoverService(fileSystem, logger);
+    const result = await service.remove({
+      rootDir: options.rootDir,
+      entriesDir: options.entriesDir,
+      rootContentTypes,
+      whatIf: options.whatIf ?? false,
+      strict: options.strict ?? false
+    });
+    logger.success(
+      `Removed ${result.removedEntries} orphan entry(ies). ${result.whitelistedEntries} entry(ies) retained.`
+    );
+  });
+  return command;
+}
+
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.34",
+  version: "1.1.35",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -5914,7 +6102,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command16();
+var program = new Command17();
 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);
@@ -5942,5 +6130,6 @@ program.addCommand(createRemoveFieldCommand());
 program.addCommand(createAddComponentParameterCommand());
 program.addCommand(createAddContentTypeFieldCommand());
 program.addCommand(createFlattenBlockFieldCommand());
+program.addCommand(createRemoveOrphanEntriesCommand());
 program.parse();
 //# sourceMappingURL=index.js.map