kernelcms 0.1.0

package/dist/chunk-Z2RKB4LF.js

@@ -0,0 +1,285 @@
+import {
+  BadRequestError,
+  NotFoundError,
+  UnauthorizedError,
+  describeConfig,
+  isKernelError
+} from "./chunk-O5TO5JFA.js";
+
+// ../server/src/index.ts
+import { createServer } from "http";
+function createRequestHandler(kernel, options = {}) {
+  const apiBase = kernel.config.routes.api;
+  return async function handle(request) {
+    if (request.method === "OPTIONS") return withCors(new Response(null, { status: 204 }), options, request);
+    try {
+      const response = await route(kernel, options, request, apiBase);
+      return withCors(response, options, request);
+    } catch (err) {
+      return withCors(errorResponse(err), options, request);
+    }
+  };
+}
+async function route(kernel, options, request, apiBase) {
+  const url = new URL(request.url);
+  if (!url.pathname.startsWith(apiBase)) {
+    return json({ error: { code: "NOT_FOUND", message: `No route for ${url.pathname}` } }, 404);
+  }
+  const segments = url.pathname.slice(apiBase.length).split("/").filter(Boolean);
+  const { user, overrideAccess } = await resolveAuth(kernel, options, request);
+  const locale = url.searchParams.get("locale") ?? void 0;
+  const depth = toNum(url.searchParams.get("depth"));
+  const base = { req: { user, ...locale ? { locale } : {} }, overrideAccess, ...depth !== void 0 ? { depth } : {} };
+  const method = request.method;
+  if (segments.length === 0) {
+    return json({
+      name: "KernelCMS",
+      collections: kernel.config.collections.map((c) => c.slug),
+      globals: kernel.config.globals.map((g) => g.slug)
+    });
+  }
+  if (segments.length === 1 && segments[0] === "health") {
+    const health = await kernel.db.health();
+    return json({ status: "ok", db: health }, health.status === "ok" ? 200 : 503);
+  }
+  if (segments.length === 1 && segments[0] === "_config") {
+    return json(describeConfig(kernel.config));
+  }
+  if (segments[0] === "globals" && segments.length === 2) {
+    const slug = segments[1];
+    if (method === "GET") return json(await kernel.findGlobal({ slug, ...base }));
+    if (method === "POST" || method === "PATCH") {
+      const data = await readBody(request);
+      return json(await kernel.updateGlobal({ slug, data, ...base }));
+    }
+    return methodNotAllowed();
+  }
+  const collection = segments[0];
+  if (segments.length === 2 && (segments[1] === "login" || segments[1] === "me")) {
+    const authColl = kernel.config.collectionsBySlug[collection];
+    if (authColl?.auth) {
+      if (segments[1] === "login" && method === "POST") {
+        const body = await readBody(request);
+        return json(
+          await kernel.login({
+            collection,
+            email: String(body.email ?? ""),
+            password: String(body.password ?? "")
+          })
+        );
+      }
+      if (segments[1] === "me" && method === "GET") {
+        if (!user) throw new UnauthorizedError();
+        return json({ user });
+      }
+    }
+  }
+  if (segments.length === 1) {
+    if (method === "GET") {
+      const result = await kernel.find({
+        collection,
+        where: parseWhere(url.searchParams),
+        sort: url.searchParams.get("sort") ?? void 0,
+        limit: toNum(url.searchParams.get("limit")),
+        page: toNum(url.searchParams.get("page")),
+        ...base
+      });
+      return json(result);
+    }
+    if (method === "POST") {
+      const data = await readBody(request);
+      return json(await kernel.create({ collection, data, ...base }), 201);
+    }
+    return methodNotAllowed();
+  }
+  if (segments.length === 2) {
+    const id = segments[1];
+    if (method === "GET") {
+      const doc = await kernel.findByID({ collection, id, ...base });
+      if (!doc) throw new NotFoundError();
+      return json(doc);
+    }
+    if (method === "PATCH" || method === "PUT") {
+      const data = await readBody(request);
+      const doc = await kernel.update({ collection, id, data, ...base });
+      if (!doc) throw new NotFoundError();
+      return json(doc);
+    }
+    if (method === "DELETE") {
+      const doc = await kernel.delete({ collection, id, ...base });
+      if (!doc) throw new NotFoundError();
+      return json(doc);
+    }
+    return methodNotAllowed();
+  }
+  return json({ error: { code: "NOT_FOUND", message: `No route for ${url.pathname}` } }, 404);
+}
+async function resolveAuth(kernel, options, request) {
+  const auth = request.headers.get("authorization");
+  if (options.apiKey && auth === `Bearer ${options.apiKey}`) {
+    return { user: { id: "system", roles: ["admin"], collection: "system" }, overrideAccess: true };
+  }
+  if (options.getUser) {
+    const user = await options.getUser(request);
+    if (user) return { user, overrideAccess: false };
+  }
+  if (auth?.startsWith("Bearer ")) {
+    const user = await kernel.authenticate(auth.slice("Bearer ".length));
+    if (user) return { user, overrideAccess: false };
+  }
+  return { user: null, overrideAccess: false };
+}
+async function readBody(request) {
+  let parsed;
+  try {
+    parsed = await request.json();
+  } catch {
+    throw new BadRequestError("Request body must be valid JSON.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new BadRequestError("Request body must be a JSON object.");
+  }
+  return parsed;
+}
+function coerce(value) {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (value !== "" && /^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  return value;
+}
+function setDeep(root, path, value) {
+  let node = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const key = path[i];
+    if (typeof node[key] !== "object" || node[key] === null) node[key] = {};
+    node = node[key];
+  }
+  node[path[path.length - 1]] = value;
+}
+function parseWhere(params) {
+  const raw = params.get("where");
+  if (raw) {
+    try {
+      return JSON.parse(raw);
+    } catch {
+      throw new BadRequestError("`where` must be valid JSON.");
+    }
+  }
+  const root = {};
+  let found = false;
+  for (const [key, value] of params) {
+    if (!key.startsWith("where[")) continue;
+    found = true;
+    const path = key.slice("where".length).split(/[[\]]+/).filter(Boolean);
+    setDeep(root, path, coerce(value));
+  }
+  return found ? root : void 0;
+}
+function json(data, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+function methodNotAllowed() {
+  return json({ error: { code: "BAD_REQUEST", message: "Method not allowed." } }, 405);
+}
+function errorResponse(err) {
+  if (isKernelError(err)) {
+    const response = json(err.toJSON(), err.status);
+    const retryAfter = err.retryAfter;
+    if (typeof retryAfter === "number") response.headers.set("retry-after", String(retryAfter));
+    return response;
+  }
+  console.error("[kernel] unhandled error:", err);
+  return json({ error: { code: "INTERNAL", message: "Internal server error." } }, 500);
+}
+function withCors(response, options, request) {
+  if (!options.cors) return response;
+  const origin = request.headers.get("origin");
+  let allow = null;
+  let credentials = false;
+  if (Array.isArray(options.cors)) {
+    if (origin && options.cors.includes(origin)) {
+      allow = origin;
+      credentials = true;
+    }
+  } else {
+    allow = origin ?? "*";
+  }
+  if (!allow) return response;
+  response.headers.set("access-control-allow-origin", allow);
+  if (credentials) response.headers.set("access-control-allow-credentials", "true");
+  response.headers.set("access-control-allow-headers", "Content-Type, Authorization");
+  response.headers.set("access-control-allow-methods", "GET, POST, PATCH, PUT, DELETE, OPTIONS");
+  response.headers.set("vary", "Origin");
+  return response;
+}
+function toNum(value) {
+  if (value === null) return void 0;
+  const n = Number(value);
+  return Number.isNaN(n) ? void 0 : n;
+}
+function toNodeListener(handler) {
+  return (req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("error", () => {
+      res.statusCode = 400;
+      res.end();
+    });
+    req.on("end", () => {
+      void (async () => {
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(req.headers)) {
+          if (typeof value === "string") headers.set(key, value);
+          else if (Array.isArray(value)) headers.set(key, value.join(", "));
+        }
+        const url = `http://${req.headers.host ?? "localhost"}${req.url ?? "/"}`;
+        const method = req.method ?? "GET";
+        const hasBody = method !== "GET" && method !== "HEAD" && chunks.length > 0;
+        const request = new Request(url, {
+          method,
+          headers,
+          body: hasBody ? Buffer.concat(chunks) : void 0
+        });
+        try {
+          const response = await handler(request);
+          res.statusCode = response.status;
+          response.headers.forEach((value, key) => res.setHeader(key, value));
+          const body = Buffer.from(await response.arrayBuffer());
+          res.end(body);
+        } catch (err) {
+          console.error("[kernel] listener error:", err);
+          res.statusCode = 500;
+          res.setHeader("content-type", "application/json");
+          res.end(JSON.stringify({ error: { code: "INTERNAL", message: "Internal server error." } }));
+        }
+      })();
+    });
+  };
+}
+async function serve(kernel, options = {}) {
+  const handler = createRequestHandler(kernel, options);
+  const server = createServer(toNodeListener(handler));
+  const requested = options.port ?? 3e3;
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(requested, () => resolve());
+  });
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : requested;
+  return {
+    url: `http://localhost:${port}`,
+    port,
+    close: () => new Promise((resolve) => server.close(() => resolve()))
+  };
+}
+
+export {
+  createRequestHandler,
+  parseWhere,
+  toNodeListener,
+  serve
+};

package/dist/client.d.ts

@@ -0,0 +1,57 @@
+import { W as Where, R as Row, P as PaginatedResult } from './index-BxvPeUO2.js';
+
+/**
+ * @kernel/client — a tiny, typed fetch client for the KernelCMS REST API.
+ * Works in the browser, on the edge, and in Node (global fetch).
+ */
+
+interface ClientOptions {
+    /** Origin of the KernelCMS server, e.g. "http://localhost:3000". */
+    baseURL: string;
+    /** API route prefix. Default "/api". */
+    apiRoute?: string;
+    /** System API key (sent as a bearer token). */
+    apiKey?: string;
+    /** End-user auth token (sent as a bearer token). Takes precedence over apiKey. */
+    token?: string;
+    /** Custom fetch implementation (defaults to global fetch). */
+    fetch?: typeof fetch;
+    /** Extra headers attached to every request. */
+    headers?: Record<string, string>;
+}
+interface FindQuery {
+    where?: Where;
+    sort?: string | string[];
+    limit?: number;
+    page?: number;
+    depth?: number;
+    locale?: string;
+}
+interface ByIdQuery {
+    depth?: number;
+    locale?: string;
+}
+declare class KernelClientError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details: unknown;
+    constructor(status: number, code: string, message: string, details: unknown);
+}
+interface KernelClient {
+    find: <T extends Row = Row>(collection: string, query?: FindQuery) => Promise<PaginatedResult<T>>;
+    findByID: <T extends Row = Row>(collection: string, id: string, query?: ByIdQuery) => Promise<T>;
+    create: <T extends Row = Row>(collection: string, data: Row, query?: ByIdQuery) => Promise<T>;
+    update: <T extends Row = Row>(collection: string, id: string, data: Row, query?: ByIdQuery) => Promise<T>;
+    remove: <T extends Row = Row>(collection: string, id: string) => Promise<T>;
+    findGlobal: <T extends Row = Row>(slug: string, query?: ByIdQuery) => Promise<T>;
+    updateGlobal: <T extends Row = Row>(slug: string, data: Row) => Promise<T>;
+    health: () => Promise<{
+        status: string;
+        db: {
+            status: string;
+        };
+    }>;
+}
+declare function createClient(options: ClientOptions): KernelClient;
+
+export { type ByIdQuery, type ClientOptions, type FindQuery, type KernelClient, KernelClientError, createClient };

package/dist/client.js

@@ -0,0 +1,61 @@
+// ../client/src/index.ts
+var KernelClientError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(status, code, message, details) {
+    super(message);
+    this.name = "KernelClientError";
+    this.status = status;
+    this.code = code;
+    this.details = details;
+  }
+};
+function buildSearch(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  if ("where" in query && query.where) params.set("where", JSON.stringify(query.where));
+  if ("sort" in query && query.sort) params.set("sort", Array.isArray(query.sort) ? query.sort.join(",") : query.sort);
+  if ("limit" in query && query.limit !== void 0) params.set("limit", String(query.limit));
+  if ("page" in query && query.page !== void 0) params.set("page", String(query.page));
+  if (query.depth !== void 0) params.set("depth", String(query.depth));
+  if (query.locale) params.set("locale", query.locale);
+  const qs = params.toString();
+  return qs ? `?${qs}` : "";
+}
+function createClient(options) {
+  const doFetch = options.fetch ?? globalThis.fetch;
+  const apiRoute = options.apiRoute ?? "/api";
+  const root = options.baseURL.replace(/\/$/, "") + apiRoute;
+  async function request(method, path, body) {
+    const headers = { "content-type": "application/json", ...options.headers };
+    const bearer = options.token ?? options.apiKey;
+    if (bearer) headers.authorization = `Bearer ${bearer}`;
+    const response = await doFetch(root + path, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    const text = await response.text();
+    const payload = text ? JSON.parse(text) : null;
+    if (!response.ok) {
+      const err = payload?.error ?? {};
+      throw new KernelClientError(response.status, err.code ?? "ERROR", err.message ?? response.statusText, err.details);
+    }
+    return payload;
+  }
+  return {
+    find: (collection, query) => request("GET", `/${collection}${buildSearch(query)}`),
+    findByID: (collection, id, query) => request("GET", `/${collection}/${id}${buildSearch(query)}`),
+    create: (collection, data, query) => request("POST", `/${collection}${buildSearch(query)}`, data),
+    update: (collection, id, data, query) => request("PATCH", `/${collection}/${id}${buildSearch(query)}`, data),
+    remove: (collection, id) => request("DELETE", `/${collection}/${id}`),
+    findGlobal: (slug, query) => request("GET", `/globals/${slug}${buildSearch(query)}`),
+    updateGlobal: (slug, data) => request("POST", `/globals/${slug}`, data),
+    health: () => request("GET", "/health")
+  };
+}
+export {
+  KernelClientError,
+  createClient
+};

package/dist/index-BxvPeUO2.d.ts

@@ -0,0 +1,134 @@
+/**
+ * @kernel/db — the persistence adapter contract and the storage-facing schema.
+ *
+ * The operation core (@kernel/core) is written entirely against these types and
+ * never imports a driver. Concrete backends (@kernel/db-sqlite, ...) implement
+ * `DatabaseAdapter`. This is the contract that makes the "choose everything"
+ * promise real.
+ */
+type StorageType = 'text' | 'integer' | 'real' | 'boolean' | 'json' | 'timestamp';
+interface ColumnSchema {
+    /** Column name (matches the field name). */
+    name: string;
+    /** Physical storage type the adapter must provision. */
+    type: StorageType;
+    required: boolean;
+    unique: boolean;
+    indexed: boolean;
+    /** For relationship columns, the collection slug this points at. */
+    relationTo?: string;
+    /** When true, the stored value is a JSON map of locale -> value. */
+    localized: boolean;
+}
+interface TableSchema {
+    /** Physical table name. */
+    table: string;
+    /** Logical slug (collection slug, or the global slug). */
+    slug: string;
+    /** Columns excluding the system id/timestamp columns the adapter owns. */
+    columns: ColumnSchema[];
+    timestamps: boolean;
+    /** Single-row table backing a global. */
+    singleton: boolean;
+}
+interface KernelSchema {
+    tables: TableSchema[];
+}
+type AdapterKind = 'db' | 'storage' | 'auth' | 'email' | 'search' | 'cache' | 'queue';
+interface Logger {
+    debug: (msg: string, meta?: unknown) => void;
+    info: (msg: string, meta?: unknown) => void;
+    warn: (msg: string, meta?: unknown) => void;
+    error: (msg: string, meta?: unknown) => void;
+}
+interface AdapterContext {
+    logger: Logger;
+}
+interface HealthStatus {
+    status: 'ok' | 'degraded' | 'down';
+    detail?: string;
+}
+interface Adapter {
+    readonly kind: AdapterKind;
+    readonly name: string;
+    readonly contractVersion: `${number}.${number}`;
+    init(ctx: AdapterContext): Promise<void>;
+    health(): Promise<HealthStatus>;
+    destroy(): Promise<void>;
+}
+type WhereOperator = 'equals' | 'not_equals' | 'in' | 'not_in' | 'greater_than' | 'greater_than_equal' | 'less_than' | 'less_than_equal' | 'like' | 'contains' | 'exists';
+type WhereCondition = Partial<Record<WhereOperator, unknown>>;
+interface Where {
+    and?: Where[];
+    or?: Where[];
+    [field: string]: WhereCondition | Where[] | undefined;
+}
+type SortDirection = 'asc' | 'desc';
+interface SortSpec {
+    field: string;
+    direction: SortDirection;
+}
+type Row = Record<string, unknown>;
+interface FindArgs {
+    collection: string;
+    where?: Where;
+    sort?: SortSpec[];
+    limit: number;
+    page: number;
+}
+interface PaginatedResult<T = Row> {
+    docs: T[];
+    totalDocs: number;
+    limit: number;
+    page: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    prevPage: number | null;
+    nextPage: number | null;
+    pagingCounter: number;
+}
+interface MigrationReport {
+    createdTables: string[];
+    addedColumns: string[];
+    statements: string[];
+}
+interface DatabaseCapabilities {
+    transactions: boolean;
+    joins: 'native' | 'application';
+    jsonQuery: boolean;
+    fullTextSearch: boolean;
+    returning: boolean;
+}
+interface DatabaseAdapter extends Adapter {
+    readonly kind: 'db';
+    readonly capabilities: DatabaseCapabilities;
+    /** Diff the schema against the live database and apply the changes. */
+    migrate(schema: KernelSchema): Promise<MigrationReport>;
+    find(args: FindArgs): Promise<PaginatedResult<Row>>;
+    findByID(args: {
+        collection: string;
+        id: string;
+    }): Promise<Row | null>;
+    create(args: {
+        collection: string;
+        data: Row;
+    }): Promise<Row>;
+    update(args: {
+        collection: string;
+        id: string;
+        data: Row;
+    }): Promise<Row | null>;
+    delete(args: {
+        collection: string;
+        id: string;
+    }): Promise<Row | null>;
+    count(args: {
+        collection: string;
+        where?: Where;
+    }): Promise<number>;
+    transaction<R>(fn: (tx: DatabaseAdapter) => Promise<R>): Promise<R>;
+}
+type DatabaseAdapterFactory = () => DatabaseAdapter;
+
+export type { Adapter as A, ColumnSchema as C, DatabaseAdapter as D, KernelSchema as K, Logger as L, MigrationReport as M, PaginatedResult as P, Row as R, SortSpec as S, TableSchema as T, Where as W, AdapterContext as a, DatabaseAdapterFactory as b, DatabaseCapabilities as c, StorageType as d, WhereCondition as e, WhereOperator as f };