simplemdg-dev-cli 1.5.1 → 2.4.4

package/src/core/cache.ts

@@ -0,0 +1,332 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "fs-extra";
+import type {
+  TCloudFoundryApp,
+  TCloudFoundryAppsCacheEntry,
+  TCloudFoundryLoginProfile,
+  TCloudFoundryOrgEntry,
+  TSimpleMdgCache,
+  TNpmrcPackageEntry,
+  TNpmrcTokenEntry,
+} from "./types";
+
+const CACHE_DIRECTORY = path.join(os.homedir(), ".simplemdg");
+const CACHE_FILE_PATH = path.join(CACHE_DIRECTORY, "cache.json");
+const MAX_HISTORY_ITEMS = 20;
+const MAX_NPMRC_PACKAGE_ITEMS = 500;
+
+const EMPTY_CACHE: TSimpleMdgCache = {
+  variables: {},
+  overrides: {},
+  cloudFoundry: {
+    loginProfiles: [],
+    appListsByTarget: {},
+    orgsAcrossRegions: [],
+    orgsAcrossRegionsUpdatedAt: undefined,
+    envFileNames: ["default-env.json", "default-envBTP.json", "default-envBTPConfigAdmin.json"],
+    selectedApps: [],
+  },
+  cds: {
+    profiles: ["hybrid", "development", "production"],
+    ports: ["4004", "4005", "4010"],
+    services: [],
+    edmxOutputFileNames: [],
+    models: ["srv", "."],
+  },
+  npmrc: {
+    hosts: ["gitlab.simplemdg.com"],
+    scopes: ["@simplemdg"],
+    packageIds: [],
+    packages: [],
+    packageIdsByProject: {},
+    tokens: [],
+    tokenEntries: [],
+    outputFileNames: [".npmrc"],
+  },
+};
+
+function cloneEmptyCache(): TSimpleMdgCache {
+  return JSON.parse(JSON.stringify(EMPTY_CACHE)) as TSimpleMdgCache;
+}
+
+function uniqueLatest(values: string[]): string[] {
+  const normalizedValues = values.map((value) => value.trim()).filter(Boolean);
+  return [...new Set(normalizedValues)].slice(0, MAX_HISTORY_ITEMS);
+}
+
+function uniquePackageEntries(values: TNpmrcPackageEntry[]): TNpmrcPackageEntry[] {
+  const result: TNpmrcPackageEntry[] = [];
+  const keys = new Set<string>();
+
+  for (const value of values) {
+    const packageId = value.packageId.trim();
+    const scope = value.scope.trim();
+    const host = value.host.trim();
+
+    if (!packageId || !scope || !host) {
+      continue;
+    }
+
+    const key = `${host}|${scope}|${packageId}`;
+
+    if (keys.has(key)) {
+      continue;
+    }
+
+    keys.add(key);
+    result.push({
+      ...value,
+      packageId,
+      packageName: value.packageName.trim() || packageId,
+      scope,
+      host,
+    });
+  }
+
+  return result.slice(0, MAX_NPMRC_PACKAGE_ITEMS);
+}
+
+function uniqueTokenEntries(values: TNpmrcTokenEntry[]): TNpmrcTokenEntry[] {
+  const result: TNpmrcTokenEntry[] = [];
+  const keys = new Set<string>();
+
+  for (const value of values) {
+    const scope = value.scope.trim();
+    const host = value.host.trim();
+
+    if (!scope || !host || !value.token.trim()) {
+      continue;
+    }
+
+    const key = `${host}|${scope}`;
+
+    if (keys.has(key)) {
+      continue;
+    }
+
+    keys.add(key);
+    result.push({
+      ...value,
+      scope,
+      host,
+      token: value.token.trim(),
+      label: value.label.trim() || `${scope} @ ${host}`,
+    });
+  }
+
+  return result.slice(0, MAX_HISTORY_ITEMS);
+}
+
+function migrateNpmrcProjectCache(
+  value: TSimpleMdgCache["npmrc"]["packageIdsByProject"],
+): TSimpleMdgCache["npmrc"]["packageIdsByProject"] {
+  const migratedEntries: TSimpleMdgCache["npmrc"]["packageIdsByProject"] = {};
+
+  for (const [projectName, projectCache] of Object.entries(value ?? {})) {
+    migratedEntries[projectName] = {
+      projectName: projectCache.projectName ?? projectName,
+      packageIds: projectCache.packageIds ?? [],
+      packages: projectCache.packages ?? [],
+    };
+  }
+
+  return migratedEntries;
+}
+
+export async function readCache(): Promise<TSimpleMdgCache> {
+  if (!(await fs.pathExists(CACHE_FILE_PATH))) {
+    return cloneEmptyCache();
+  }
+
+  const cache = await fs.readJson(CACHE_FILE_PATH).catch(() => cloneEmptyCache()) as Partial<TSimpleMdgCache>;
+
+  return {
+    variables: cache.variables ?? {},
+    overrides: cache.overrides ?? {},
+    cloudFoundry: {
+      loginProfiles: cache.cloudFoundry?.loginProfiles ?? [],
+      appListsByTarget: cache.cloudFoundry?.appListsByTarget ?? {},
+      orgsAcrossRegions: cache.cloudFoundry?.orgsAcrossRegions ?? [],
+      orgsAcrossRegionsUpdatedAt: cache.cloudFoundry?.orgsAcrossRegionsUpdatedAt,
+      envFileNames: cache.cloudFoundry?.envFileNames ?? EMPTY_CACHE.cloudFoundry.envFileNames,
+      selectedApps: cache.cloudFoundry?.selectedApps ?? [],
+    },
+    cds: {
+      profiles: cache.cds?.profiles ?? EMPTY_CACHE.cds.profiles,
+      ports: cache.cds?.ports ?? EMPTY_CACHE.cds.ports,
+      services: cache.cds?.services ?? EMPTY_CACHE.cds.services,
+      edmxOutputFileNames: cache.cds?.edmxOutputFileNames ?? EMPTY_CACHE.cds.edmxOutputFileNames,
+      models: cache.cds?.models ?? EMPTY_CACHE.cds.models,
+    },
+    npmrc: {
+      hosts: cache.npmrc?.hosts ?? EMPTY_CACHE.npmrc.hosts,
+      scopes: cache.npmrc?.scopes ?? EMPTY_CACHE.npmrc.scopes,
+      packageIds: cache.npmrc?.packageIds ?? EMPTY_CACHE.npmrc.packageIds,
+      packages: cache.npmrc?.packages ?? EMPTY_CACHE.npmrc.packages,
+      packageIdsByProject: migrateNpmrcProjectCache(cache.npmrc?.packageIdsByProject ?? EMPTY_CACHE.npmrc.packageIdsByProject),
+      tokens: cache.npmrc?.tokens ?? EMPTY_CACHE.npmrc.tokens,
+      tokenEntries: cache.npmrc?.tokenEntries ?? EMPTY_CACHE.npmrc.tokenEntries,
+      outputFileNames: cache.npmrc?.outputFileNames ?? EMPTY_CACHE.npmrc.outputFileNames,
+    },
+  };
+}
+
+export async function writeCache(cache: TSimpleMdgCache): Promise<void> {
+  await fs.ensureDir(CACHE_DIRECTORY);
+  await fs.writeJson(CACHE_FILE_PATH, cache, { spaces: 2 });
+}
+
+export async function rememberVariableValue(variableName: string, value: string): Promise<void> {
+  const cache = await readCache();
+  cache.variables[variableName] = uniqueLatest([value, ...(cache.variables[variableName] ?? [])]);
+  await writeCache(cache);
+}
+
+export async function rememberOverrideValue(packageName: string, version: string): Promise<void> {
+  const cache = await readCache();
+  cache.overrides[packageName] = uniqueLatest([version, ...(cache.overrides[packageName] ?? [])]);
+  await writeCache(cache);
+}
+
+export async function rememberResolvedOverrideVersions(overrides: Record<string, string>): Promise<void> {
+  for (const [packageName, version] of Object.entries(overrides)) {
+    await rememberOverrideValue(packageName, version);
+  }
+}
+
+export async function rememberCloudFoundryLoginProfile(profile: TCloudFoundryLoginProfile): Promise<void> {
+  const cache = await readCache();
+  const nextProfiles = cache.cloudFoundry.loginProfiles.filter((item) => {
+    return !(item.apiEndpoint === profile.apiEndpoint && item.org === profile.org && item.space === profile.space && item.username === profile.username);
+  });
+
+  cache.cloudFoundry.loginProfiles = [profile, ...nextProfiles].slice(0, MAX_HISTORY_ITEMS);
+  await writeCache(cache);
+}
+
+export async function rememberCloudFoundryApps(targetKey: string, apps: TCloudFoundryApp[]): Promise<void> {
+  const cache = await readCache();
+  const entry: TCloudFoundryAppsCacheEntry = {
+    targetKey,
+    apps,
+    updatedAt: new Date().toISOString(),
+  };
+
+  cache.cloudFoundry.appListsByTarget[targetKey] = entry;
+  await writeCache(cache);
+}
+
+
+export async function rememberCloudFoundryOrgEntries(orgEntries: TCloudFoundryOrgEntry[]): Promise<void> {
+  const cache = await readCache();
+  cache.cloudFoundry.orgsAcrossRegions = orgEntries;
+  cache.cloudFoundry.orgsAcrossRegionsUpdatedAt = new Date().toISOString();
+  await writeCache(cache);
+}
+
+export async function rememberSelectedApp(appName: string): Promise<void> {
+  const cache = await readCache();
+  cache.cloudFoundry.selectedApps = uniqueLatest([appName, ...cache.cloudFoundry.selectedApps]);
+  await writeCache(cache);
+}
+
+export async function rememberEnvironmentFileName(fileName: string): Promise<void> {
+  const cache = await readCache();
+  cache.cloudFoundry.envFileNames = uniqueLatest([fileName, ...cache.cloudFoundry.envFileNames]);
+  await writeCache(cache);
+}
+
+export async function rememberCdsProfile(profile: string): Promise<void> {
+  const cache = await readCache();
+  cache.cds.profiles = uniqueLatest([profile, ...cache.cds.profiles]);
+  await writeCache(cache);
+}
+
+export async function rememberCdsPort(port: string): Promise<void> {
+  const cache = await readCache();
+  cache.cds.ports = uniqueLatest([port, ...cache.cds.ports]);
+  await writeCache(cache);
+}
+
+export async function rememberCdsService(serviceName: string): Promise<void> {
+  const cache = await readCache();
+  cache.cds.services = uniqueLatest([serviceName, ...cache.cds.services]);
+  await writeCache(cache);
+}
+
+export async function rememberCdsEdmxOutputFileName(fileName: string): Promise<void> {
+  const cache = await readCache();
+  cache.cds.edmxOutputFileNames = uniqueLatest([fileName, ...cache.cds.edmxOutputFileNames]);
+  await writeCache(cache);
+}
+
+export async function rememberCdsModel(model: string): Promise<void> {
+  const cache = await readCache();
+  cache.cds.models = uniqueLatest([model, ...cache.cds.models]);
+  await writeCache(cache);
+}
+
+
+export async function rememberNpmrcHost(host: string): Promise<void> {
+  const cache = await readCache();
+  cache.npmrc.hosts = uniqueLatest([host, ...cache.npmrc.hosts]);
+  await writeCache(cache);
+}
+
+export async function rememberNpmrcScope(scope: string): Promise<void> {
+  const cache = await readCache();
+  cache.npmrc.scopes = uniqueLatest([scope, ...cache.npmrc.scopes]);
+  await writeCache(cache);
+}
+
+export async function rememberNpmrcPackageIds(projectName: string, packageIds: string[]): Promise<void> {
+  const fallbackEntries = packageIds.map<TNpmrcPackageEntry>((packageId) => ({
+    packageId,
+    packageName: packageId,
+    scope: "@simplemdg",
+    host: "gitlab.simplemdg.com",
+    updatedAt: new Date().toISOString(),
+  }));
+
+  await rememberNpmrcPackages(projectName, fallbackEntries);
+}
+
+export async function rememberNpmrcPackages(projectName: string, packages: TNpmrcPackageEntry[]): Promise<void> {
+  const cache = await readCache();
+  const nextPackageIds = packages.map((item) => item.packageId);
+  cache.npmrc.packageIds = uniqueLatest([...nextPackageIds, ...cache.npmrc.packageIds]);
+  cache.npmrc.packages = uniquePackageEntries([...packages, ...cache.npmrc.packages]);
+
+  const projectKey = projectName.trim();
+
+  if (projectKey) {
+    const currentProjectCache = cache.npmrc.packageIdsByProject[projectKey];
+    cache.npmrc.packageIdsByProject[projectKey] = {
+      projectName: projectKey,
+      packageIds: uniqueLatest([...nextPackageIds, ...(currentProjectCache?.packageIds ?? [])]),
+      packages: uniquePackageEntries([...packages, ...(currentProjectCache?.packages ?? [])]),
+    };
+  }
+
+  await writeCache(cache);
+}
+
+export async function rememberNpmrcToken(token: string): Promise<void> {
+  const cache = await readCache();
+  cache.npmrc.tokens = uniqueLatest([token, ...cache.npmrc.tokens]);
+  await writeCache(cache);
+}
+
+export async function rememberNpmrcTokenEntry(entry: TNpmrcTokenEntry): Promise<void> {
+  const cache = await readCache();
+  cache.npmrc.tokens = uniqueLatest([entry.token, ...cache.npmrc.tokens]);
+  cache.npmrc.tokenEntries = uniqueTokenEntries([entry, ...cache.npmrc.tokenEntries]);
+  await writeCache(cache);
+}
+
+export async function rememberNpmrcOutputFileName(fileName: string): Promise<void> {
+  const cache = await readCache();
+  cache.npmrc.outputFileNames = uniqueLatest([fileName, ...cache.npmrc.outputFileNames]);
+  await writeCache(cache);
+}

package/src/core/cds.ts

@@ -0,0 +1,278 @@
+import path from "node:path";
+import fs from "fs-extra";
+import fg from "fast-glob";
+
+const DEFAULT_CAP_PROFILES = ["hybrid", "development", "production", "mock"];
+const CAP_CONFIG_FILE_NAMES = [
+  "package.json",
+  ".cdsrc.json",
+  ".cdsrc-private.json",
+  "default-env.json",
+  "default-envBTP.json",
+];
+
+function normalizeProfileName(value: string): string {
+  return value.trim().replace(/^\[/, "").replace(/\]$/, "");
+}
+
+function addProfile(result: Set<string>, value: string | undefined): void {
+  const profileName = normalizeProfileName(value ?? "");
+
+  if (!profileName || profileName.startsWith("-") || profileName.includes("/")) {
+    return;
+  }
+
+  result.add(profileName);
+}
+
+function collectProfilesFromText(text: string, result: Set<string>): void {
+  const commandProfileRegex = /--profile(?:=|\s+)([A-Za-z0-9_.:-]+)/g;
+  let commandMatch: RegExpExecArray | null;
+
+  while ((commandMatch = commandProfileRegex.exec(text)) !== null) {
+    addProfile(result, commandMatch[1]);
+  }
+
+  const bracketProfileRegex = /"\[([A-Za-z0-9_.:-]+)\]"\s*:/g;
+  let bracketMatch: RegExpExecArray | null;
+
+  while ((bracketMatch = bracketProfileRegex.exec(text)) !== null) {
+    addProfile(result, bracketMatch[1]);
+  }
+
+  const plainProfileRegex = /"profile"\s*:\s*"([A-Za-z0-9_.:-]+)"/g;
+  let plainMatch: RegExpExecArray | null;
+
+  while ((plainMatch = plainProfileRegex.exec(text)) !== null) {
+    addProfile(result, plainMatch[1]);
+  }
+}
+
+async function collectProfilesFromPackageJson(repositoryPath: string, result: Set<string>): Promise<void> {
+  const packageJsonPath = path.join(repositoryPath, "package.json");
+
+  if (!(await fs.pathExists(packageJsonPath))) {
+    return;
+  }
+
+  const packageJson = await fs.readJson(packageJsonPath).catch(() => undefined) as Record<string, unknown> | undefined;
+
+  if (!packageJson) {
+    return;
+  }
+
+  const scripts = packageJson.scripts;
+
+  if (scripts && typeof scripts === "object") {
+    for (const [scriptName, scriptCommand] of Object.entries(scripts as Record<string, unknown>)) {
+      collectProfilesFromText(scriptName, result);
+
+      if (typeof scriptCommand === "string") {
+        collectProfilesFromText(scriptCommand, result);
+      }
+    }
+  }
+
+  const cdsConfig = packageJson.cds;
+
+  if (cdsConfig) {
+    collectProfilesFromText(JSON.stringify(cdsConfig), result);
+  }
+}
+
+export async function scanCapProfiles(repositoryPath: string): Promise<string[]> {
+  const result = new Set<string>();
+
+  await collectProfilesFromPackageJson(repositoryPath, result);
+
+  const configFilePaths = await fg(CAP_CONFIG_FILE_NAMES, {
+    cwd: repositoryPath,
+    onlyFiles: true,
+    dot: true,
+    absolute: true,
+    unique: true,
+  });
+
+  for (const filePath of configFilePaths) {
+    const text = await fs.readFile(filePath, "utf8").catch(() => "");
+    collectProfilesFromText(text, result);
+  }
+
+  for (const defaultProfile of DEFAULT_CAP_PROFILES) {
+    if (result.has(defaultProfile)) {
+      continue;
+    }
+
+    result.add(defaultProfile);
+  }
+
+  return [...result].sort((left, right) => {
+    const defaultLeftIndex = DEFAULT_CAP_PROFILES.indexOf(left);
+    const defaultRightIndex = DEFAULT_CAP_PROFILES.indexOf(right);
+
+    if (defaultLeftIndex !== -1 || defaultRightIndex !== -1) {
+      return (defaultLeftIndex === -1 ? 999 : defaultLeftIndex) - (defaultRightIndex === -1 ? 999 : defaultRightIndex);
+    }
+
+    return left.localeCompare(right);
+  });
+}
+
+export type TCdsServiceDefinition = {
+  serviceName: string;
+  filePath: string;
+  relativeFilePath: string;
+  namespace?: string;
+  fullServiceName: string;
+};
+
+const DEFAULT_CDS_SCAN_PATTERNS = [
+  "srv/**/*.cds",
+  "app/**/*.cds",
+  "db/**/*.cds",
+  "*.cds",
+];
+
+function stripCdsComments(text: string): string {
+  return text
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/(^|[^:])\/\/.*$/gm, "$1");
+}
+
+function collectNamespaceFromText(text: string): string | undefined {
+  const namespaceMatch = /\bnamespace\s+([A-Za-z_$][A-Za-z0-9_.$]*)\s*;/m.exec(stripCdsComments(text));
+  return namespaceMatch?.[1]?.trim();
+}
+
+function collectServicesFromText(text: string): string[] {
+  const services = new Set<string>();
+  const cleanedText = stripCdsComments(text);
+  const serviceRegex = /\bservice\s+([A-Za-z_$][A-Za-z0-9_.$]*)\b/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = serviceRegex.exec(cleanedText)) !== null) {
+    const serviceName = match[1]?.trim();
+
+    if (serviceName) {
+      services.add(serviceName);
+    }
+  }
+
+  return [...services];
+}
+
+function toFullServiceName(serviceName: string, namespace: string | undefined): string {
+  if (!namespace || serviceName.includes(".")) {
+    return serviceName;
+  }
+
+  return `${namespace}.${serviceName}`;
+}
+
+export async function scanCapServices(repositoryPath: string): Promise<TCdsServiceDefinition[]> {
+  const cdsFilePaths = await fg(DEFAULT_CDS_SCAN_PATTERNS, {
+    cwd: repositoryPath,
+    onlyFiles: true,
+    dot: true,
+    absolute: true,
+    unique: true,
+    ignore: [
+      "**/node_modules/**",
+      "**/dist/**",
+      "**/gen/**",
+      "**/.git/**",
+      "**/.cds/**",
+    ],
+  });
+
+  const result: TCdsServiceDefinition[] = [];
+  const keys = new Set<string>();
+
+  for (const filePath of cdsFilePaths) {
+    const text = await fs.readFile(filePath, "utf8").catch(() => "");
+    const serviceNames = collectServicesFromText(text);
+    const namespace = collectNamespaceFromText(text);
+    const relativeFilePath = path.relative(repositoryPath, filePath).replace(/\\/g, "/");
+
+    for (const serviceName of serviceNames) {
+      const fullServiceName = toFullServiceName(serviceName, namespace);
+      const key = `${fullServiceName}|${relativeFilePath}`;
+
+      if (keys.has(key)) {
+        continue;
+      }
+
+      keys.add(key);
+      result.push({
+        serviceName,
+        filePath,
+        relativeFilePath,
+        namespace,
+        fullServiceName,
+      });
+    }
+  }
+
+  return result.sort((left, right) => left.fullServiceName.localeCompare(right.fullServiceName));
+}
+
+export async function resolveDefaultCdsModel(repositoryPath: string): Promise<string> {
+  const srvPath = path.join(repositoryPath, "srv");
+
+  if (await fs.pathExists(srvPath)) {
+    return "srv";
+  }
+
+  return ".";
+}
+
+function normalizeToSnakeCase(value: string): string {
+  return value
+    .replace(/^@[^/]+\//, "")
+    .replace(/^simplemdg[-_]/i, "")
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[^A-Za-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "")
+    .replace(/_+/g, "_")
+    .toLowerCase();
+}
+
+async function readPackageName(repositoryPath: string): Promise<string | undefined> {
+  const packageJsonPath = path.join(repositoryPath, "package.json");
+
+  if (!(await fs.pathExists(packageJsonPath))) {
+    return undefined;
+  }
+
+  const packageJson = await fs.readJson(packageJsonPath).catch(() => undefined) as { name?: unknown } | undefined;
+  return typeof packageJson?.name === "string" ? packageJson.name : undefined;
+}
+
+export async function buildDefaultCompileOutputFileNames(options: {
+  repositoryPath: string;
+  serviceName?: string;
+  to: string;
+}): Promise<string[]> {
+  const extension = options.to === "edmx" ? "xml" : options.to;
+  const names = new Set<string>();
+  const packageName = await readPackageName(options.repositoryPath);
+  const folderName = path.basename(options.repositoryPath);
+
+  if (packageName) {
+    names.add(`${normalizeToSnakeCase(packageName)}.${extension}`);
+  }
+
+  if (folderName) {
+    names.add(`${normalizeToSnakeCase(folderName)}.${extension}`);
+  }
+
+  if (options.serviceName) {
+    names.add(`${normalizeToSnakeCase(options.serviceName)}.${extension}`);
+  }
+
+  return [...names].filter((value) => value !== `.${extension}`);
+}
+
+export function buildDefaultEdmxOutputFileName(serviceName: string): string {
+  return `${normalizeToSnakeCase(serviceName)}.xml`;
+}