@uniformdev/transformer 1.1.42 → 1.1.44

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";
@@ -6908,12 +6908,12 @@ var GenerateMissingProjectMapNodesService = class {
   }
   pathToNodeId(nodePath) {
     if (nodePath === "/") return "pmn-group-root";
-    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-");
+    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-").replace(/[\\:*?"<>|]/g, "_");
     return `pmn-group-${slug}`;
   }
   pathToFileName(nodePath) {
     if (nodePath === "/") return "root-node.yaml";
-    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-");
+    const slug = nodePath.split("/").filter((s) => s.length > 0).join("-").replace(/[\\:*?"<>|]/g, "_");
     return `${slug}-node.yaml`;
   }
 };
@@ -6943,10 +6943,208 @@ function createGenerateMissingProjectMapNodesCommand() {
   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: "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(", ")}`);
+      process.exit(1);
+    }
+  }).action(async (opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const options = {
+      ...globalOpts,
+      contentType: opts.contentType,
+      newContentType: opts.newContentType,
+      fieldId: opts.fieldId,
+      fieldContains: opts.fieldContains
+    };
+    const logger = new Logger();
+    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 ContentTypeSplitterService(fileSystem, logger);
+    const result = await service.split({
+      rootDir: options.rootDir,
+      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(
+      `Content type created: ${result.contentTypeCreated}. Entries scanned: ${result.entriesScanned}, updated: ${result.entriesUpdated}.`
+    );
+  });
+  return command;
+}
+
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.42",
+  version: "1.1.44",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -7015,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);
@@ -7050,5 +7248,6 @@ program.addCommand(createRemoveOrphanEntriesCommand());
 program.addCommand(createRemoveUnusedContentTypesCommand());
 program.addCommand(createRemoveUnusedComponentTypesCommand());
 program.addCommand(createGenerateMissingProjectMapNodesCommand());
+program.addCommand(createSplitContentTypeCommand());
 program.parse();
 //# sourceMappingURL=index.js.map