@kdrgny/justjson 1.4.0 → 1.7.0

package/README.md

@@ -42,6 +42,9 @@ Design your schema, enter content, upload images. Everything is written to `cont
 | **Type-safe output** | Generates `types.ts` **and** a zero-dependency `content.ts` loader — `loadPosts()`, `loadSettings()` — so your content is typed in your build. |
 | **Validate in CI** | `justjson validate` checks content against the schema — broken relations, duplicate slugs, missing media, type errors. Exits non-zero on failure. |
 | **Draft / published** | Toggle an entry's status; the generated loader returns published entries by default. |
+| **One-click site** | No site yet? `init --astro` (or a button in the editor) generates a working Astro site around your content. |
+| **Ship it** | Setup snippet for your framework, one-click content commit, push to GitHub, then deploy links for Vercel and Netlify — using the `git`/`gh` already on your machine. No tokens stored. |
+| **Astro collections** | [`@kdrgny/justjson-astro`](https://www.npmjs.com/package/@kdrgny/justjson-astro) turns your content into typed Astro content collections in one line. |
 | **English or Turkish** | The editor ships in English; switch to Turkish from the project menu any time. |
 | **Export any time** | One click downloads schema + content + types as a ZIP. Nothing is ever locked in. |
 | **The endpoint is yours** | Wherever you put the JSON becomes your API — repo raw, jsDelivr, your build. |
@@ -53,7 +56,7 @@ Field types: `text` · `richtext` · `number` · `boolean` · `date` · `select`
 | Command | What it does |
 |---|---|
 | `npx @kdrgny/justjson` (or `serve`) | Starts the local editor and opens it in your browser |
-| `npx @kdrgny/justjson init [template]` | Scaffolds a schema from a template (`blog`, `cv`, `portfolio`, `docs`, `changelog`, `recipe`, `event`, `catalog`) |
+| `npx @kdrgny/justjson init [template]` | Scaffolds a schema from a template. `--astro` also generates a working site |
 | `npx @kdrgny/justjson types` | Generates `types.ts` + a typed `content.ts` loader from your schema |
 | `npx @kdrgny/justjson validate` | Checks content against the schema (`--json`, `--strict`) — great for CI |
 | `npx @kdrgny/justjson export` | Exports a ZIP snapshot (schema + content + types) |

package/dist/cli.js

@@ -6,11 +6,7 @@ var __export = (target, all) => {
 };
 
 // src/cli.ts
-import { Command } from "commander";
-
-// src/commands/export.ts
-import { writeFile as writeFile2 } from "fs/promises";
-import { join } from "path";
+import { basename as basename3 } from "path";
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/external.js
 var external_exports = {};
@@ -4712,7 +4708,12 @@ function inferProject(data) {
   return { schema: { version: 1, collections, singletons }, entries, singletons: singletonData };
 }
 
+// src/cli.ts
+import { Command } from "commander";
+
 // src/commands/export.ts
+import { writeFile as writeFile2 } from "fs/promises";
+import { join } from "path";
 import { zipSync } from "fflate";
 
 // src/fs-adapter.ts
@@ -4879,7 +4880,10 @@ var blog_default = {
         slug: "first-post",
         body: "Hello."
       }
-    ]
+    ],
+    settings: {
+      title: "My blog"
+    }
   }
 };
 
@@ -4960,7 +4964,11 @@ var catalog_default = {
         category: "Home",
         description: "Hand-made ceramic mug."
       }
-    ]
+    ],
+    store: {
+      title: "My store",
+      tagline: "Small batch, made well"
+    }
   }
 };
 
@@ -5081,7 +5089,11 @@ var cv_default = {
         company: "Acme Inc.",
         summary: "..."
       }
-    ]
+    ],
+    profile: {
+      name: "Ada Lovelace",
+      headline: "Software engineer"
+    }
   }
 };
 
@@ -5150,7 +5162,11 @@ var docs_default = {
         order: 1,
         body: "Welcome aboard."
       }
-    ]
+    ],
+    settings: {
+      title: "Docs",
+      tagline: "Everything you need to know"
+    }
   }
 };
 
@@ -5236,7 +5252,11 @@ var event_default = {
         room: "Main hall",
         description: "Welcome to the event."
       }
-    ]
+    ],
+    event: {
+      title: "My event",
+      tagline: "One day, one track"
+    }
   }
 };
 
@@ -5333,7 +5353,11 @@ var portfolio_default = {
         kind: "Web",
         body: "Project details go here."
       }
-    ]
+    ],
+    about: {
+      name: "Ada Lovelace",
+      bio: "I build things for the web."
+    }
   }
 };
 
@@ -5414,7 +5438,10 @@ var recipe_default = {
         ingredients: "- 200g pasta\n- 2 cloves garlic\n- Olive oil",
         steps: "Boil the pasta. Fry the garlic in olive oil. Toss together."
       }
-    ]
+    ],
+    kitchen: {
+      title: "My recipe box"
+    }
   }
 };
 
@@ -5454,10 +5481,15 @@ async function applyTemplate(adapter, contentDir, template) {
   const schema = parseSchema(template.schema);
   await saveSchema(adapter, schema, contentDir);
   const store = new ContentStore(adapter, schema, contentDir);
-  for (const [collection, rows] of Object.entries(template.samples)) {
-    for (const row of rows) {
+  const singletonNames = new Set(schema.singletons.map((s) => s.name));
+  for (const [name, sample] of Object.entries(template.samples)) {
+    if (!Array.isArray(sample)) {
+      if (singletonNames.has(name)) await store.writeSingleton(name, sample);
+      continue;
+    }
+    for (const row of sample) {
       const slug = slugify(typeof row.slug === "string" ? row.slug : String(row.title ?? "content"));
-      await store.writeEntry(collection, slug, row);
+      await store.writeEntry(name, slug, row);
     }
   }
   return schema;
@@ -5566,13 +5598,314 @@ function formatJson(issues) {
   return JSON.stringify({ ok: errors === 0, errors, warnings, issues }, null, 2);
 }
 
+// src/scaffold.ts
+import { access, mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+var ASTRO_VERSION = "^5.18.0";
+var LOADER_VERSION = "^1.7.0";
+var STYLE = `  <style is:global>
+    :root { color-scheme: light dark; }
+    body {
+      margin: 0 auto;
+      max-width: 44rem;
+      padding: 3rem 1.25rem 6rem;
+      font: 16px/1.65 ui-sans-serif, system-ui, sans-serif;
+    }
+    h1 { font-size: 1.9rem; line-height: 1.2; margin: 0 0 0.35rem; }
+    h2 { font-size: 1.05rem; text-transform: uppercase; letter-spacing: 0.08em; opacity: 0.6; margin: 2.75rem 0 0.75rem; }
+    ul { list-style: none; margin: 0; padding: 0; }
+    li + li { margin-top: 0.6rem; }
+    a { color: inherit; }
+    time { opacity: 0.6; font-size: 0.9rem; }
+    img { max-width: 100%; height: auto; border-radius: 8px; }
+    .body { white-space: pre-wrap; }
+  </style>`;
+function titleFieldOf(fields) {
+  const preferred = fields.find(
+    (f) => ["title", "name", "label", "role", "version"].includes(f.key)
+  );
+  return (preferred ?? fields.find((f) => f.type === "text"))?.key ?? "title";
+}
+function safePackageName(name) {
+  return slugify(name) || "my-site";
+}
+function detailPage(collection) {
+  const titleKey = titleFieldOf(collection.fields);
+  const image = collection.fields.find((f) => f.type === "image");
+  const rich = collection.fields.find((f) => f.type === "richtext");
+  const date = collection.fields.find((f) => f.type === "date");
+  const parts = [
+    `<h1>{entry.data.${titleKey} ?? entry.id}</h1>`,
+    date && `{entry.data.${date.key} && <time>{entry.data.${date.key}}</time>}`,
+    image && `{entry.data.${image.key} && <img src={\`/media/\${entry.data.${image.key}.split('/').pop()}\`} alt="" />}`,
+    rich && `{entry.data.${rich.key} && <div class="body">{entry.data.${rich.key}}</div>}`
+  ].filter(Boolean);
+  return `---
+import { getCollection } from 'astro:content'
+
+export async function getStaticPaths() {
+  const entries = await getCollection('${collection.name}')
+  return entries.map((entry) => ({ params: { slug: entry.id }, props: { entry } }))
+}
+
+const { entry } = Astro.props
+---
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{entry.data.${titleKey} ?? entry.id}</title>
+${STYLE}
+  </head>
+  <body>
+    <p><a href="/">&larr; Back</a></p>
+${parts.map((p) => `    ${p}`).join("\n")}
+  </body>
+</html>
+`;
+}
+function indexPage(schema, projectName) {
+  const singleton = schema.singletons[0];
+  const imports = ["getCollection", singleton && "getEntry"].filter(Boolean).join(", ");
+  const loads = schema.collections.map(
+    (c) => `const ${varFor(c.name)} = await getCollection('${c.name}')`
+  );
+  if (singleton) {
+    loads.unshift(`const site = await getEntry('${singleton.name}', '${singleton.name}')`);
+  }
+  const heading = singleton ? `{site?.data.${titleFieldOf(singleton.fields)} ?? '${projectName}'}` : `${projectName}`;
+  const sections = schema.collections.map((c) => {
+    const titleKey = titleFieldOf(c.fields);
+    return `    <h2>${c.label ?? c.name}</h2>
+    <ul>
+      {${varFor(c.name)}.map((entry) => (
+        <li>
+          <a href={\`/${c.name}/\${entry.id}\`}>{entry.data.${titleKey} ?? entry.id}</a>
+        </li>
+      ))}
+    </ul>`;
+  });
+  const empty = `    <p>No content yet \u2014 run <code>npx @kdrgny/justjson</code> and add some.</p>`;
+  return `---
+import { ${imports} } from 'astro:content'
+
+${loads.join("\n")}
+---
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${singleton ? `{site?.data.${titleFieldOf(singleton.fields)} ?? '${projectName}'}` : projectName}</title>
+${STYLE}
+  </head>
+  <body>
+    <h1>${heading}</h1>
+${sections.length ? sections.join("\n") : empty}
+  </body>
+</html>
+`;
+}
+function varFor(name) {
+  const camel = name.replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase());
+  return /^[a-zA-Z_$]/.test(camel) ? camel : `c${camel}`;
+}
+function astroSiteFiles(schema, projectName) {
+  const files = {
+    "package.json": `${JSON.stringify(
+      {
+        name: safePackageName(projectName),
+        type: "module",
+        version: "0.0.1",
+        private: true,
+        scripts: { dev: "astro dev", build: "astro build", preview: "astro preview" },
+        dependencies: {
+          "@kdrgny/justjson-astro": LOADER_VERSION,
+          astro: ASTRO_VERSION
+        }
+      },
+      null,
+      2
+    )}
+`,
+    "astro.config.mjs": `import { defineConfig } from 'astro/config'
+
+export default defineConfig({})
+`,
+    "tsconfig.json": `${JSON.stringify({ extends: "astro/tsconfigs/strict" }, null, 2)}
+`,
+    ".gitignore": `node_modules
+dist
+.astro
+`,
+    "src/content.config.ts": `import { justjsonCollections } from '@kdrgny/justjson-astro'
+
+// Every collection and singleton in content/_schema.json, typed from your fields.
+export const collections = await justjsonCollections()
+`,
+    "src/pages/index.astro": indexPage(schema, projectName)
+  };
+  for (const collection of schema.collections) {
+    files[`src/pages/${collection.name}/[slug].astro`] = detailPage(collection);
+  }
+  return files;
+}
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeAstroSite(root2, schema, projectName) {
+  const files = astroSiteFiles(schema, projectName);
+  const result = { written: [], skipped: [] };
+  for (const [relative, contents] of Object.entries(files)) {
+    const target = join4(root2, relative);
+    if (await exists(target)) {
+      result.skipped.push(relative);
+      continue;
+    }
+    await mkdir2(dirname2(target), { recursive: true });
+    await writeFile3(target, contents, "utf8");
+    result.written.push(relative);
+  }
+  return result;
+}
+
 // src/server.ts
 import { exec } from "child_process";
-import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
-import { basename as basename2, dirname as dirname2, extname, join as join4, normalize } from "path";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import { basename as basename2, dirname as dirname3, extname, join as join6, normalize } from "path";
 import { fileURLToPath } from "url";
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
+
+// src/detect.ts
+import { readFile as readFile2 } from "fs/promises";
+import { join as join5 } from "path";
+var SIGNATURES = [
+  ["astro", "astro"],
+  ["next", "next"],
+  ["nuxt", "nuxt"],
+  ["sveltekit", "@sveltejs/kit"],
+  ["vite", "vite"]
+];
+async function detectFramework(root2) {
+  let pkg;
+  try {
+    pkg = JSON.parse(await readFile2(join5(root2, "package.json"), "utf8"));
+  } catch {
+    return "unknown";
+  }
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  for (const [framework, dependency] of SIGNATURES) {
+    if (deps[dependency]) return framework;
+  }
+  return "node";
+}
+
+// src/git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var run = promisify(execFile);
+function remoteWebUrl(remote) {
+  if (!remote) return null;
+  const ssh = remote.match(/^(?:ssh:\/\/)?git@([^:/]+)[:/](.+?)(?:\.git)?$/);
+  if (ssh) return `https://${ssh[1]}/${ssh[2]}`;
+  const https = remote.match(/^https?:\/\/(?:[^@]+@)?(.+?)(?:\.git)?$/);
+  if (https) return `https://${https[1]}`;
+  return null;
+}
+async function git(root2, args) {
+  const { stdout } = await run("git", args, { cwd: root2 });
+  return stdout.trim();
+}
+async function tryGit(root2, args) {
+  try {
+    return await git(root2, args);
+  } catch {
+    return null;
+  }
+}
+async function hasGh() {
+  try {
+    await run("gh", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function gitStatus(root2, contentDir) {
+  const inside = await tryGit(root2, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") {
+    return {
+      isRepo: false,
+      branch: null,
+      hasRemote: false,
+      remoteUrl: null,
+      remoteWebUrl: null,
+      pendingFiles: 0,
+      hasGh: await hasGh()
+    };
+  }
+  const branch = await tryGit(root2, ["branch", "--show-current"]);
+  const remoteUrl = await tryGit(root2, ["remote", "get-url", "origin"]);
+  const porcelain = await tryGit(root2, ["status", "--porcelain", "-uall", "--", contentDir]) ?? "";
+  return {
+    isRepo: true,
+    branch: branch || null,
+    hasRemote: remoteUrl !== null,
+    remoteUrl,
+    remoteWebUrl: remoteWebUrl(remoteUrl),
+    pendingFiles: porcelain ? porcelain.split("\n").filter(Boolean).length : 0,
+    hasGh: await hasGh()
+  };
+}
+async function commitContent(root2, contentDir, message) {
+  const inside = await tryGit(root2, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") throw new Error("Not a git repository \u2014 run `git init` first.");
+  await git(root2, ["add", "--", contentDir]);
+  const staged = await tryGit(root2, ["diff", "--cached", "--name-only", "--", contentDir]);
+  if (!staged) return { committed: false, count: 0 };
+  await git(root2, ["commit", "-m", message, "--", contentDir]);
+  return { committed: true, count: staged.split("\n").filter(Boolean).length };
+}
+async function pushContent(root2) {
+  const branch = await tryGit(root2, ["branch", "--show-current"]);
+  if (!branch || branch === "HEAD") throw new Error("No branch to push \u2014 commit something first.");
+  const hasUpstream = await tryGit(root2, ["rev-parse", "--abbrev-ref", `${branch}@{upstream}`]);
+  const args = hasUpstream ? ["push"] : ["push", "-u", "origin", branch];
+  await git(root2, args);
+  return { branch };
+}
+async function createGitHubRepo(root2, options) {
+  if (!await hasGh()) {
+    throw new Error("GitHub CLI (gh) not found \u2014 install it, or add a remote yourself.");
+  }
+  const inside = await tryGit(root2, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") {
+    await git(root2, ["init", "-b", "main"]);
+  }
+  await run(
+    "gh",
+    [
+      "repo",
+      "create",
+      options.name,
+      options.private ? "--private" : "--public",
+      "--source",
+      ".",
+      "--push"
+    ],
+    {
+      cwd: root2
+    }
+  );
+  return { name: options.name };
+}
+
+// src/server.ts
 var editorDir = fileURLToPath(new URL("./editor", import.meta.url));
 var PROVIDER_BASE_URLS = {
   groq: "https://api.groq.com/openai/v1",
@@ -5669,6 +6002,55 @@ async function createServer(root2) {
       singletons: schema.singletons.length
     })
   );
+  app.post("/api/_ship/scaffold", async (c) => {
+    if (schema.collections.length === 0 && schema.singletons.length === 0) {
+      return c.json({ error: "Pick a template or build a schema first." }, 400);
+    }
+    return c.json(await writeAstroSite(root2, schema, basename2(root2) || "my-site"));
+  });
+  app.get(
+    "/api/_ship",
+    async (c) => c.json({
+      framework: await detectFramework(root2),
+      git: await gitStatus(root2, contentDir)
+    })
+  );
+  app.post("/api/_ship/commit", async (c) => {
+    const { message } = await c.req.json();
+    try {
+      return c.json(await commitContent(root2, contentDir, message?.trim() || "content: update"));
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  app.post("/api/_ship/publish", async (c) => {
+    const { message } = await c.req.json().catch(() => ({}));
+    try {
+      const commit = await commitContent(root2, contentDir, message?.trim() || "content: update");
+      const { branch } = await pushContent(root2);
+      return c.json({ committed: commit.committed, count: commit.count, branch });
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  app.post("/api/_ship/push", async (c) => {
+    try {
+      return c.json(await pushContent(root2));
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
+  app.post("/api/_ship/repo", async (c) => {
+    const { name, private: isPrivate } = await c.req.json();
+    if (!name?.trim()) return c.json({ error: "A repository name is required." }, 400);
+    try {
+      return c.json(
+        await createGitHubRepo(root2, { name: name.trim(), private: isPrivate !== false })
+      );
+    } catch (e) {
+      return c.json({ error: e.message }, 400);
+    }
+  });
   app.get("/api/_templates", (c) => c.json({ items: templateList() }));
   app.post("/api/_init", async (c) => {
     const { template: id } = await c.req.json();
@@ -5752,9 +6134,9 @@ async function createServer(root2) {
     const base = slugify((body.filename ?? "gorsel").replace(/\.[^.]+$/, "")) || "gorsel";
     const name = `${base}-${Date.now().toString(36)}.webp`;
     const rel = `${contentDir}/media/${name}`;
-    const abs = join4(root2, rel);
-    await mkdir2(dirname2(abs), { recursive: true });
-    await writeFile3(abs, Buffer.from(body.dataBase64, "base64"));
+    const abs = join6(root2, rel);
+    await mkdir3(dirname3(abs), { recursive: true });
+    await writeFile4(abs, Buffer.from(body.dataBase64, "base64"));
     return c.json({ path: rel });
   });
   app.post("/api/_ai/models", async (c) => {
@@ -5796,7 +6178,7 @@ async function createServer(root2) {
       return c.text("forbidden", 400);
     }
     try {
-      const bytes = await readFile2(join4(root2, contentDir, "media", file));
+      const bytes = await readFile3(join6(root2, contentDir, "media", file));
       return new Response(bytes, { headers: { "content-type": "image/webp" } });
     } catch {
       return c.text("not found", 404);
@@ -5823,14 +6205,14 @@ async function createServer(root2) {
   app.get("/*", async (c) => {
     const urlPath = c.req.path === "/" ? "/index.html" : c.req.path;
     const rel = normalize(urlPath).replace(/^(\.\.[/\\])+/, "");
-    const file = join4(editorDir, rel);
+    const file = join6(editorDir, rel);
     if (!file.startsWith(editorDir)) return c.text("forbidden", 403);
     const type = MIME[extname(file)] ?? "application/octet-stream";
     try {
-      return new Response(await readFile2(file), { headers: { "content-type": type } });
+      return new Response(await readFile3(file), { headers: { "content-type": type } });
     } catch {
       try {
-        const html = await readFile2(join4(editorDir, "index.html"));
+        const html = await readFile3(join6(editorDir, "index.html"));
         return new Response(html, { headers: { "content-type": "text/html; charset=utf-8" } });
       } catch {
         return c.text("Editor UI not found (run the justjson build first).", 404);
@@ -5863,9 +6245,16 @@ function readVersion() {
 var program = new Command();
 var root = process.cwd();
 program.name("justjson").description("A tiny local-first CMS that keeps your content as plain JSON").version(readVersion());
-program.command("init").description("Scaffold a project from a template").argument("[template]", `template name (${listTemplates().join(", ")})`, "blog").action(async (template) => {
+program.command("init").description("Scaffold a project from a template").argument("[template]", `template name (${listTemplates().join(", ")})`, "blog").option("--astro", "also generate a working Astro site around the content").action(async (template, opts) => {
   await initProject(root, template);
   console.log(`Scaffolded from the '${template}' template.`);
+  if (!opts.astro) return;
+  const schema = await loadSchema(new FsAdapter(root), await resolveContentDir(root));
+  if (!schema) return;
+  const { written, skipped } = await writeAstroSite(root, schema, basename3(root) || "my-site");
+  console.log(`Wrote ${written.length} site file(s).`);
+  if (skipped.length > 0) console.log(`Kept your existing: ${skipped.join(", ")}`);
+  console.log("\nNext:\n  npm install\n  npm run dev");
 });
 program.command("types").description("Generate types.ts and a typed content.ts loader from your schema").action(async () => {
   const out = await generateTypesFile(root);