@uniformdev/transformer 1.1.28 → 1.1.30

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { Command as Command13 } from "commander";
+import { Command as Command15 } from "commander";
 
 // src/cli/commands/propagate-root-component-property.ts
 import { Command } from "commander";
@@ -638,13 +638,21 @@ var CompositionConverterService = class {
     }
     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);
+      try {
+        const { component } = await this.componentService.loadComponent(
+          componentsDirFull,
+          rootType,
+          { strict }
+        );
+        const contentType = this.generateContentType(component);
+        contentTypeMap.set(rootType, contentType);
+      } catch (error) {
+        if (error instanceof ComponentNotFoundError) {
+          this.logger.warn(`Component not found: ${rootType} \u2014 skipping content type generation`);
+          continue;
+        }
+        throw error;
+      }
     }
     const allTargetTypes = [.../* @__PURE__ */ new Set([...componentsToReferences, ...componentsToBlocks])];
     const targetContentTypeMap = /* @__PURE__ */ new Map();
@@ -5011,10 +5019,325 @@ function createRemoveFieldCommand() {
   return command;
 }
 
+// src/cli/commands/add-component-parameter.ts
+import { Command as Command13 } from "commander";
+
+// src/core/services/component-parameter-adder.service.ts
+var ComponentParameterAdderService = class {
+  constructor(fileSystem, componentService, logger) {
+    this.fileSystem = fileSystem;
+    this.componentService = componentService;
+    this.logger = logger;
+  }
+  async add(options) {
+    const {
+      rootDir,
+      componentsDir,
+      componentId,
+      parameterId,
+      parameterType,
+      parameterConfig,
+      groupId,
+      whatIf,
+      strict
+    } = options;
+    const findOptions = { strict };
+    const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
+    this.logger.info(`Loading component: ${componentId}`);
+    const { component, filePath: componentFilePath } = await this.componentService.loadComponent(fullComponentsDir, componentId, findOptions);
+    let parsedConfig = {};
+    if (parameterConfig) {
+      try {
+        parsedConfig = JSON.parse(parameterConfig);
+      } catch (e) {
+        throw new TransformError(
+          `Invalid JSON in --parameterConfig: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    const { id: _ignoreId, type: _ignoreType, ...restConfig } = parsedConfig;
+    const parameter = {
+      id: parameterId,
+      name: parsedConfig.name ?? parameterId,
+      type: parameterType,
+      ...restConfig
+    };
+    const existing = this.componentService.findParameter(component, parameterId, findOptions);
+    const parameterReplaced = existing !== void 0;
+    if (parameterReplaced) {
+      this.logger.warn(
+        `Parameter "${parameterId}" already exists on component "${component.id}" \u2014 replacing`
+      );
+    }
+    this.logger.action(
+      whatIf,
+      parameterReplaced ? "UPDATE" : "ADD",
+      `parameter "${parameterId}" to component/${this.fileSystem.getBasename(componentFilePath)}`
+    );
+    let updatedComponent = this.componentService.addParameterToComponent(
+      component,
+      parameter,
+      findOptions
+    );
+    if (groupId) {
+      const group = this.componentService.findParameter(updatedComponent, groupId, findOptions);
+      if (!group || !this.componentService.isGroupParameter(group)) {
+        throw new TransformError(
+          `Group "${groupId}" not found on component "${component.id}"`
+        );
+      }
+      updatedComponent = this.componentService.addParameterToGroup(
+        updatedComponent,
+        groupId,
+        parameterId,
+        findOptions
+      );
+    }
+    if (!whatIf) {
+      await this.componentService.saveComponent(componentFilePath, updatedComponent);
+    }
+    this.logger.info("");
+    this.logger.info(`Summary: 1 component definition updated.`);
+    return {
+      componentDefinitionUpdated: true,
+      parameterReplaced
+    };
+  }
+};
+
+// src/cli/commands/add-component-parameter.ts
+function createAddComponentParameterCommand() {
+  const command = new Command13("add-component-parameter");
+  command.description(
+    "Adds a new parameter definition to a component. If the parameter already exists it is replaced."
+  ).option("--componentId <id>", "The ID of the component to add the parameter to").option("--parameterId <id>", "The ID of the new parameter").option("--parameterType <type>", "The type of the new parameter (e.g. text, checkbox, select)").option(
+    "--parameterConfig <json>",
+    "Optional JSON string with additional parameter properties (e.g. name, typeConfig, localizable)"
+  ).option(
+    "--groupId <id>",
+    "Optional ID of an existing group parameter to register the new parameter under"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "componentId", flag: "--componentId" },
+      { name: "parameterId", flag: "--parameterId" },
+      { name: "parameterType", flag: "--parameterType" }
+    ];
+    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,
+      componentId: opts.componentId,
+      parameterId: opts.parameterId,
+      parameterType: opts.parameterType,
+      parameterConfig: opts.parameterConfig,
+      groupId: opts.groupId
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const componentService = new ComponentService(fileSystem);
+    const adder = new ComponentParameterAdderService(fileSystem, componentService, logger);
+    try {
+      const result = await adder.add({
+        rootDir: options.rootDir,
+        componentsDir: options.componentsDir,
+        componentId: options.componentId,
+        parameterId: options.parameterId,
+        parameterType: options.parameterType,
+        parameterConfig: options.parameterConfig,
+        groupId: options.groupId,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `${result.parameterReplaced ? "Replaced" : "Added"} parameter "${options.parameterId}" on component "${options.componentId}"`
+      );
+    } catch (error) {
+      if (error instanceof TransformError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      throw error;
+    }
+  });
+  return command;
+}
+
+// src/cli/commands/add-contenttype-field.ts
+import { Command as Command14 } from "commander";
+
+// src/core/services/contenttype-field-adder.service.ts
+var ContentTypeFieldAdderService = class {
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  compareIds(id1, id2, strict) {
+    if (strict) {
+      return id1 === id2;
+    }
+    return id1.toLowerCase() === id2.toLowerCase();
+  }
+  async loadContentType(contentTypesDir, contentTypeId, strict) {
+    const jsonPath = this.fileSystem.joinPath(contentTypesDir, `${contentTypeId}.json`);
+    const yamlPath = this.fileSystem.joinPath(contentTypesDir, `${contentTypeId}.yaml`);
+    const ymlPath = this.fileSystem.joinPath(contentTypesDir, `${contentTypeId}.yml`);
+    if (await this.fileSystem.fileExists(jsonPath)) {
+      const contentType = await this.fileSystem.readFile(jsonPath);
+      return { contentType, filePath: jsonPath };
+    }
+    if (await this.fileSystem.fileExists(yamlPath)) {
+      const contentType = await this.fileSystem.readFile(yamlPath);
+      return { contentType, filePath: yamlPath };
+    }
+    if (await this.fileSystem.fileExists(ymlPath)) {
+      const contentType = await this.fileSystem.readFile(ymlPath);
+      return { contentType, filePath: ymlPath };
+    }
+    if (!strict) {
+      const files = await this.fileSystem.findFiles(contentTypesDir, "*.{json,yaml,yml}");
+      for (const filePath of files) {
+        const basename2 = this.fileSystem.getBasename(filePath);
+        const nameWithoutExt = basename2.replace(/\.(json|yaml|yml)$/i, "");
+        if (nameWithoutExt.toLowerCase() === contentTypeId.toLowerCase()) {
+          const contentType = await this.fileSystem.readFile(filePath);
+          return { contentType, filePath };
+        }
+      }
+    }
+    throw new TransformError(`Content type not found: ${contentTypeId} (searched: ${contentTypesDir})`);
+  }
+  async add(options) {
+    const {
+      rootDir,
+      contentTypesDir,
+      contentTypeId,
+      fieldId,
+      fieldType,
+      fieldConfig,
+      whatIf,
+      strict
+    } = options;
+    const fullContentTypesDir = this.fileSystem.resolvePath(rootDir, contentTypesDir);
+    this.logger.info(`Loading content type: ${contentTypeId}`);
+    const { contentType, filePath: contentTypeFilePath } = await this.loadContentType(fullContentTypesDir, contentTypeId, strict);
+    let parsedConfig = {};
+    if (fieldConfig) {
+      try {
+        parsedConfig = JSON.parse(fieldConfig);
+      } catch (e) {
+        throw new TransformError(
+          `Invalid JSON in --fieldConfig: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
+    const { id: _ignoreId, type: _ignoreType, ...restConfig } = parsedConfig;
+    const field = {
+      id: fieldId,
+      name: parsedConfig.name ?? fieldId,
+      type: fieldType,
+      ...restConfig
+    };
+    if (!contentType.fields) {
+      contentType.fields = [];
+    }
+    const existingIndex = contentType.fields.findIndex(
+      (f) => this.compareIds(f.id, fieldId, strict)
+    );
+    const fieldReplaced = existingIndex >= 0;
+    if (fieldReplaced) {
+      this.logger.warn(
+        `Field "${fieldId}" already exists on content type "${contentType.id}" \u2014 replacing`
+      );
+    }
+    this.logger.action(
+      whatIf,
+      fieldReplaced ? "UPDATE" : "ADD",
+      `field "${fieldId}" to contentType/${this.fileSystem.getBasename(contentTypeFilePath)}`
+    );
+    if (fieldReplaced) {
+      contentType.fields[existingIndex] = field;
+    } else {
+      contentType.fields.push(field);
+    }
+    if (!whatIf) {
+      await this.fileSystem.writeFile(contentTypeFilePath, contentType);
+    }
+    this.logger.info("");
+    this.logger.info(`Summary: 1 content type definition updated.`);
+    return {
+      contentTypeDefinitionUpdated: true,
+      fieldReplaced
+    };
+  }
+};
+
+// src/cli/commands/add-contenttype-field.ts
+function createAddContentTypeFieldCommand() {
+  const command = new Command14("add-contenttype-field");
+  command.description(
+    "Adds a new field definition to a content type. If the field already exists it is replaced."
+  ).option("--contentTypeId <id>", "The ID of the content type to add the field to").option("--fieldId <id>", "The ID of the new field").option("--fieldType <type>", "The type of the new field (e.g. text, richText, reference)").option(
+    "--fieldConfig <json>",
+    "Optional JSON string with additional field properties (e.g. name, typeConfig, localizable)"
+  ).hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    const requiredOptions = [
+      { name: "contentTypeId", flag: "--contentTypeId" },
+      { name: "fieldId", flag: "--fieldId" },
+      { name: "fieldType", flag: "--fieldType" }
+    ];
+    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,
+      contentTypeId: opts.contentTypeId,
+      fieldId: opts.fieldId,
+      fieldType: opts.fieldType,
+      fieldConfig: opts.fieldConfig
+    };
+    const logger = new Logger();
+    const fileSystem = new FileSystemService();
+    const adder = new ContentTypeFieldAdderService(fileSystem, logger);
+    try {
+      const result = await adder.add({
+        rootDir: options.rootDir,
+        contentTypesDir: options.contentTypesDir,
+        contentTypeId: options.contentTypeId,
+        fieldId: options.fieldId,
+        fieldType: options.fieldType,
+        fieldConfig: options.fieldConfig,
+        whatIf: options.whatIf ?? false,
+        strict: options.strict ?? false
+      });
+      logger.success(
+        `${result.fieldReplaced ? "Replaced" : "Added"} field "${options.fieldId}" on content type "${options.contentTypeId}"`
+      );
+    } 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.28",
+  version: "1.1.30",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {
@@ -5083,7 +5406,7 @@ var package_default = {
 };
 
 // src/cli/index.ts
-var program = new Command13();
+var program = new Command15();
 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);
@@ -5108,5 +5431,7 @@ program.addCommand(createPropagateRootComponentSlotCommand());
 program.addCommand(createConvertCompositionsToEntriesCommand());
 program.addCommand(createRemoveParameterCommand());
 program.addCommand(createRemoveFieldCommand());
+program.addCommand(createAddComponentParameterCommand());
+program.addCommand(createAddContentTypeFieldCommand());
 program.parse();
 //# sourceMappingURL=index.js.map