@uniformdev/transformer 1.1.41 → 1.1.43

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -6829,7 +6829,7 @@ var GenerateMissingProjectMapNodesService = class {
     this.logger = logger;
   }
   async generate(options) {
-    const { rootDir, projectMapNodesDir, compositionsDir, rootContentTypes, whatIf, strict } = options;
+    const { rootDir, projectMapNodesDir, whatIf } = options;
     const nodesDirFull = this.fileSystem.resolvePath(rootDir, projectMapNodesDir);
     const nodesDirExists = await this.fileSystem.fileExists(nodesDirFull);
     if (!nodesDirExists) {
@@ -6858,41 +6858,8 @@ var GenerateMissingProjectMapNodesService = class {
       allNodes.push({ filePath, node });
     }
     const existingPaths = new Set(allNodes.map(({ node }) => node.path));
-    const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    const compositionIdToType = /* @__PURE__ */ new Map();
-    const compositionsDirExists = await this.fileSystem.fileExists(compositionsDirFull);
-    if (!compositionsDirExists) {
-      this.logger.warn(`Compositions directory not found: ${compositionsDir} \u2014 no source nodes will match`);
-    } else {
-      const compositionFiles = await this.fileSystem.findFiles(
-        compositionsDirFull,
-        "**/*.{json,yaml,yml}"
-      );
-      for (const filePath of compositionFiles) {
-        let comp;
-        try {
-          comp = await this.fileSystem.readFile(filePath);
-        } catch {
-          this.logger.warn(`Could not read composition file: ${filePath} \u2014 skipping`);
-          continue;
-        }
-        if (comp?.composition?._id && comp?.composition?.type) {
-          compositionIdToType.set(comp.composition._id, comp.composition.type);
-        }
-      }
-    }
-    const sourceNodes = allNodes.filter(({ node }) => {
-      if (!node.compositionId) return false;
-      const rootType = compositionIdToType.get(node.compositionId);
-      if (!rootType) {
-        this.logger.warn(
-          `No composition found for compositionId "${node.compositionId}" (node path: ${node.path}) \u2014 skipping`
-        );
-        return false;
-      }
-      return this.matchesContentType(rootType, rootContentTypes, strict);
-    });
-    this.logger.info(`${sourceNodes.length} node(s) match root content types`);
+    const sourceNodes = allNodes.filter(({ node }) => !!node.compositionId);
+    this.logger.info(`${sourceNodes.length} node(s) selected as sources`);
     const ancestorPaths = /* @__PURE__ */ new Set();
     for (const { node } of sourceNodes) {
       for (const ancestor of this.computeAncestorPaths(node.path)) {
@@ -6949,29 +6916,192 @@ var GenerateMissingProjectMapNodesService = class {
     const slug = nodePath.split("/").filter((s) => s.length > 0).join("-");
     return `${slug}-node.yaml`;
   }
-  matchesContentType(rootType, rootContentTypes, strict) {
-    for (const ct of rootContentTypes) {
-      if (strict) {
-        if (rootType === ct) return true;
-      } else {
-        if (rootType.toLowerCase() === ct.toLowerCase()) return true;
-      }
-    }
-    return false;
-  }
 };
 
 // src/cli/commands/generate-missing-project-map-nodes.ts
 function createGenerateMissingProjectMapNodesCommand() {
   const command = new Command19("generate-missing-project-map-nodes");
   command.description(
-    "Creates group project map nodes for ancestor path segments that are missing from the project map. Only paths reachable from compositions whose root type matches --rootContentTypes are considered."
-  ).option(
-    "--rootContentTypes <types>",
-    'Pipe-separated list of root component types identifying the leaf-page compositions whose ancestor paths should be filled in (e.g. "BlogPost|NewsArticle")'
-  ).hook("preAction", (thisCommand) => {
+    "Creates group project map nodes for ancestor path segments that are missing from the project map. All project map nodes with a compositionId are used as sources."
+  ).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const service = new GenerateMissingProjectMapNodesService(fileSystem, logger);
+    const result = await service.generate({
+      rootDir: options.rootDir,
+      projectMapNodesDir: options.projectMapNodesDir,
+      whatIf: options.whatIf ?? false
+    });
+    logger.success(
+      `Created ${result.generatedCount} missing project map node(s). ${result.alreadyCoveredCount} ancestor path(s) already existed.`
+    );
+  });
+  return command;
+}
+
+// src/cli/commands/split-content-type.ts
+import { Command as Command20 } from "commander";
+
+// src/core/services/content-type-splitter.service.ts
+var ContentTypeSplitterService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async split(options) {
+    const {
+      rootDir,
+      contentTypesDir,
+      entriesDir,
+      contentType,
+      newContentType,
+      fieldId,
+      fieldContains,
+      whatIf,
+      strict
+    } = options;
+    const ctDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
+    const ctDirExists = await this.fileSystem.fileExists(ctDirFull);
+    if (!ctDirExists) {
+      this.logger.warn(`Content types directory not found: ${contentTypesDir}`);
+      return { contentTypeCreated: false, entriesScanned: 0, entriesUpdated: 0 };
+    }
+    const ctFiles = await this.fileSystem.findFiles(ctDirFull, "**/*.{json,yaml,yml}");
+    let sourceCtFilePath;
+    let sourceCt;
+    let newCtExists = false;
+    for (const filePath of ctFiles) {
+      let ct;
+      try {
+        ct = await this.fileSystem.readFile(filePath);
+      } catch {
+        this.logger.warn(`Could not read content type file: ${filePath} \u2014 skipping`);
+        continue;
+      }
+      if (!ct?.id) continue;
+      if (this.matchesId(ct.id, contentType, strict)) {
+        sourceCtFilePath = filePath;
+        sourceCt = ct;
+      }
+      if (this.matchesId(ct.id, newContentType, strict)) {
+        newCtExists = true;
+      }
+    }
+    if (!sourceCtFilePath || !sourceCt) {
+      this.logger.warn(`Content type "${contentType}" not found in ${contentTypesDir}`);
+      return { contentTypeCreated: false, entriesScanned: 0, entriesUpdated: 0 };
+    }
+    let contentTypeCreated = false;
+    if (newCtExists) {
+      this.logger.info(`Content type "${newContentType}" already exists \u2014 skipping creation`);
+    } else {
+      const newCt = {
+        ...sourceCt,
+        id: newContentType,
+        name: newContentType
+      };
+      const ext = this.fileSystem.getExtension(sourceCtFilePath) || ".yaml";
+      const newCtFilePath = this.fileSystem.resolvePath(ctDirFull, `${newContentType}${ext}`);
+      const relPath = `${contentTypesDir}/${newContentType}${ext}`;
+      this.logger.action(whatIf, "CREATE", relPath);
+      if (!whatIf) {
+        await this.fileSystem.writeFile(newCtFilePath, newCt);
+      }
+      contentTypeCreated = true;
+    }
+    const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
+    const entriesDirExists = await this.fileSystem.fileExists(entriesDirFull);
+    if (!entriesDirExists) {
+      this.logger.warn(`Entries directory not found: ${entriesDir}`);
+      return { contentTypeCreated, entriesScanned: 0, entriesUpdated: 0 };
+    }
+    const entryFiles = await this.fileSystem.findFiles(entriesDirFull, "**/*.{json,yaml,yml}");
+    this.logger.info(`Scanning ${entryFiles.length} entry file(s)`);
+    let entriesScanned = 0;
+    let entriesUpdated = 0;
+    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?.type) continue;
+      if (!this.matchesId(entryData.entry.type, contentType, strict)) continue;
+      entriesScanned++;
+      const fields = entryData.entry.fields;
+      if (!fields || typeof fields !== "object") {
+        this.logger.warn(`Entry "${entryData.entry._id}" has no fields \u2014 skipping`);
+        continue;
+      }
+      if (!(fieldId in fields)) {
+        this.logger.warn(
+          `Entry "${entryData.entry._id}" does not have field "${fieldId}" \u2014 skipping`
+        );
+        continue;
+      }
+      const field = fields[fieldId];
+      const fieldValueStr = this.getFieldValueString(field);
+      if (!this.containsValue(fieldValueStr, fieldContains, strict)) continue;
+      const relPath = this.fileSystem.joinPath(
+        entriesDir,
+        this.fileSystem.getBasename(filePath)
+      );
+      this.logger.action(
+        whatIf,
+        "UPDATE",
+        `${relPath}: type ${entryData.entry.type} \u2192 ${newContentType}`
+      );
+      if (!whatIf) {
+        const updatedEntry = {
+          ...entryData,
+          entry: { ...entryData.entry, type: newContentType }
+        };
+        await this.fileSystem.writeFile(filePath, updatedEntry);
+      }
+      entriesUpdated++;
+    }
+    return { contentTypeCreated, entriesScanned, entriesUpdated };
+  }
+  matchesId(value, target, strict) {
+    if (strict) return value === target;
+    return value.toLowerCase() === target.toLowerCase();
+  }
+  containsValue(haystack, needle, strict) {
+    if (strict) return haystack.includes(needle);
+    return haystack.toLowerCase().includes(needle.toLowerCase());
+  }
+  getFieldValueString(field) {
+    if (field === null || field === void 0) return "";
+    if (typeof field === "string") return field;
+    if (typeof field === "number" || typeof field === "boolean") return String(field);
+    if (typeof field === "object") {
+      const f = field;
+      if (f.value !== void 0) return String(f.value);
+      return JSON.stringify(f);
+    }
+    return String(field);
+  }
+};
+
+// src/cli/commands/split-content-type.ts
+function createSplitContentTypeCommand() {
+  const command = new Command20("split-content-type");
+  command.description(
+    "Creates a new content type as a copy of an existing one, then reassigns matching entries to it."
+  ).option("--contentType <type>", "Source content type ID to split").option("--newContentType <type>", "New content type ID to create").option("--fieldId <id>", "Field ID in entry.fields whose value is checked").option("--fieldContains <value>", "Substring to search for in the field value").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
-    const requiredOptions = [{ name: "rootContentTypes", flag: "--rootContentTypes" }];
+    const requiredOptions = [
+      { name: "contentType", flag: "--contentType" },
+      { name: "newContentType", flag: "--newContentType" },
+      { name: "fieldId", flag: "--fieldId" },
+      { name: "fieldContains", flag: "--fieldContains" }
+    ];
     const missing = requiredOptions.filter((opt) => !opts[opt.name]).map((opt) => opt.flag);
     if (missing.length > 0) {
       console.error(`error: missing required options: ${missing.join(", ")}`);
@@ -6981,23 +7111,31 @@ function createGenerateMissingProjectMapNodesCommand() {
     const globalOpts = cmd.optsWithGlobals();
     const options = {
       ...globalOpts,
-      rootContentTypes: opts.rootContentTypes
+      contentType: opts.contentType,
+      newContentType: opts.newContentType,
+      fieldId: opts.fieldId,
+      fieldContains: opts.fieldContains
     };
     const logger = new Logger();
-    logger.info(`rootContentTypes: ${options.rootContentTypes}`);
-    const rootContentTypes = splitList(options.rootContentTypes);
+    logger.info(`contentType: ${options.contentType}`);
+    logger.info(`newContentType: ${options.newContentType}`);
+    logger.info(`fieldId: ${options.fieldId}`);
+    logger.info(`fieldContains: ${options.fieldContains}`);
     const fileSystem = new FileSystemService();
-    const service = new GenerateMissingProjectMapNodesService(fileSystem, logger);
-    const result = await service.generate({
+    const service = new ContentTypeSplitterService(fileSystem, logger);
+    const result = await service.split({
       rootDir: options.rootDir,
-      projectMapNodesDir: options.projectMapNodesDir,
-      compositionsDir: options.compositionsDir,
-      rootContentTypes,
+      contentTypesDir: options.contentTypesDir,
+      entriesDir: options.entriesDir,
+      contentType: options.contentType,
+      newContentType: options.newContentType,
+      fieldId: options.fieldId,
+      fieldContains: options.fieldContains,
       whatIf: options.whatIf ?? false,
       strict: options.strict ?? false
     });
     logger.success(
-      `Created ${result.generatedCount} missing project map node(s). ${result.alreadyCoveredCount} ancestor path(s) already existed.`
+      `Content type created: ${result.contentTypeCreated}. Entries scanned: ${result.entriesScanned}, updated: ${result.entriesUpdated}.`
     );
   });
   return command;
@@ -7006,7 +7144,7 @@ function createGenerateMissingProjectMapNodesCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.41",
+  version: "1.1.43",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -7075,7 +7213,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command20();
+var program = new Command21();
 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);
@@ -7110,5 +7248,6 @@ program.addCommand(createRemoveOrphanEntriesCommand());
 program.addCommand(createRemoveUnusedContentTypesCommand());
 program.addCommand(createRemoveUnusedComponentTypesCommand());
 program.addCommand(createGenerateMissingProjectMapNodesCommand());
+program.addCommand(createSplitContentTypeCommand());
 program.parse();
 //# sourceMappingURL=index.js.map