@kosdev-code/kos-codegen-core 0.1.0-next.792 → 0.1.0-next.797

package/index.mjs

@@ -515,6 +515,296 @@ function generateInit(codegenFs, options) {
   };
   writeJson(codegenFs, "nx.json", nxConfig);
 }
+const BUILD_SCRIPTS = [
+  "build/build-ui.sh",
+  "build/build-java.sh",
+  "build/build-release.sh",
+  "build/release_version_prebuild.sh",
+  "build/docker-build.sh"
+];
+function generatePolyglotWorkspace(codegenFs, templateDir, options) {
+  const hasUi = (options.type ?? "polyglot") !== "java";
+  const normalized = normalizeAllValues({ name: options.name });
+  const vars = {
+    ...normalized,
+    hasUi,
+    keyset: options.keyset || "prod.kos",
+    appUiName: `${normalized.nameDashCase}-ui`,
+    nodeVersion: options.nodeVersion || process.version.replace(/^v/, ""),
+    jdkMajor: options.jdkMajor || "17",
+    mavenVersion: options.mavenVersion || "3.9.9"
+  };
+  generateFilesFromTemplates(
+    codegenFs,
+    path.join(templateDir, "root"),
+    ".",
+    vars
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path.join(templateDir, "build"),
+    "build",
+    vars
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path.join(templateDir, "github"),
+    ".github",
+    vars
+  );
+  generateFilesFromTemplates(
+    codegenFs,
+    path.join(templateDir, "java"),
+    "java",
+    vars
+  );
+  return { executablePaths: [...BUILD_SCRIPTS] };
+}
+const UI_PROJECT_DIRS = [
+  "apps",
+  "libs",
+  "plugins",
+  "splash",
+  "themes",
+  "content",
+  "translations"
+];
+function joinArtifactPath(outputPath, fileName) {
+  return `${outputPath.replace(/\/+$/, "")}/${fileName}`;
+}
+function discoverUiArtifacts(codegenFs) {
+  const artifacts = [];
+  for (const dir of UI_PROJECT_DIRS) {
+    for (const file of codegenFs.listFiles(`ui/${dir}`)) {
+      if (!file.endsWith("project.json")) continue;
+      const raw = codegenFs.read(file);
+      if (raw === null) continue;
+      let project;
+      try {
+        project = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      const name = project.name;
+      if (!name) continue;
+      const kabOptions = project.targets?.kab?.options;
+      if (kabOptions?.outputPath && kabOptions?.kabName) {
+        artifacts.push({
+          id: name,
+          filename: `ui/${joinArtifactPath(kabOptions.outputPath, kabOptions.kabName)}`
+        });
+      } else if (project.targets?.splash) {
+        artifacts.push({
+          id: name,
+          filename: `ui/dist/archives/packages/${name}/${name}.kab`,
+          layer: 1
+        });
+      }
+    }
+  }
+  for (const file of codegenFs.listFiles("ui/external")) {
+    if (!file.endsWith(".kab")) continue;
+    const base = file.slice(file.lastIndexOf("/") + 1, -".kab".length);
+    artifacts.push({ id: base, filename: file });
+  }
+  return artifacts;
+}
+function discoverJavaArtifacts(codegenFs) {
+  const aggregator = codegenFs.read("java/pom.xml");
+  if (aggregator === null) return [];
+  const artifacts = [];
+  for (const match of aggregator.matchAll(/<module>([^<]+)<\/module>/g)) {
+    const moduleDir = match[1];
+    const pom = codegenFs.read(`java/${moduleDir}/pom.xml`);
+    if (pom === null || !pom.includes("kos-kab-maven-plugin")) continue;
+    const withoutParent = pom.replace(/<parent>[\s\S]*?<\/parent>/, "");
+    const artifactId = withoutParent.match(
+      /<artifactId>([^<]+)<\/artifactId>/
+    )?.[1];
+    if (!artifactId) continue;
+    artifacts.push({
+      id: moduleDir,
+      // eslint-disable-next-line no-template-curly-in-string
+      filename: `java/${moduleDir}/target/${artifactId}-\${KOS_STD_VERSION_REGEX}.kab`
+    });
+  }
+  return artifacts;
+}
+function syncManifest(codegenFs, manifestPath, discovered, prune) {
+  const raw = codegenFs.read(manifestPath);
+  if (raw === null) return null;
+  const manifest = JSON.parse(raw);
+  const existing = manifest.artifacts ?? [];
+  const byFilename = new Map(discovered.map((d) => [d.filename, d]));
+  const kept = [];
+  const stale = [];
+  const pruned = [];
+  for (const entry of existing) {
+    if (byFilename.has(entry.filename)) {
+      kept.push(entry);
+      byFilename.delete(entry.filename);
+    } else if (prune) {
+      pruned.push(entry.id ?? entry.filename);
+    } else {
+      kept.push(entry);
+      stale.push(entry.id ?? entry.filename);
+    }
+  }
+  const added = [];
+  for (const artifact of byFilename.values()) {
+    kept.push({
+      id: artifact.id,
+      filename: artifact.filename,
+      artifactstore: "kos-cdn",
+      marketplace: 1,
+      ...artifact.layer !== void 0 ? { layer: artifact.layer } : {}
+    });
+    added.push(artifact.id);
+  }
+  if (added.length > 0 || pruned.length > 0) {
+    manifest.artifacts = kept;
+    codegenFs.write(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  }
+  return { added, stale, pruned };
+}
+function syncCiManifests(codegenFs, options = {}) {
+  const prune = options.prune ?? false;
+  const ui = discoverUiArtifacts(codegenFs);
+  const java = discoverJavaArtifacts(codegenFs);
+  const manifests = {};
+  const plan = [
+    [".github/build-ui.json", ui],
+    [".github/build-java.json", java],
+    [".github/build-release.json", [...ui, ...java]]
+  ];
+  for (const [manifestPath, discovered] of plan) {
+    const result = syncManifest(codegenFs, manifestPath, discovered, prune);
+    if (result) {
+      manifests[manifestPath] = result;
+    }
+  }
+  return { manifests, discovered: { ui, java } };
+}
+function ensureJavaAggregatorPom(codegenFs, options) {
+  const pomPath = "java/pom.xml";
+  const existing = codegenFs.read(pomPath);
+  if (existing === null) {
+    codegenFs.write(
+      pomPath,
+      `<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>${options.groupId}</groupId>
+  <artifactId>${options.artifactId}</artifactId>
+  <version>0.0.0-SNAPSHOT</version>
+  <packaging>pom</packaging>
+  <modules>
+    <module>${options.moduleName}</module>
+  </modules>
+</project>
+`
+    );
+    return;
+  }
+  if (existing.includes(`<module>${options.moduleName}</module>`)) {
+    return;
+  }
+  codegenFs.write(
+    pomPath,
+    existing.replace(
+      "</modules>",
+      `  <module>${options.moduleName}</module>
+  </modules>`
+    )
+  );
+}
+function finalizeArchetypeModule(codegenFs, options) {
+  const { moduleName, kosVersion, kabPluginVersion, apiInfoVersion } = options;
+  const notes = [];
+  const pomPath = `java/${moduleName}/pom.xml`;
+  let pom = codegenFs.read(pomPath);
+  if (pom === null) {
+    throw new Error(`Generated module pom not found: ${pomPath}`);
+  }
+  if (pom.includes("<kos.version>0.0.0-SNAPSHOT</kos.version>")) {
+    if (kosVersion) {
+      pom = pom.replace(
+        "<kos.version>0.0.0-SNAPSHOT</kos.version>",
+        `<kos.version>${kosVersion}</kos.version>`
+      );
+    } else {
+      notes.push(
+        "kos.version is 0.0.0-SNAPSHOT — set it to a released kos-bom version before building"
+      );
+    }
+  }
+  if (pom.includes("${kos-kab-maven-plugin.version}") && !pom.includes("<kos-kab-maven-plugin.version>")) {
+    if (kabPluginVersion) {
+      pom = pom.replace(
+        /(<kos\.version>[^<]*<\/kos\.version>)/,
+        `$1
+        <kos-kab-maven-plugin.version>${kabPluginVersion}</kos-kab-maven-plugin.version>`
+      );
+    } else {
+      notes.push(
+        "the ${kos-kab-maven-plugin.version} property is referenced but undefined — add it before building"
+      );
+    }
+  }
+  const unversionedApiInfo = /<artifactId>api-info<\/artifactId>(\s*)<\/dependency>/;
+  if (unversionedApiInfo.test(pom)) {
+    if (apiInfoVersion) {
+      pom = pom.replace(
+        unversionedApiInfo,
+        `<artifactId>api-info</artifactId>$1  <version>${apiInfoVersion}</version>$1</dependency>`
+      );
+    } else {
+      notes.push(
+        "api-info has no version and is not managed by the kos-bom — add one before building"
+      );
+    }
+  }
+  codegenFs.write(pomPath, pom);
+  const githubDir = `java/${moduleName}/github`;
+  if (codegenFs.exists(githubDir)) {
+    for (const file of codegenFs.listFiles(githubDir)) {
+      codegenFs.delete(file);
+    }
+  }
+  const gitignore = codegenFs.read(`java/${moduleName}/gitignore`);
+  if (gitignore !== null) {
+    codegenFs.write(`java/${moduleName}/.gitignore`, gitignore);
+    codegenFs.delete(`java/${moduleName}/gitignore`);
+  }
+  return notes;
+}
+function addJavaArtifactToManifests(codegenFs, options) {
+  const { moduleName } = options;
+  for (const manifestPath of [
+    ".github/build-java.json",
+    ".github/build-release.json"
+  ]) {
+    const raw = codegenFs.read(manifestPath);
+    if (raw === null) {
+      continue;
+    }
+    const manifest = JSON.parse(raw);
+    manifest.artifacts = manifest.artifacts ?? [];
+    if (manifest.artifacts.some(
+      (artifact) => artifact.id === moduleName
+    )) {
+      continue;
+    }
+    manifest.artifacts.push({
+      id: moduleName,
+      // eslint-disable-next-line no-template-curly-in-string
+      filename: `java/${moduleName}/target/${moduleName}-\${KOS_STD_VERSION_REGEX}.kab`,
+      artifactstore: "kos-cdn",
+      marketplace: 1
+    });
+    codegenFs.write(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  }
+}
 function normalizeOptions(codegenFs, options, projects) {
   const toNormalize = {
     name: options.name
@@ -560,6 +850,103 @@ function normalizeOptions(codegenFs, options, projects) {
     template: ""
   };
 }
+const UPDATE_RELEASE_VERSION_SCRIPT_PATH = "tools/scripts/update-release-version.mjs";
+function buildKabTargets(options) {
+  const {
+    name,
+    archiveDir = "packages",
+    descriptorDir,
+    buildTarget = "build"
+  } = options;
+  const outputPath = `dist/archives/${archiveDir}/${name}/`;
+  const targets = {
+    kab: {
+      command: `node tools/scripts/kabtool.mjs build ${name} && node tools/scripts/kabtool.mjs list ${name} `,
+      options: {
+        outputPath,
+        zipName: "ui.zip",
+        kabName: `${name}.kab`
+      },
+      dependsOn: ["zip"]
+    },
+    zip: {
+      command: `node tools/scripts/archiver.js ${name}`,
+      options: {
+        outputPath,
+        zipName: "ui.zip"
+      },
+      dependsOn: descriptorDir ? [buildTarget, "descriptor"] : [buildTarget]
+    }
+  };
+  if (descriptorDir) {
+    targets.descriptor = {
+      command: `node tools/scripts/descriptor.mjs ${name}`,
+      options: {
+        outputPath: `dist/${descriptorDir}`,
+        fileName: "descriptor.json"
+      },
+      dependsOn: ["build"]
+    };
+  }
+  targets.version = {
+    command: `node ${UPDATE_RELEASE_VERSION_SCRIPT_PATH} ${name} {args.ver}`,
+    options: {},
+    dependsOn: []
+  };
+  return targets;
+}
+const UPDATE_RELEASE_VERSION_SCRIPT = `import devkit from "@nx/devkit";
+import { resolve } from "path";
+import { readFileSync, writeFileSync } from "fs";
+import prettier from "prettier";
+
+// KOS artifact versioning: stamps the project's .kos.json "version" field
+// (which kabtool bakes into the KAB). Never touches package.json.
+// Driven by tag-based releases:
+//   nx run-many --target=version --args=--ver=$KOSBUILD_VERSION
+
+const { readCachedProjectGraph } = devkit;
+const [, , name, versionArg] = process.argv;
+
+// "{args.ver}" arrives literally when the target runs without --args=--ver=<v>;
+// treat that (or a missing arg) as "report current version, change nothing".
+const version =
+  versionArg && !versionArg.startsWith("{args") ? versionArg : undefined;
+
+if (!name) {
+  console.error("usage: update-release-version.mjs <project> <version>");
+  process.exit(1);
+}
+
+const graph = readCachedProjectGraph();
+const project = graph.nodes[name];
+if (!project) {
+  console.error("Unknown project: " + name);
+  process.exit(1);
+}
+
+const kosJsonPath = resolve(process.cwd(), project.data.root, ".kos.json");
+let kosJson;
+try {
+  kosJson = JSON.parse(readFileSync(kosJsonPath, "utf8"));
+} catch {
+  console.error("Missing or invalid .kos.json: " + kosJsonPath);
+  process.exit(1);
+}
+
+if (!version) {
+  console.log(name + ": " + kosJson.version + " (no --ver given; unchanged)");
+  process.exit(0);
+}
+
+const prettierOptions = await prettier.resolveConfig(kosJsonPath);
+const output = await prettier.format(
+  JSON.stringify({ ...kosJson, version }, null, 2),
+  { ...prettierOptions, parser: "json" }
+);
+writeFileSync(kosJsonPath, output);
+console.log(name + ": version -> " + version);
+`;
 function appendBarrelExport(codegenFs, indexPath, exportPath) {
   const exportLine = `export * from '${exportPath}'`;
   const content = codegenFs.read(indexPath) ?? "";
@@ -2985,6 +3372,8 @@ export {
   PLUGIN_TYPES,
   PluginHandlerFactory,
   TrackingFileSystem,
+  UPDATE_RELEASE_VERSION_SCRIPT,
+  UPDATE_RELEASE_VERSION_SCRIPT_PATH,
   ValidationError,
   addChildToModel,
   addComputedToModel,
@@ -2992,17 +3381,23 @@ export {
   addContainerSupportToModel,
   addDependencyToModel,
   addFutureToModel,
+  addJavaArtifactToManifests,
   addKosModelConfiguration,
   addModelEffectToModel,
   addPropertyToModel,
   addServiceRequestToModel,
   addTopicHandlerToModel,
   appendBarrelExport,
+  buildKabTargets,
   camelCase,
   constantCase,
   dashCase,
   describeModel,
+  discoverJavaArtifacts,
   discoverProjects,
+  discoverUiArtifacts,
+  ensureJavaAggregatorPom,
+  finalizeArchetypeModule,
   findProjectByName,
   findProjectForPath,
   formatFiles,
@@ -3014,6 +3409,7 @@ export {
   generateHook,
   generateInit,
   generateModel,
+  generatePolyglotWorkspace,
   generateSplashProject,
   getCodegenLogger,
   getCurrentDirectoryName,
@@ -3031,6 +3427,7 @@ export {
   readNxJson,
   resolveModelFilePath,
   setCodegenLogger,
+  syncCiManifests,
   updateJson,
   updateModelIndex,
   validateModel,