@jtl-software/create-cloud-app 0.0.2 → 0.0.4

package/README.md

@@ -0,0 +1,43 @@
+# @jtl-software/create-cloud-app
+
+Scaffold a [JTL Platform](https://www.jtl-software.com/) cloud app in seconds.
+
+## Quick start
+
+```bash
+npm create @jtl-software/cloud-app
+```
+
+The CLI prompts you for:
+
+- **App name** — directory name, package name, and manifest identifier
+- **Description** — placed in the app manifest
+- **Backend** — Node.js (Express + TypeScript) or .NET (ASP.NET Core + FastEndpoints)
+- **Frontend** — React (Vite + Tailwind + JTL Platform UI)
+
+Then start developing:
+
+```bash
+cd my-app
+npm install
+npm run dev
+```
+
+## What's included
+
+- Pre-configured monorepo with [Turborepo](https://turbo.build/)
+- Frontend with welcome pages explaining each app mode and manifest mapping
+- Backend with JWT verification, tenant connection, and ERP API proxy
+- Ready-to-register `manifest.json`
+
+## After scaffolding
+
+1. Register your manifest in the [Partner Portal](https://partner.jtl-cloud.com/)
+2. Add your Client ID and Secret to the backend config
+3. Install the app from [JTL-Cloud Hub](https://hub.jtl-cloud.com/) under "Apps in development"
+
+## Documentation
+
+- [JTL Developer Platform](https://developer.jtl-software.com/)
+- [Partner Portal](https://partner.jtl-cloud.com/)
+- [JTL-Cloud Hub](https://hub.jtl-cloud.com/)

package/dist/index.js

@@ -7,8 +7,6 @@ import pc from "picocolors";
 // src/scaffold.ts
 import fs from "fs";
 import path from "path";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
 function toPascalCase(kebab) {
   return kebab.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
@@ -24,14 +22,30 @@ var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".eot",
   ".svg"
 ]);
-function copyDir(src, dest, replacements) {
+var PACKAGE_JSON_STRIP_FIELDS = [
+  "cloudAppTemplate",
+  "publishConfig",
+  "description"
+];
+function transformPackageJson(content, appName, templateType, replacements) {
+  const pkg = JSON.parse(content);
+  pkg.name = `${appName}-${templateType}`;
+  for (const field of PACKAGE_JSON_STRIP_FIELDS) {
+    delete pkg[field];
+  }
+  let result = JSON.stringify(pkg, null, 2);
+  for (const [key, value] of Object.entries(replacements)) {
+    result = result.replaceAll(key, value);
+  }
+  return result + "\n";
+}
+function copyDir(src, dest, replacements, templateType, appName) {
   fs.mkdirSync(dest, { recursive: true });
   for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    if (entry.name === "package.json") continue;
     const srcPath = path.join(src, entry.name);
     let destName = entry.name;
-    if (destName.startsWith("_")) {
-      destName = destName.startsWith("_git") ? `.${destName.slice(1)}` : destName.slice(1);
+    if (destName.startsWith("_git")) {
+      destName = `.${destName.slice(1)}`;
     }
     for (const [key, value] of Object.entries(replacements)) {
       destName = destName.replaceAll(key, value);
@@ -39,6 +53,12 @@ function copyDir(src, dest, replacements) {
     const destPath = path.join(dest, destName);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath, replacements);
+    } else if (entry.name === "package.json" && templateType && appName) {
+      const content = fs.readFileSync(srcPath, "utf-8");
+      fs.writeFileSync(
+        destPath,
+        transformPackageJson(content, appName, templateType, replacements)
+      );
     } else {
       const ext = path.extname(entry.name).toLowerCase();
       if (BINARY_EXTENSIONS.has(ext)) {
@@ -53,26 +73,29 @@ function copyDir(src, dest, replacements) {
     }
   }
 }
-function resolveTemplatePackage(packageName) {
-  const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
-  return path.dirname(pkgJsonPath);
+function buildReplacements(base, template) {
+  const extra = template.meta.extraReplacements ?? {};
+  const resolved = {};
+  for (const [key, value] of Object.entries(extra)) {
+    let resolvedValue = value;
+    for (const [baseKey, baseValue] of Object.entries(base)) {
+      resolvedValue = resolvedValue.replaceAll(baseKey, baseValue);
+    }
+    resolved[key] = resolvedValue;
+  }
+  return { ...base, ...resolved };
 }
-var TEMPLATE_PACKAGES = {
-  shared: "@jtl-software/cloud-app-template-shared",
-  "react-tailwind": "@jtl-software/cloud-app-template-frontend-react",
-  "node-express": "@jtl-software/cloud-app-template-backend-node",
-  dotnet: "@jtl-software/cloud-app-template-backend-dotnet"
-};
 async function scaffold({
   appName,
   description,
   backend,
   frontend,
+  shared,
   targetDir: customTargetDir
 }) {
   const targetDir = customTargetDir ?? path.resolve(process.cwd(), appName);
   const pascalName = toPascalCase(appName);
-  const replacements = {
+  const baseReplacements = {
     "{{APP_NAME}}": appName,
     "{{APP_NAME_PASCAL}}": pascalName,
     "{{APP_DESCRIPTION}}": description
@@ -81,39 +104,38 @@ async function scaffold({
     throw new Error(`Directory "${appName}" already exists`);
   }
   fs.mkdirSync(targetDir, { recursive: true });
-  copyDir(
-    resolveTemplatePackage(TEMPLATE_PACKAGES.shared),
-    targetDir,
-    replacements
-  );
+  copyDir(shared.dir, targetDir, baseReplacements);
   const frontendDest = path.join(targetDir, "packages", "frontend");
+  const frontendReplacements = buildReplacements(baseReplacements, frontend);
   copyDir(
-    resolveTemplatePackage(TEMPLATE_PACKAGES[frontend]),
+    frontend.dir,
     frontendDest,
-    replacements
+    frontendReplacements,
+    frontend.meta.type,
+    appName
   );
-  if (backend === "node-express") {
-    const backendDest = path.join(targetDir, "packages", "backend");
-    copyDir(
-      resolveTemplatePackage(TEMPLATE_PACKAGES["node-express"]),
-      backendDest,
-      replacements
-    );
-  } else if (backend === "dotnet") {
-    const backendDest = path.join(targetDir, "backend");
-    const dotnetReplacements = { ...replacements, HelloWorldApp: pascalName };
-    copyDir(
-      resolveTemplatePackage(TEMPLATE_PACKAGES.dotnet),
-      backendDest,
-      dotnetReplacements
+  const backendDest = path.join(targetDir, "packages", "backend");
+  const backendReplacements = buildReplacements(baseReplacements, backend);
+  copyDir(
+    backend.dir,
+    backendDest,
+    backendReplacements,
+    backend.meta.type,
+    appName
+  );
+  const runtimeVersions = backend.meta.runtimeVersions ?? {};
+  if (Object.keys(runtimeVersions).length > 0) {
+    const toolVersions = Object.entries(runtimeVersions).map(([tool, version]) => `${tool} ${version}`).join("\n");
+    fs.writeFileSync(
+      path.join(targetDir, ".tool-versions"),
+      toolVersions + "\n"
     );
   }
-  const workspaces = backend === "node-express" ? ["packages/*"] : ["packages/frontend"];
   const rootPackageJson = {
     name: appName,
     version: "1.0.0",
     private: true,
-    workspaces,
+    workspaces: ["packages/*"],
     scripts: {
       dev: "turbo dev",
       build: "turbo build",
@@ -131,10 +153,49 @@ async function scaffold({
   );
 }
 
+// src/templates.ts
+import fs2 from "fs";
+import path2 from "path";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function discoverTemplates() {
+  const cliPkgPath = require2.resolve("@jtl-software/create-cloud-app/package.json");
+  const cliPkg = JSON.parse(fs2.readFileSync(cliPkgPath, "utf-8"));
+  const deps = cliPkg.dependencies ?? {};
+  const templates = [];
+  for (const packageName of Object.keys(deps)) {
+    if (!packageName.startsWith("@jtl-software/cloud-app-template-")) continue;
+    try {
+      const pkgJsonPath = require2.resolve(`${packageName}/package.json`);
+      const pkg = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const meta = pkg.cloudAppTemplate;
+      if (!meta?.type) continue;
+      templates.push({
+        packageName,
+        dir: path2.dirname(pkgJsonPath),
+        meta
+      });
+    } catch {
+    }
+  }
+  return templates;
+}
+function getTemplatesByType(templates, type) {
+  return templates.filter((t) => t.meta.type === type);
+}
+
 // src/index.ts
 async function main() {
   console.log();
-  p.intro(pc.bgCyan(pc.black(" create-jtl-app ")));
+  p.intro(pc.bgCyan(pc.black(" create-cloud-app ")));
+  const templates = discoverTemplates();
+  const backends = getTemplatesByType(templates, "backend");
+  const frontends = getTemplatesByType(templates, "frontend");
+  const shared = templates.find((t) => t.meta.type === "shared");
+  if (!backends.length || !frontends.length || !shared) {
+    p.cancel("No templates found. Ensure template packages are installed.");
+    process.exit(1);
+  }
   const answers = await p.group(
     {
       appName: () => p.text({
@@ -152,28 +213,19 @@ async function main() {
       }),
       backend: () => p.select({
         message: "Backend",
-        options: [
-          {
-            value: "node-express",
-            label: "Node.js",
-            hint: "Express + TypeScript"
-          },
-          {
-            value: "dotnet",
-            label: ".NET",
-            hint: "ASP.NET Core + FastEndpoints"
-          }
-        ]
+        options: backends.map((t) => ({
+          value: t.packageName,
+          label: t.meta.label ?? t.packageName,
+          hint: t.meta.hint
+        }))
       }),
-      frontend: () => p.select({
+      frontend: () => frontends.length === 1 ? Promise.resolve(frontends[0].packageName) : p.select({
         message: "Frontend",
-        options: [
-          {
-            value: "react-tailwind",
-            label: "React",
-            hint: "Vite + Tailwind + JTL UI"
-          }
-        ]
+        options: frontends.map((t) => ({
+          value: t.packageName,
+          label: t.meta.label ?? t.packageName,
+          hint: t.meta.hint
+        }))
       })
     },
     {
@@ -183,13 +235,20 @@ async function main() {
       }
     }
   );
+  const selectedBackend = templates.find(
+    (t) => t.packageName === answers.backend
+  );
+  const selectedFrontend = templates.find(
+    (t) => t.packageName === answers.frontend
+  );
   const s = p.spinner();
   s.start("Scaffolding project");
   await scaffold({
     appName: answers.appName,
     description: answers.description || "A JTL Platform app",
-    backend: answers.backend,
-    frontend: answers.frontend
+    backend: selectedBackend,
+    frontend: selectedFrontend,
+    shared
   });
   s.stop("Project scaffolded");
   p.note(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jtl-software/create-cloud-app",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "description": "CLI tool for scaffolding JTL Platform cloud apps",
   "bin": {
@@ -15,10 +15,10 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.10.0",
-    "@jtl-software/cloud-app-template-frontend-react": "0.0.2",
-    "@jtl-software/cloud-app-template-backend-node": "0.0.2",
-    "@jtl-software/cloud-app-template-backend-dotnet": "0.0.2",
-    "@jtl-software/cloud-app-template-shared": "0.0.2",
+    "@jtl-software/cloud-app-template-frontend-react": "0.0.4",
+    "@jtl-software/cloud-app-template-backend-node": "0.0.4",
+    "@jtl-software/cloud-app-template-backend-dotnet": "0.0.4",
+    "@jtl-software/cloud-app-template-shared": "0.0.3",
     "picocolors": "^1.1.1"
   },
   "devDependencies": {