kernelcms 0.1.0

package/README.md

@@ -0,0 +1,70 @@
+# kernelcms
+
+The TanStack-native, adapter-based, end-to-end type-safe **headless CMS** — config-as-code and fully self-hosted.
+
+```bash
+npm install kernelcms
+```
+
+> Requires **Node >= 22** and a **PostgreSQL** database (set `DATABASE_URL`).
+
+## Quickstart
+
+```ts
+// kernel.config.ts
+import { defineConfig } from 'kernelcms'
+import { postgresAdapter } from 'kernelcms/postgres'
+
+export default defineConfig({
+  secret: process.env.KERNEL_SECRET,
+  db: postgresAdapter(), // reads DATABASE_URL
+  collections: [
+    {
+      slug: 'posts',
+      access: { read: () => true },
+      fields: [
+        { name: 'title', type: 'text', required: true },
+        { name: 'body', type: 'richText' },
+      ],
+    },
+  ],
+})
+```
+
+```bash
+export DATABASE_URL="postgres://user:pass@localhost:5432/mydb"
+```
+
+```ts
+import { initKernel } from 'kernelcms'
+import config from './kernel.config'
+
+const kernel = await initKernel(config, { autoMigrate: true })
+const post = await kernel.create({ collection: 'posts', data: { title: 'Hello' }, overrideAccess: true })
+```
+
+## Entry points
+
+| Import | What you get |
+| --- | --- |
+| `kernelcms` | Config, fields, the Local API (`initKernel`), auth, access, codegen, error types |
+| `kernelcms/postgres` | `postgresAdapter` — the default PostgreSQL adapter (pooled, concurrent transactions) |
+| `kernelcms/sqlite` | `sqliteAdapter` — an optional `node:sqlite` adapter, handy for local dev and tests |
+| `kernelcms/server` | `createRequestHandler`, `serve` — the REST handler + Node http adapter |
+| `kernelcms/client` | `createClient` — a tiny typed fetch client (browser/edge/Node) |
+
+## CLI
+
+```bash
+npx kernel migrate          # create/update tables from the config
+npx kernel seed             # run the exported seed()
+npx kernel dev              # migrate + start the REST API
+npx kernel generate:types   # emit TypeScript types for the content model
+```
+
+The CLI imports your `kernel.config.ts` directly — run on Node ≥ 22.6 (type
+stripping) or point `--config` at a compiled `.js`/`.mjs`.
+
+## License
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import {
+  serve
+} from "./chunk-Z2RKB4LF.js";
+import {
+  generateTypes,
+  initKernel
+} from "./chunk-O5TO5JFA.js";
+
+// ../cli/src/index.ts
+import { writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { pathToFileURL } from "url";
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) {
+        flags[key] = next;
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    } else {
+      positionals.push(arg);
+    }
+  }
+  return { command: positionals[0], positionals: positionals.slice(1), flags };
+}
+async function loadConfig(flags) {
+  const configPath = typeof flags.config === "string" ? flags.config : "kernel.config.ts";
+  const abs = resolve(process.cwd(), configPath);
+  const mod = await import(pathToFileURL(abs).href);
+  const config = mod.default ?? mod.config;
+  if (!config) throw new Error(`No config found. Export a default config from ${configPath}.`);
+  return { config, seed: mod.seed, path: abs };
+}
+var HELP = `KernelCMS CLI
+
+Usage: kernel <command> [options]
+
+Commands:
+  migrate            Create/update database tables from the config schema
+  seed               Run the exported seed() function
+  generate:types     Write generated TypeScript types for the content model
+  dev                Migrate, then start the REST API server
+
+Options:
+  --config <path>    Path to kernel.config.ts (default: ./kernel.config.ts)
+  --port <number>    Port for "dev" (default: $PORT or 3000)
+  --out <path>       Output file for "generate:types"
+`;
+async function run(argv) {
+  const { command, flags } = parseArgs(argv);
+  switch (command) {
+    case "migrate": {
+      const { config } = await loadConfig(flags);
+      const kernel = await initKernel(config);
+      const report = await kernel.db.migrate(kernel.schema);
+      console.log(
+        `\u2713 Migration complete \u2014 ${report.createdTables.length} table(s) created, ${report.addedColumns.length} column(s) added.`
+      );
+      if (report.createdTables.length) console.log(`  Created: ${report.createdTables.join(", ")}`);
+      await kernel.destroy();
+      break;
+    }
+    case "seed": {
+      const { config, seed } = await loadConfig(flags);
+      if (!seed) throw new Error("No `seed` export found in the config module.");
+      const kernel = await initKernel(config, { autoMigrate: true });
+      await seed(kernel);
+      console.log("\u2713 Seed complete.");
+      await kernel.destroy();
+      break;
+    }
+    case "generate:types":
+    case "types": {
+      const { config, path } = await loadConfig(flags);
+      const output = generateTypes({ collections: config.collections, globals: config.globals ?? [] });
+      const out = typeof flags.out === "string" ? resolve(process.cwd(), flags.out) : resolve(dirname(path), "kernel-types.ts");
+      writeFileSync(out, output, "utf8");
+      console.log(`\u2713 Types written to ${out}`);
+      break;
+    }
+    case "dev": {
+      const { config } = await loadConfig(flags);
+      const kernel = await initKernel(config, { autoMigrate: true });
+      const port = typeof flags.port === "string" ? Number(flags.port) : Number(process.env.PORT) || 3e3;
+      const server = await serve(kernel, {
+        port,
+        apiKey: process.env.KERNEL_API_KEY,
+        cors: true
+      });
+      console.log(`
+  KernelCMS dev server`);
+      console.log(`  \u279C  API:    ${server.url}${kernel.config.routes.api}`);
+      console.log(`  \u279C  Health: ${server.url}${kernel.config.routes.api}/health`);
+      console.log(`  \u279C  Collections: ${kernel.config.collections.map((c) => c.slug).join(", ") || "(none)"}`);
+      if (!process.env.KERNEL_API_KEY) {
+        console.log(`  !  Set KERNEL_API_KEY to enable trusted writes over HTTP.`);
+      }
+      const shutdown = async () => {
+        await server.close();
+        await kernel.destroy();
+        process.exit(0);
+      };
+      process.on("SIGINT", shutdown);
+      process.on("SIGTERM", shutdown);
+      break;
+    }
+    case void 0:
+    case "help":
+    case "--help":
+      console.log(HELP);
+      break;
+    default:
+      console.error(`Unknown command "${command}".
+`);
+      console.log(HELP);
+      process.exitCode = 1;
+  }
+}
+
+// src/bin.ts
+run(process.argv.slice(2)).catch((err) => {
+  console.error(`
+\u2717 ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});