koguma 0.4.0

package/src/react/index.ts

@@ -0,0 +1,70 @@
+/**
+ * React hooks for Koguma.
+ *
+ * Usage:
+ *   import { useEntry, useEntries } from "koguma/react";
+ *   const { data, loading, error } = useEntry<FourDirectionsPage>("fourDirectionsPage", "single");
+ *   const { data: cards } = useEntries<FeatureCard>("featureCard");
+ */
+import { useEffect, useState } from "react";
+import { getClient } from "../client/index.ts";
+
+export interface UseEntryResult<T> {
+  data: T | null;
+  loading: boolean;
+  error: string | null;
+}
+
+export interface UseEntriesResult<T> {
+  data: T[];
+  loading: boolean;
+  error: string | null;
+}
+
+// Module-level cache: { "featureCard": Promise<T[]>, "fourDirectionsPage:single": Promise<T> }
+const cache = new Map<string, Promise<unknown>>();
+
+/** Fetch and cache a single entry */
+export function useEntry<T = Record<string, unknown>>(
+  contentType: string,
+  id: string,
+): UseEntryResult<T> {
+  const [data, setData] = useState<T | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const key = `${contentType}:${id}`;
+    if (!cache.has(key)) {
+      cache.set(key, getClient().get<T>(contentType, id));
+    }
+    (cache.get(key) as Promise<T>)
+      .then(setData)
+      .catch((e: unknown) => setError(e instanceof Error ? e.message : String(e)))
+      .finally(() => setLoading(false));
+  }, [contentType, id]);
+
+  return { data, loading, error };
+}
+
+/** Fetch and cache all entries of a type */
+export function useEntries<T = Record<string, unknown>>(
+  contentType: string,
+): UseEntriesResult<T> {
+  const [data, setData] = useState<T[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    const key = `list:${contentType}`;
+    if (!cache.has(key)) {
+      cache.set(key, getClient().list<T>(contentType));
+    }
+    (cache.get(key) as Promise<T[]>)
+      .then(setData)
+      .catch((e: unknown) => setError(e instanceof Error ? e.message : String(e)))
+      .finally(() => setLoading(false));
+  }, [contentType]);
+
+  return { data, loading, error };
+}

package/src/worker.ts

@@ -0,0 +1,51 @@
+/**
+ * createWorker — the main entry point for Koguma.
+ *
+ * This is what the developer imports in their worker.ts:
+ *
+ *   import { createWorker } from "koguma/worker";
+ *   import config from "./site.config";
+ *   export default createWorker(config);
+ */
+import { Hono } from "hono";
+import type { KogumaConfig } from "./config/define.ts";
+import { createApiRouter } from "./api/router.ts";
+import { adminHtml } from "./admin/dashboard.ts";
+
+type Env = Record<string, unknown>;
+
+
+export function createWorker(config: KogumaConfig) {
+  const app = new Hono();
+
+  // Mount the API
+  const api = createApiRouter(config);
+  app.route("/", api);
+
+  // Admin SPA — catch-all for /admin* routes
+  app.get("/admin", (c) => {
+    return c.html(adminHtml(config.siteName));
+  });
+  app.get("/admin/*", (c) => {
+    return c.html(adminHtml(config.siteName));
+  });
+
+  return {
+    async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+      const url = new URL(request.url);
+
+      // API and admin routes handled by Hono
+      if (url.pathname.startsWith("/api/") || url.pathname.startsWith("/admin")) {
+        return app.fetch(request, env, ctx);
+      }
+
+      // Everything else — serve static assets (Vite build)
+      const assets = env.ASSETS as { fetch: typeof fetch } | undefined;
+      if (assets) {
+        return assets.fetch(request);
+      }
+
+      return new Response("Not found", { status: 404 });
+    },
+  };
+}