create-objectstack 17.0.0-rc.2 → 17.0.0-rc.4

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # create-objectstack
 
+## 17.0.0-rc.4
+
+### Patch Changes
+
+- 8d41998: fix(create-objectstack): scaffolding a remote template no longer produces a project that cannot build (#4926)
+
+  `npx create-objectstack@latest my-app -t todo` (and `compliance`, `content`,
+  `contracts`, `procurement`) generated a project that failed `objectstack build`
+  immediately — 5 of the 6 offered templates. Only the bundled `blank` worked.
+
+  The scaffolder read the template's original namespace from
+  `objectstack.manifest.json`, and that filename names two different documents.
+  The bundled template's is app-shaped and carries `namespace`; a remote
+  template's is the template-registry document
+  (`$schema: …/template-manifest.json`) and carries none — its namespace lives
+  only in `objectstack.config.ts`. So the value came back `undefined` for every
+  remote template and the object-name rewrite was skipped, while the config's
+  `namespace:` was rewritten anyway. The result was `namespace: 'my_app'` sitting
+  next to `name: 'todo_task'`, which the `${namespace}_${shortName}` rule rejects.
+  Across the five templates, 74 object names were left unrewritten.
+
+  `objectstack.config.ts` is now the authority for the template namespace (it
+  holds the very literal the scaffolder overwrites, so the two cannot disagree),
+  with the manifest as fallback. The rewrite also verifies itself: any surviving
+  stale prefix throws at the scaffold, naming the files and lines, instead of
+  surfacing as a build failure on the user's first command.
+
 ## 17.0.0-rc.2
 
 ## 17.0.0-rc.1

package/dist/index.js

@@ -1,8 +1,8 @@
 // src/index.ts
 import { Command } from "commander";
 import chalk from "chalk";
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 import os from "os";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
@@ -47,10 +47,77 @@ function copyDir(src, dest, collected, rel = "") {
   }
 }
 
+// src/rewrite-identity.ts
+import fs2 from "fs";
+import path2 from "path";
+var CONFIG_NAMESPACE_RE = /\bnamespace:\s*(['"`])([a-z0-9_]+)\1/i;
+function readTemplateNamespace(targetDir) {
+  const configPath = path2.join(targetDir, "objectstack.config.ts");
+  if (fs2.existsSync(configPath)) {
+    const m = CONFIG_NAMESPACE_RE.exec(fs2.readFileSync(configPath, "utf8"));
+    if (m) return m[2];
+  }
+  const manifestPath = path2.join(targetDir, "objectstack.manifest.json");
+  if (fs2.existsSync(manifestPath)) {
+    try {
+      const m = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+      if (typeof m.namespace === "string" && m.namespace) return m.namespace;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function tsFiles(dir, out = []) {
+  if (!fs2.existsSync(dir)) return out;
+  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules") continue;
+      tsFiles(full, out);
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+var namePrefixRe = (ns, flags) => new RegExp(`(\\bname:\\s*)(['"\`])${ns}_([a-z0-9_]+)\\2`, flags);
+function rewriteObjectNamePrefix(dir, from, to) {
+  let rewritten = 0;
+  for (const file of tsFiles(dir)) {
+    const before = fs2.readFileSync(file, "utf8");
+    const after = before.replace(
+      namePrefixRe(from, "g"),
+      (_m, prefix, q, rest) => {
+        rewritten++;
+        return `${prefix}${q}${to}_${rest}${q}`;
+      }
+    );
+    if (after !== before) fs2.writeFileSync(file, after);
+  }
+  return rewritten;
+}
+function findStaleNamespacePrefixes(dir, oldNs) {
+  const re = namePrefixRe(oldNs, "");
+  const stale = [];
+  for (const file of tsFiles(dir)) {
+    const lines = fs2.readFileSync(file, "utf8").split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (re.test(lines[i])) {
+        stale.push({
+          file: path2.relative(dir, file),
+          line: i + 1,
+          text: lines[i].trim()
+        });
+      }
+    }
+  }
+  return stale;
+}
+
 // src/index.ts
 var __filename2 = fileURLToPath(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var BUNDLED_TEMPLATES_DIR = path2.resolve(__dirname2, "templates");
+var __dirname2 = path3.dirname(__filename2);
+var BUNDLED_TEMPLATES_DIR = path3.resolve(__dirname2, "templates");
 var REMOTE_REPO = "objectstack-ai/templates";
 var REMOTE_BRANCH = "main";
 var REMOTE_TARBALL_URL = `https://codeload.github.com/${REMOTE_REPO}/tar.gz/refs/heads/${REMOTE_BRANCH}`;
@@ -96,8 +163,8 @@ function sanitizeNamespace(name) {
 }
 function readCliVersion() {
   try {
-    const pkgPath = path2.resolve(__dirname2, "..", "package.json");
-    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+    const pkgPath = path3.resolve(__dirname2, "..", "package.json");
+    const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
     return String(pkg.version || "0.0.0");
   } catch {
     return "0.0.0";
@@ -132,8 +199,8 @@ function detectPackageManager() {
   }
 }
 function loadBundled(templateDir, targetDir) {
-  const src = path2.join(BUNDLED_TEMPLATES_DIR, templateDir);
-  if (!fs2.existsSync(src)) {
+  const src = path3.join(BUNDLED_TEMPLATES_DIR, templateDir);
+  if (!fs3.existsSync(src)) {
     throw new Error(`Bundled template missing on disk: ${src}`);
   }
   const collected = [];
@@ -154,12 +221,12 @@ async function downloadTarball(url, destFile) {
   });
 }
 async function loadRemote(pkgName, targetDir) {
-  const tmp = await mkdtemp(path2.join(os.tmpdir(), "create-objectstack-"));
+  const tmp = await mkdtemp(path3.join(os.tmpdir(), "create-objectstack-"));
   try {
-    const tarball = path2.join(tmp, "templates.tar.gz");
+    const tarball = path3.join(tmp, "templates.tar.gz");
     printStep(`Fetching template "${pkgName}" from ${REMOTE_REPO}@${REMOTE_BRANCH}\u2026`);
     await downloadTarball(REMOTE_TARBALL_URL, tarball);
-    fs2.mkdirSync(targetDir, { recursive: true });
+    fs3.mkdirSync(targetDir, { recursive: true });
     const collected = [];
     await pipeline(
       createReadStream(tarball),
@@ -190,98 +257,79 @@ async function loadRemote(pkgName, targetDir) {
     await rm(tmp, { recursive: true, force: true });
   }
 }
-function walkAndRewriteTs(dir, fn) {
-  if (!fs2.existsSync(dir)) return;
-  for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
-    const full = path2.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      walkAndRewriteTs(full, fn);
-    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
-      const before = fs2.readFileSync(full, "utf8");
-      const after = fn(before);
-      if (after !== before) fs2.writeFileSync(full, after);
-    }
-  }
-}
 function rewriteProjectIdentity(targetDir, projectName, namespace) {
   const title = toTitleCase(projectName);
-  let templateNamespace;
-  const manifestPathPre = path2.join(targetDir, "objectstack.manifest.json");
-  if (fs2.existsSync(manifestPathPre)) {
-    try {
-      const m = JSON.parse(fs2.readFileSync(manifestPathPre, "utf8"));
-      if (typeof m.namespace === "string") templateNamespace = m.namespace;
-    } catch {
-    }
-  }
-  const pkgPath = path2.join(targetDir, "package.json");
-  if (fs2.existsSync(pkgPath)) {
+  const templateNamespace = readTemplateNamespace(targetDir);
+  const pkgPath = path3.join(targetDir, "package.json");
+  if (fs3.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf8"));
       pkg.name = projectName;
       syncObjectStackDeps(pkg, readCliVersion());
-      fs2.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+      fs3.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
     } catch {
     }
   }
-  const manifestPath = path2.join(targetDir, "objectstack.manifest.json");
-  if (fs2.existsSync(manifestPath)) {
+  const manifestPath = path3.join(targetDir, "objectstack.manifest.json");
+  if (fs3.existsSync(manifestPath)) {
     try {
-      const m = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
+      const m = JSON.parse(fs3.readFileSync(manifestPath, "utf8"));
       m.name = projectName;
       m.displayName = title;
       if ("namespace" in m) m.namespace = namespace;
-      fs2.writeFileSync(manifestPath, JSON.stringify(m, null, 2) + "\n");
+      fs3.writeFileSync(manifestPath, JSON.stringify(m, null, 2) + "\n");
     } catch {
     }
   }
-  const configPath = path2.join(targetDir, "objectstack.config.ts");
-  if (fs2.existsSync(configPath)) {
-    let cfg = fs2.readFileSync(configPath, "utf8");
+  const configPath = path3.join(targetDir, "objectstack.config.ts");
+  if (fs3.existsSync(configPath)) {
+    let cfg = fs3.readFileSync(configPath, "utf8");
     cfg = cfg.replace(/(\bid:\s*)(['"`])[^'"`]*\2/, `$1$2${projectName}$2`);
     cfg = cfg.replace(/(\bnamespace:\s*)(['"`])[^'"`]*\2/, `$1$2${namespace}$2`);
     cfg = cfg.replace(/(\bname:\s*)(['"`])[^'"`]*\2/, `$1$2${title}$2`);
-    fs2.writeFileSync(configPath, cfg);
+    fs3.writeFileSync(configPath, cfg);
   }
-  if (namespace !== templateNamespace && templateNamespace) {
-    const prefixRe = new RegExp(
-      `(\\bname:\\s*)(['"\`])${templateNamespace}_([a-z0-9_]+)\\2`,
-      "g"
-    );
-    walkAndRewriteTs(
-      path2.join(targetDir, "src"),
-      (src) => src.replace(
-        prefixRe,
-        (_m, prefix, q, rest) => `${prefix}${q}${namespace}_${rest}${q}`
-      )
-    );
+  if (templateNamespace && namespace !== templateNamespace) {
+    const srcDir = path3.join(targetDir, "src");
+    rewriteObjectNamePrefix(srcDir, templateNamespace, namespace);
+    const stale = findStaleNamespacePrefixes(srcDir, templateNamespace);
+    if (stale.length > 0) {
+      const shown = stale.slice(0, 5).map((s) => `    src/${s.file}:${s.line}  ${s.text}`).join("\n");
+      const more = stale.length > 5 ? `
+    \u2026and ${stale.length - 5} more` : "";
+      throw new Error(
+        `Scaffolding rewrote the namespace to '${namespace}' but ${stale.length} object name(s) still carry the template's '${templateNamespace}_' prefix:
+${shown}${more}
+The generated project would fail 'objectstack build' on the \${namespace}_\${shortName} rule. This is a bug in the scaffolder, not in your input.`
+      );
+    }
   }
-  const readmePath = path2.join(targetDir, "README.md");
-  if (fs2.existsSync(readmePath)) {
-    let md = fs2.readFileSync(readmePath, "utf8");
+  const readmePath = path3.join(targetDir, "README.md");
+  if (fs3.existsSync(readmePath)) {
+    let md = fs3.readFileSync(readmePath, "utf8");
     md = md.replace(/^#\s+.*$/m, `# ${title}`);
-    fs2.writeFileSync(readmePath, md);
+    fs3.writeFileSync(readmePath, md);
   }
   writeAgentGuides(targetDir, title, projectName);
 }
 function writeAgentGuides(targetDir, title, projectName) {
-  const templatePath = path2.join(BUNDLED_TEMPLATES_DIR, "AGENTS.md");
+  const templatePath = path3.join(BUNDLED_TEMPLATES_DIR, "AGENTS.md");
   let template;
   try {
-    template = fs2.readFileSync(templatePath, "utf8");
+    template = fs3.readFileSync(templatePath, "utf8");
   } catch (err) {
     if (err?.code === "ENOENT") return;
     throw err;
   }
   const rendered = template.replace(/\{\{PROJECT_TITLE\}\}/g, title).replace(/\{\{PROJECT_NAME\}\}/g, projectName);
-  writeIfAbsent(path2.join(targetDir, "AGENTS.md"), rendered);
-  const copilotPath = path2.join(targetDir, ".github", "copilot-instructions.md");
-  fs2.mkdirSync(path2.dirname(copilotPath), { recursive: true });
+  writeIfAbsent(path3.join(targetDir, "AGENTS.md"), rendered);
+  const copilotPath = path3.join(targetDir, ".github", "copilot-instructions.md");
+  fs3.mkdirSync(path3.dirname(copilotPath), { recursive: true });
   writeIfAbsent(copilotPath, rendered);
 }
 function writeIfAbsent(filePath, contents) {
   try {
-    fs2.writeFileSync(filePath, contents, { flag: "wx" });
+    fs3.writeFileSync(filePath, contents, { flag: "wx" });
   } catch (err) {
     if (err?.code !== "EEXIST") throw err;
   }
@@ -303,24 +351,24 @@ var program = new Command().name("create-objectstack").description("Create a new
     process.exit(1);
   }
   const cwd = process.cwd();
-  const projectName = name || path2.basename(cwd);
+  const projectName = name || path3.basename(cwd);
   const namespace = sanitizeNamespace(projectName);
-  const targetDir = name ? path2.resolve(cwd, name) : cwd;
+  const targetDir = name ? path3.resolve(cwd, name) : cwd;
   const isCurrentDir = targetDir === cwd;
   printKV("Environment", projectName);
   printKV("Namespace", namespace);
   printKV("Template", `${options.template} \u2014 ${template.description}`);
   printKV("Directory", targetDir);
   console.log("");
-  if (!isCurrentDir && fs2.existsSync(targetDir)) {
-    const existing = fs2.readdirSync(targetDir);
+  if (!isCurrentDir && fs3.existsSync(targetDir)) {
+    const existing = fs3.readdirSync(targetDir);
     if (existing.length > 0) {
       printError(`Directory already exists and is not empty: ${targetDir}`);
       process.exit(1);
     }
   }
   try {
-    fs2.mkdirSync(targetDir, { recursive: true });
+    fs3.mkdirSync(targetDir, { recursive: true });
     let createdFiles;
     if (template.source.kind === "bundled") {
       createdFiles = loadBundled(template.source.dir, targetDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-objectstack",
-  "version": "17.0.0-rc.2",
+  "version": "17.0.0-rc.4",
   "description": "Create a new ObjectStack project — npx create-objectstack",
   "bin": {
     "create-objectstack": "./bin/create-objectstack.js"