simplemdg-dev-cli 1.5.1 → 2.4.4

package/src/commands/cds.command.ts

@@ -0,0 +1,529 @@
+import path from "node:path";
+import fs from "fs-extra";
+import chalk from "chalk";
+import { Command } from "commander";
+import {
+  buildDefaultCompileOutputFileNames,
+  buildDefaultEdmxOutputFileName,
+  resolveDefaultCdsModel,
+  scanCapProfiles,
+  scanCapServices,
+  type TCdsServiceDefinition,
+} from "../core/cds";
+import {
+  readCache,
+  rememberCdsEdmxOutputFileName,
+  rememberCdsModel,
+  rememberCdsPort,
+  rememberCdsProfile,
+  rememberCdsService,
+} from "../core/cache";
+import { runCommand, runCommandInherit } from "../core/process";
+import { resolveRepositoryPath } from "../core/repository";
+import { searchableSelectChoice, searchableSelectOrInput } from "../core/prompts";
+import { ensureExternalTool } from "../core/tooling";
+
+const NO_PROFILE_VALUE = "__SMDG_NO_PROFILE__";
+const NO_PORT_VALUE = "__SMDG_NO_PORT__";
+const DEFAULT_PORTS = ["4004", "4005", "4010", "4002", "4003", "4006"];
+const DEFAULT_CDS_COMPILE_FORMATS = ["edmx", "edm", "csn", "json", "sql", "yaml"];
+
+type TCdsWatchCommandOptions = {
+  cwd?: string;
+  profile?: string;
+  port?: string;
+  skipProfile?: boolean;
+  skipPort?: boolean;
+};
+
+type TCdsProfilesCommandOptions = {
+  cwd?: string;
+};
+
+type TCdsServicesCommandOptions = {
+  cwd?: string;
+};
+
+type TCdsCompileCommandOptions = {
+  cwd?: string;
+  service?: string;
+  model?: string;
+  out?: string;
+  profile?: string;
+  all?: boolean;
+  print?: boolean;
+  to?: string;
+};
+
+function uniqueValues(values: Array<string | undefined>): string[] {
+  return [...new Set(values.map((value) => value?.trim() ?? "").filter(Boolean))];
+}
+
+function validateRequired(value: string): true | string {
+  return value.trim() ? true : "Value is required";
+}
+
+function validatePort(value: string): true | string {
+  if (!value.trim()) {
+    return "Port is required";
+  }
+
+  const port = Number(value);
+
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    return "Port must be a number from 1 to 65535";
+  }
+
+  return true;
+}
+
+function isServiceOptionRequired(to: string): boolean {
+  return ["edmx", "edm"].includes(to);
+}
+
+function normalizeCompileFormat(value: string | undefined): string {
+  return (value?.trim() || "edmx").replace(/^--to\s+/, "");
+}
+
+async function resolveProfile(options: {
+  repositoryPath: string;
+  profile?: string;
+  skipProfile?: boolean;
+}): Promise<string | undefined> {
+  if (options.skipProfile) {
+    return undefined;
+  }
+
+  if (options.profile?.trim()) {
+    await rememberCdsProfile(options.profile.trim());
+    return options.profile.trim();
+  }
+
+  const cache = await readCache();
+  const scannedProfiles = await scanCapProfiles(options.repositoryPath);
+  const profiles = uniqueValues([...cache.cds.profiles, ...scannedProfiles]);
+
+  const selectedProfile = await searchableSelectChoice({
+    message: "Select CAP profile",
+    choices: [
+      ...profiles.map((profile) => ({ title: profile, value: profile })),
+      { title: "Run without --profile", value: NO_PROFILE_VALUE },
+    ],
+    validateCustomValue: validateRequired,
+    customValueTitle: (value) => `Use typed CAP profile: ${value}`,
+  });
+
+  if (selectedProfile === NO_PROFILE_VALUE) {
+    return undefined;
+  }
+
+  await rememberCdsProfile(selectedProfile);
+  return selectedProfile;
+}
+
+async function resolvePort(options: {
+  port?: string;
+  skipPort?: boolean;
+}): Promise<string | undefined> {
+  if (options.skipPort) {
+    return undefined;
+  }
+
+  if (options.port?.trim()) {
+    const validationResult = validatePort(options.port.trim());
+
+    if (validationResult !== true) {
+      throw new Error(validationResult);
+    }
+
+    await rememberCdsPort(options.port.trim());
+    return options.port.trim();
+  }
+
+  const cache = await readCache();
+  const ports = uniqueValues([...cache.cds.ports, ...DEFAULT_PORTS]);
+
+  const selectedPort = await searchableSelectChoice({
+    message: "Select CAP port",
+    choices: [
+      ...ports.map((port) => ({ title: port, value: port })),
+      { title: "Run without --port", value: NO_PORT_VALUE },
+    ],
+    validateCustomValue: validatePort,
+    customValueTitle: (value) => `Use typed port: ${value}`,
+  });
+
+  if (selectedPort === NO_PORT_VALUE) {
+    return undefined;
+  }
+
+  await rememberCdsPort(selectedPort);
+  return selectedPort;
+}
+
+async function resolveCompileFormat(options: { to?: string }): Promise<string> {
+  if (options.to?.trim()) {
+    return normalizeCompileFormat(options.to);
+  }
+
+  return searchableSelectChoice({
+    message: "Select cds compile --to format",
+    choices: DEFAULT_CDS_COMPILE_FORMATS.map((format) => ({ title: format, value: format })),
+    validateCustomValue: validateRequired,
+    customValueTitle: (value) => `Use typed --to format: ${value}`,
+  });
+}
+
+async function resolveCompileService(options: {
+  repositoryPath: string;
+  service?: string;
+  required: boolean;
+}): Promise<{ serviceName?: string; serviceDefinition?: TCdsServiceDefinition }> {
+  const scannedServices = await scanCapServices(options.repositoryPath);
+
+  if (options.service?.trim()) {
+    const inputServiceName = options.service.trim();
+    const serviceDefinition = scannedServices.find((item) => {
+      return item.serviceName === inputServiceName || item.fullServiceName === inputServiceName;
+    });
+
+    await rememberCdsService(inputServiceName);
+    return {
+      serviceName: serviceDefinition?.fullServiceName ?? inputServiceName,
+      serviceDefinition,
+    };
+  }
+
+  if (!scannedServices.length) {
+    if (options.required) {
+      throw new Error("No CAP service was found in srv/app/db. Please pass --service manually.");
+    }
+
+    return {};
+  }
+
+  const choices = scannedServices.map((serviceDefinition) => {
+    const titleServiceName = serviceDefinition.fullServiceName === serviceDefinition.serviceName
+      ? serviceDefinition.serviceName
+      : `${serviceDefinition.fullServiceName} (${serviceDefinition.serviceName})`;
+
+    return {
+      title: `${titleServiceName} (${serviceDefinition.relativeFilePath})`,
+      value: serviceDefinition.fullServiceName,
+      description: serviceDefinition.relativeFilePath,
+    };
+  });
+
+  const selectedServiceName = await searchableSelectChoice({
+    message: "Select CAP service",
+    choices,
+    validateCustomValue: validateRequired,
+    customValueTitle: (value) => `Use typed service: ${value}`,
+    limit: 20,
+  });
+
+  const serviceDefinition = scannedServices.find((item) => item.fullServiceName === selectedServiceName || item.serviceName === selectedServiceName);
+  const serviceName = serviceDefinition?.fullServiceName ?? selectedServiceName;
+
+  await rememberCdsService(serviceName);
+
+  return {
+    serviceName,
+    serviceDefinition,
+  };
+}
+
+async function resolveCompileModel(options: {
+  repositoryPath: string;
+  model?: string;
+  serviceDefinition?: TCdsServiceDefinition;
+}): Promise<string> {
+  if (options.model?.trim()) {
+    await rememberCdsModel(options.model.trim());
+    return options.model.trim();
+  }
+
+  const cache = await readCache();
+  const defaultModel = options.serviceDefinition?.relativeFilePath ?? await resolveDefaultCdsModel(options.repositoryPath);
+  const fallbackModel = await resolveDefaultCdsModel(options.repositoryPath);
+  const model = await searchableSelectOrInput({
+    message: "Select CDS model/path",
+    values: uniqueValues([defaultModel, fallbackModel, ".", ...cache.cds.models]),
+    initialValue: defaultModel,
+    validate: validateRequired,
+    customValueTitle: (value) => `Use typed model/path: ${value}`,
+  });
+
+  await rememberCdsModel(model);
+  return model;
+}
+
+async function resolveCompileOutputFile(options: {
+  repositoryPath: string;
+  serviceName?: string;
+  to: string;
+  out?: string;
+}): Promise<string> {
+  if (options.out?.trim()) {
+    await rememberCdsEdmxOutputFileName(options.out.trim());
+    return options.out.trim();
+  }
+
+  const cache = await readCache();
+  const defaultOutputFiles = await buildDefaultCompileOutputFileNames({
+    repositoryPath: options.repositoryPath,
+    serviceName: options.serviceName,
+    to: options.to,
+  });
+  const outputFile = await searchableSelectOrInput({
+    message: "Select output file",
+    values: uniqueValues([...defaultOutputFiles, ...cache.cds.edmxOutputFileNames]),
+    initialValue: defaultOutputFiles[0] ?? "metadata.xml",
+    validate: validateRequired,
+    customValueTitle: (value) => `Use typed output file: ${value}`,
+  });
+
+  await rememberCdsEdmxOutputFileName(outputFile);
+  return outputFile;
+}
+
+async function compileCds(options: {
+  repositoryPath: string;
+  model: string;
+  to: string;
+  serviceName?: string;
+  outputFile?: string;
+  profile?: string;
+  print?: boolean;
+}): Promise<void> {
+  const args = ["compile", options.model, "--to", options.to];
+
+  if (options.serviceName) {
+    args.push("--service", options.serviceName);
+  }
+
+  if (options.profile) {
+    args.push("--profile", options.profile);
+  }
+
+  console.log(chalk.gray(`Running: cds ${args.join(" ")}`));
+  console.log(chalk.gray(`CWD: ${options.repositoryPath}`));
+
+  if (options.outputFile && options.to === "edmx") {
+    console.log(chalk.gray(`Equivalent PowerShell: cds ${args.join(" ")} | Out-File -Encoding utf8 ${options.outputFile}`));
+  }
+
+  const result = await runCommand("cds", args, { cwd: options.repositoryPath, reject: false });
+
+  if (result.stderr.trim()) {
+    console.error(result.stderr);
+  }
+
+  if (result.exitCode !== 0) {
+    if (options.serviceName) {
+      const services = await scanCapServices(options.repositoryPath);
+      const serviceList = services.map((service) => `- ${service.fullServiceName} (${service.relativeFilePath})`).join("\n");
+
+      if (serviceList) {
+        console.log(chalk.yellow("Available services detected in this repository:"));
+        console.log(serviceList);
+      }
+    }
+
+    throw new Error(`cds compile failed with exit code ${result.exitCode}`);
+  }
+
+  if (options.print) {
+    console.log(result.stdout);
+    return;
+  }
+
+  if (!options.outputFile) {
+    throw new Error("Output file is required");
+  }
+
+  const outputPath = path.isAbsolute(options.outputFile)
+    ? options.outputFile
+    : path.join(options.repositoryPath, options.outputFile);
+
+  await fs.ensureDir(path.dirname(outputPath));
+  await fs.writeFile(outputPath, result.stdout, { encoding: "utf8" });
+  console.log(chalk.green(`Metadata exported with utf8 encoding: ${outputPath}`));
+}
+
+async function runCdsWatchCommand(extraArguments: string[], options: TCdsWatchCommandOptions): Promise<void> {
+  await ensureExternalTool("cds");
+  const repositoryPath = await resolveRepositoryPath(options.cwd ?? process.cwd());
+  const profile = await resolveProfile({
+    repositoryPath,
+    profile: options.profile,
+    skipProfile: options.skipProfile,
+  });
+  const port = await resolvePort({
+    port: options.port,
+    skipPort: options.skipPort,
+  });
+
+  const args = ["watch"];
+
+  if (profile) {
+    args.push("--profile", profile);
+  }
+
+  if (port) {
+    args.push("--port", port);
+  }
+
+  args.push(...extraArguments);
+
+  console.log(chalk.gray(`Running: cds ${args.join(" ")}`));
+  console.log(chalk.gray(`CWD: ${repositoryPath}`));
+  console.log("");
+
+  const exitCode = await runCommandInherit("cds", args, { cwd: repositoryPath });
+  process.exitCode = exitCode;
+}
+
+async function runCdsProfilesCommand(options: TCdsProfilesCommandOptions): Promise<void> {
+  const repositoryPath = await resolveRepositoryPath(options.cwd ?? process.cwd());
+  const profiles = await scanCapProfiles(repositoryPath);
+
+  for (const profile of profiles) {
+    console.log(profile);
+  }
+}
+
+async function runCdsServicesCommand(options: TCdsServicesCommandOptions): Promise<void> {
+  const repositoryPath = await resolveRepositoryPath(options.cwd ?? process.cwd());
+  const services = await scanCapServices(repositoryPath);
+
+  if (!services.length) {
+    console.log(chalk.yellow("No CAP services found."));
+    return;
+  }
+
+  for (const service of services) {
+    console.log(`${service.fullServiceName}\t${service.relativeFilePath}`);
+  }
+}
+
+async function runCdsCompileCommand(options: TCdsCompileCommandOptions): Promise<void> {
+  await ensureExternalTool("cds");
+  const repositoryPath = await resolveRepositoryPath(options.cwd ?? process.cwd());
+  const to = await resolveCompileFormat({ to: options.to });
+  const service = await resolveCompileService({
+    repositoryPath,
+    service: options.service,
+    required: isServiceOptionRequired(to),
+  });
+  const model = await resolveCompileModel({
+    repositoryPath,
+    model: options.model,
+    serviceDefinition: service.serviceDefinition,
+  });
+  const profile = options.profile?.trim();
+
+  if (profile) {
+    await rememberCdsProfile(profile);
+  }
+
+  if (options.all) {
+    const services = await scanCapServices(repositoryPath);
+
+    if (!services.length) {
+      throw new Error("No CAP services found to export");
+    }
+
+    const outputDirectory = options.out?.trim() || "metadata";
+    await rememberCdsEdmxOutputFileName(outputDirectory);
+
+    for (const serviceDefinition of services) {
+      const outputFile = path.join(outputDirectory, buildDefaultEdmxOutputFileName(serviceDefinition.fullServiceName));
+      await rememberCdsService(serviceDefinition.fullServiceName);
+      await compileCds({
+        repositoryPath,
+        model: serviceDefinition.relativeFilePath,
+        to,
+        serviceName: serviceDefinition.fullServiceName,
+        outputFile,
+        profile,
+        print: false,
+      });
+    }
+
+    return;
+  }
+
+  const outputFile = options.print
+    ? undefined
+    : await resolveCompileOutputFile({
+      repositoryPath,
+      serviceName: service.serviceName,
+      to,
+      out: options.out,
+    });
+
+  await compileCds({
+    repositoryPath,
+    model,
+    to,
+    serviceName: service.serviceName,
+    outputFile,
+    profile,
+    print: options.print,
+  });
+}
+
+export function registerCdsCommands(program: Command): void {
+  const cdsCommand = program.command("cds").description("SAP CAP helper commands for SimpleMDG");
+
+  cdsCommand
+    .command("watch [extraArguments...]")
+    .description("Run cds watch with searchable profile and optional port")
+    .option("--cwd <path>", "Repository path", process.cwd())
+    .option("--profile <profile>", "CAP profile, for example hybrid")
+    .option("--port <port>", "Port, for example 4005")
+    .option("--skip-profile", "Run without --profile")
+    .option("--skip-port", "Run without --port")
+    .allowUnknownOption(true)
+    .action(runCdsWatchCommand);
+
+  cdsCommand
+    .command("profiles")
+    .description("Scan available CAP profiles in the current repository")
+    .option("--cwd <path>", "Repository path", process.cwd())
+    .action(runCdsProfilesCommand);
+
+  cdsCommand
+    .command("services")
+    .description("Scan available CAP services in the current repository")
+    .option("--cwd <path>", "Repository path", process.cwd())
+    .action(runCdsServicesCommand);
+
+  cdsCommand
+    .command("compline")
+    .alias("compile")
+    .description("Run cds compile and export result with utf8 encoding")
+    .option("--cwd <path>", "Repository path", process.cwd())
+    .option("--model <model>", "CDS model/path, for example srv, . or srv/main-service.cds")
+    .option("--service <service>", "CAP service name to export")
+    .option("--to <format>", "cds compile output format, default edmx", "edmx")
+    .option("--out <fileOrDirectory>", "Output file, or output directory when --all is used")
+    .option("--profile <profile>", "CAP profile used by cds compile")
+    .option("--all", "Export all scanned services to a directory")
+    .option("--print", "Print output to terminal instead of writing a file")
+    .action(runCdsCompileCommand);
+
+  cdsCommand
+    .command("edmx")
+    .alias("metadata")
+    .description("Export CAP service metadata EDMX XML. Alias of smdg cds compline --to edmx")
+    .option("--cwd <path>", "Repository path", process.cwd())
+    .option("--model <model>", "CDS model/path, for example srv, . or srv/main-service.cds")
+    .option("--service <service>", "CAP service name to export")
+    .option("--out <fileOrDirectory>", "Output XML file, or output directory when --all is used")
+    .option("--profile <profile>", "CAP profile used by cds compile")
+    .option("--all", "Export all scanned services to a directory")
+    .option("--print", "Print EDMX to terminal instead of writing a file")
+    .action((options: Omit<TCdsCompileCommandOptions, "to">) => runCdsCompileCommand({ ...options, to: "edmx" }));
+}