create-strata 1.0.1

package/dist/templates/overlays/spa-react/frontend/src/app.css

@@ -0,0 +1,98 @@
+:root {
+  color: #0f172a;
+  background: #f8fafc;
+  font-family: system-ui, sans-serif;
+  line-height: 1.5;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+}
+
+a {
+  color: #2563eb;
+}
+
+.app-shell {
+  max-width: 960px;
+  margin: 0 auto;
+  padding: 1.5rem;
+}
+
+.site-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 1rem;
+  margin-bottom: 1.5rem;
+  padding-bottom: 1rem;
+  border-bottom: 1px solid #e2e8f0;
+}
+
+.site-header nav {
+  display: flex;
+  gap: 1rem;
+  flex-wrap: wrap;
+}
+
+.card {
+  background: #fff;
+  border: 1px solid #e2e8f0;
+  border-radius: 0.75rem;
+  padding: 1rem;
+  margin-bottom: 1rem;
+}
+
+.stack-form {
+  display: grid;
+  gap: 0.75rem;
+  max-width: 24rem;
+}
+
+.stack-form label {
+  display: grid;
+  gap: 0.25rem;
+}
+
+.stack-form input {
+  padding: 0.5rem 0.75rem;
+  border: 1px solid #cbd5e1;
+  border-radius: 0.5rem;
+}
+
+button {
+  cursor: pointer;
+  border: none;
+  border-radius: 0.5rem;
+  padding: 0.5rem 0.875rem;
+  background: #2563eb;
+  color: #fff;
+}
+
+button.secondary {
+  background: #64748b;
+}
+
+.error {
+  color: #b91c1c;
+}
+
+table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+th,
+td {
+  text-align: left;
+  padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid #e2e8f0;
+}
+
+.hint {
+  color: #64748b;
+}

package/dist/templates/overlays/spa-react/frontend/src/auth/AuthContext.tsx

@@ -0,0 +1,103 @@
+import {
+  createContext,
+  type ReactNode,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useState,
+} from "react";
+import { apiFetch } from "../api/client";
+import { clearToken, readToken, writeToken } from "./tokenStorage";
+
+interface AuthUser {
+  id: number;
+  name: string;
+  email: string;
+  role: string;
+}
+
+interface AuthContextValue {
+  token: string | null;
+  user: AuthUser | null;
+  loading: boolean;
+  login: (email: string, password: string) => Promise<void>;
+  logout: () => void;
+}
+
+const AuthContext = createContext<AuthContextValue | null>(null);
+
+function AuthProvider({ children }: { children: ReactNode }) {
+  const [token, setToken] = useState<string | null>(() => readToken());
+  const [user, setUser] = useState<AuthUser | null>(null);
+  const [loading, setLoading] = useState(Boolean(readToken()));
+
+  const loadProfile = useCallback(async (activeToken: string) => {
+    const profile = await apiFetch<AuthUser>("/auth/me", { token: activeToken });
+    setUser(profile);
+  }, []);
+
+  useEffect(() => {
+    if (!token) {
+      setUser(null);
+      setLoading(false);
+      return;
+    }
+
+    loadProfile(token)
+      .catch(() => {
+        clearToken();
+        setToken(null);
+        setUser(null);
+      })
+      .finally(() => {
+        setLoading(false);
+      });
+  }, [loadProfile, token]);
+
+  const login = useCallback(
+    async (email: string, password: string) => {
+      const body = await apiFetch<{ token: string }>("/auth/login", {
+        method: "POST",
+        body: JSON.stringify({ email, password }),
+      });
+
+      writeToken(body.token);
+      setToken(body.token);
+      await loadProfile(body.token);
+    },
+    [loadProfile],
+  );
+
+  const logout = useCallback(() => {
+    clearToken();
+    setToken(null);
+    setUser(null);
+  }, []);
+
+  const value = useMemo(
+    () => ({
+      token,
+      user,
+      loading,
+      login,
+      logout,
+    }),
+    [loading, login, logout, token, user],
+  );
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
+
+function useAuth(): AuthContextValue {
+  const context = useContext(AuthContext);
+
+  if (!context) {
+    throw new Error("useAuth must be used within AuthProvider");
+  }
+
+  return context;
+}
+
+export type { AuthUser };
+export { AuthProvider, useAuth };

package/dist/templates/overlays/spa-react/frontend/src/auth/tokenStorage.ts

@@ -0,0 +1,15 @@
+const TOKEN_KEY = "strata_api_token";
+
+function readToken(): string | null {
+  return localStorage.getItem(TOKEN_KEY);
+}
+
+function writeToken(token: string): void {
+  localStorage.setItem(TOKEN_KEY, token);
+}
+
+function clearToken(): void {
+  localStorage.removeItem(TOKEN_KEY);
+}
+
+export { clearToken, readToken, TOKEN_KEY, writeToken };

package/dist/templates/overlays/spa-react/frontend/src/main.tsx

@@ -0,0 +1,22 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { BrowserRouter } from "react-router-dom";
+import App from "./App";
+import { AuthProvider } from "./auth/AuthContext";
+import "./app.css";
+
+const rootElement = document.getElementById("root");
+
+if (!rootElement) {
+  throw new Error("Root element #root not found");
+}
+
+createRoot(rootElement).render(
+  <StrictMode>
+    <BrowserRouter basename="/app">
+      <AuthProvider>
+        <App />
+      </AuthProvider>
+    </BrowserRouter>
+  </StrictMode>,
+);

package/dist/templates/overlays/spa-react/frontend/src/pages/HomePage.tsx

@@ -0,0 +1,72 @@
+import { useAuth } from "../auth/AuthContext";
+
+export default function HomePage() {
+  const { user } = useAuth();
+
+  return (
+    <section>
+      <h1>Signed in</h1>
+      <p className="hint">
+        This page reads <code>GET /api/v1/auth/me</code> with the bearer token from the login
+        response. It is the only resource the generated backend serves, so it is the only one this
+        page shows.
+      </p>
+
+      <div className="card">
+        <table>
+          <tbody>
+            <tr>
+              <th>Name</th>
+              <td>{user?.name ?? "—"}</td>
+            </tr>
+            <tr>
+              <th>Email</th>
+              <td>{user?.email ?? "—"}</td>
+            </tr>
+            <tr>
+              <th>Role</th>
+              <td>
+                <code>{user?.role ?? "—"}</code>
+              </td>
+            </tr>
+          </tbody>
+        </table>
+      </div>
+
+      <h2>Add your first resource</h2>
+      <p>
+        Create a module under <code>src/modules/</code> and return routes from it. The kernel picks
+        it up on the next boot.
+      </p>
+
+      <pre className="card">
+        <code>{`// src/modules/notes/index.ts
+import type { AppModule } from "@getstrata/bootstrap/contracts";
+import { jsonResponse } from "@getstrata/core/http/response";
+import { getSql } from "../../bootstrap/database.ts";
+
+const notesModule: AppModule = {
+  name: "notes",
+  order: 2,
+  routes({ kernel }) {
+    return {
+      "/api/v1/notes": kernel.wrap("api", async () => {
+        const rows = await getSql().unsafe<{ id: number; body: string }>(
+          "SELECT id, body FROM notes ORDER BY id DESC",
+        );
+        return jsonResponse({ data: rows });
+      }),
+    };
+  },
+};
+
+export default notesModule;`}</code>
+      </pre>
+
+      <p className="hint">
+        Then fetch it here with <code>apiFetch("/notes", {"{ token }"})</code>. The{" "}
+        <code>notes</code> table already exists after <code>bun run db:migrate</code>.
+      </p>
+    </section>
+  );
+}

package/dist/templates/overlays/spa-react/frontend/src/pages/LoginPage.tsx

@@ -0,0 +1,70 @@
+import { type FormEvent, useState } from "react";
+import { Navigate, useNavigate } from "react-router-dom";
+import { ApiError } from "../api/client";
+import { useAuth } from "../auth/AuthContext";
+
+export default function LoginPage() {
+  const { login, token } = useAuth();
+  const navigate = useNavigate();
+  const [email, setEmail] = useState("admin@example.test");
+  const [password, setPassword] = useState("password");
+  const [error, setError] = useState<string | null>(null);
+  const [submitting, setSubmitting] = useState(false);
+
+  if (token) {
+    return <Navigate to="/" replace />;
+  }
+
+  async function onSubmit(event: FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    setSubmitting(true);
+    setError(null);
+
+    try {
+      await login(email, password);
+      navigate("/");
+    } catch (cause) {
+      setError(cause instanceof ApiError ? cause.message : "Login failed");
+    } finally {
+      setSubmitting(false);
+    }
+  }
+
+  return (
+    <section className="card">
+      <h1>Sign in</h1>
+      <p className="hint">
+        Seeded users are <code>demo@example.com</code> and <code>admin@example.test</code>, password
+        <code>password</code>.
+      </p>
+
+      {error ? <p className="error">{error}</p> : null}
+
+      <form className="stack-form" onSubmit={onSubmit}>
+        <label>
+          Email
+          <input
+            type="email"
+            value={email}
+            onChange={(event) => setEmail(event.target.value)}
+            required
+          />
+        </label>
+
+        <label>
+          Password
+          <input
+            type="password"
+            value={password}
+            onChange={(event) => setPassword(event.target.value)}
+            required
+          />
+        </label>
+
+        <button type="submit" disabled={submitting}>
+          {submitting ? "Signing in…" : "Sign in"}
+        </button>
+      </form>
+    </section>
+  );
+}

package/dist/templates/overlays/spa-react/frontend/src/pages/NotFoundPage.tsx

@@ -0,0 +1,12 @@
+import { Link } from "react-router-dom";
+
+export default function NotFoundPage() {
+  return (
+    <section className="card">
+      <h1>Not found</h1>
+      <p>
+        Return <Link to="/">home</Link>.
+      </p>
+    </section>
+  );
+}

package/dist/templates/overlays/spa-react/frontend/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "strict": true,
+    "types": ["bun"]
+  },
+  "include": ["src", "build.ts", "dev-server.ts", "bun-env.d.ts"]
+}

package/dist/templates/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "{{PROJECT_NAME}}",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "strata dev",
+    "start": "strata start",
+    "db:migrate": "strata migrate",
+    "db:fresh": "strata migrate:fresh",
+    "check": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@getstrata/bootstrap": "^1.0.1",
+    "@getstrata/cli": "^1.0.1",
+    "@getstrata/core": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.0",
+    "typescript": "^5.9.2"
+  }
+}

package/dist/templates/public/assets/site.css

@@ -0,0 +1,29 @@
+:root {
+  color-scheme: light dark;
+  font-family: system-ui, sans-serif;
+  line-height: 1.5;
+}
+
+body {
+  margin: 0;
+  padding: 0 1.5rem 2rem;
+  max-width: 48rem;
+}
+
+.site-header {
+  padding: 1rem 0;
+}
+
+.brand {
+  font-weight: 700;
+  text-decoration: none;
+  color: inherit;
+}
+
+.section h1 {
+  margin-top: 0;
+}
+
+code {
+  font-size: 0.9em;
+}

package/dist/templates/src/bootstrap/config.ts

@@ -0,0 +1,29 @@
+export interface AppConfig {
+  port: number;
+  appUrl: string;
+  databaseUrl: string;
+}
+
+export function loadConfig(): AppConfig {
+  const databaseUrl = process.env.DATABASE_URL;
+  if (!databaseUrl) {
+    throw new Error("DATABASE_URL is required");
+  }
+
+  return {
+    port: Number(process.env.PORT ?? 3000),
+    appUrl: process.env.APP_URL ?? "http://localhost:3000",
+    databaseUrl,
+  };
+}
+
+/** Cookie sessions and signed cookies are keyed by this; there is no default. */
+export function sessionSecret(): string {
+  const secret = process.env.SESSION_SECRET?.trim();
+  if (!secret) {
+    throw new Error(
+      "SESSION_SECRET is required. Copy .env.example to .env and set it (32+ characters).",
+    );
+  }
+  return secret;
+}

package/dist/templates/src/bootstrap/createApp.ts

@@ -0,0 +1,94 @@
+import { runProviderPhase } from "@getstrata/bootstrap/context";
+import {
+  type AppContext,
+  type AppDependencies,
+  type AppRouteMap,
+  assertAppDependenciesComplete,
+  type ConfigStore,
+  type MutableAppDependencies,
+  type ProviderContext,
+  ServiceContainer,
+} from "@getstrata/bootstrap/contracts";
+import { createWebServer } from "@getstrata/bootstrap/web/server";
+import { setActiveApplicationContext } from "@getstrata/core/runtime/applicationRegistry";
+import { migrate } from "../db/migrate.ts";
+import { buildRoutes } from "../routes.ts";
+import { loadConfig } from "./config.ts";
+import { starterProviders } from "./providers/index.ts";
+
+export interface BootstrapOptions {
+  migrate?: boolean;
+}
+
+export interface BootstrappedApp {
+  context: AppContext;
+  routes: AppRouteMap;
+  config: ReturnType<typeof loadConfig>;
+}
+
+class AppConfigStore {
+  private readonly values = new Map<string, unknown>();
+
+  set<T>(key: string, value: T): T {
+    this.values.set(key, value);
+    return value;
+  }
+
+  get<T>(key: string): T | undefined {
+    return this.values.get(key) as T | undefined;
+  }
+
+  require<T>(key: string): T {
+    const value = this.get<T>(key);
+    if (value === undefined) {
+      throw new Error(`Missing required config value "${key}".`);
+    }
+    return value;
+  }
+
+  has(key: string): boolean {
+    return this.values.has(key);
+  }
+}
+
+function createAppContext(): AppContext {
+  const container = new ServiceContainer();
+  const config = new AppConfigStore() as unknown as ConfigStore;
+  const dependencies: MutableAppDependencies = { container };
+  const context: ProviderContext = { container, config, dependencies };
+
+  runProviderPhase(starterProviders, "register", context);
+  runProviderPhase(starterProviders, "boot", context);
+
+  assertAppDependenciesComplete(dependencies);
+
+  const appContext = { container, config, dependencies: dependencies as AppDependencies };
+  setActiveApplicationContext(appContext as never);
+  return appContext;
+}
+
+export async function bootstrapApp(options: BootstrapOptions = {}): Promise<BootstrappedApp> {
+  const isProduction = process.env.APP_ENV === "production";
+  const { migrate: runMigrate = !isProduction } = options;
+
+  const appConfig = loadConfig();
+  const context = createAppContext();
+
+  if (runMigrate) {
+    await migrate();
+  }
+
+  const routes = buildRoutes(context.dependencies);
+
+  return { context, routes, config: appConfig };
+}
+
+export function createAppServer(routes: AppRouteMap, port = 0) {
+  return createWebServer({
+    port,
+    publicDir: "./public",
+    routes,
+  });
+}
+
+export { createAppContext };

package/dist/templates/src/bootstrap/database.ts

@@ -0,0 +1,30 @@
+import { SQL } from "bun";
+
+export type SqlClient = InstanceType<typeof SQL>;
+
+let sql: SqlClient | null = null;
+
+export function getSql(): SqlClient {
+  if (!sql) {
+    const url = process.env.DATABASE_URL;
+    if (!url) throw new Error("DATABASE_URL is required");
+    sql = new SQL({ url, max: 5 });
+  }
+  return sql;
+}
+
+export async function pingDatabase(): Promise<boolean> {
+  try {
+    await getSql()`SELECT 1`;
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function closeDatabase() {
+  if (sql) {
+    await sql.close();
+    sql = null;
+  }
+}

package/dist/templates/src/bootstrap/preload.ts

@@ -0,0 +1,5 @@
+import { join } from "node:path";
+import { configureModulesDirectory } from "@getstrata/bootstrap/discoverModules";
+
+process.env.DATABASE_URL ??= "postgresql://postgres:postgres@localhost:5432/{{PROJECT_NAME}}";
+configureModulesDirectory(join(import.meta.dir, "../modules"));

package/dist/templates/src/bootstrap/providers/auth.ts

@@ -0,0 +1,41 @@
+import { CORE_AUTH_TOKEN } from "@getstrata/bootstrap/config";
+import type { AuthUser } from "@getstrata/core/auth/authContext";
+import { currentAuthUser } from "@getstrata/core/auth/authContext";
+import type { ServiceProvider } from "@getstrata/core/contracts/di";
+
+class StarterAuthManager {
+  async resolve(request?: Request): Promise<AuthUser | null> {
+    if (request) {
+      const userId = request.headers.get("x-authenticated-user-id");
+      if (!userId) {
+        return null;
+      }
+
+      const role = request.headers.get("x-authenticated-user-role");
+
+      return {
+        id: userId,
+        ...(role ? { role } : {}),
+      };
+    }
+
+    return currentAuthUser();
+  }
+
+  user(request?: Request) {
+    return this.resolve(request);
+  }
+
+  async check(request: Request) {
+    return (await this.user(request)) !== null;
+  }
+}
+
+const authProvider: ServiceProvider = {
+  name: "starter.auth",
+  register({ container }) {
+    container.set(CORE_AUTH_TOKEN, new StarterAuthManager());
+  },
+};
+
+export default authProvider;

package/dist/templates/src/bootstrap/providers/cache.ts

@@ -0,0 +1,28 @@
+import { CORE_CACHE_TOKEN } from "@getstrata/bootstrap/config";
+import { createCacheStore } from "@getstrata/core/cache/createCacheStore";
+import { CacheRepository } from "@getstrata/core/cache/repository";
+import type { ServiceProvider } from "@getstrata/core/contracts/di";
+
+const cacheProvider: ServiceProvider = {
+  name: "starter.cache",
+  register({ container, config, dependencies }) {
+    container.singleton(CORE_CACHE_TOKEN, () => {
+      const ttlMs = config.get<number>("cache.ttlMs") ?? 3_600_000;
+      const maxEntries = config.get<number>("cache.maxEntries") ?? 100;
+      const driver = config.get<"array" | "redis">("cache.driver") ?? "array";
+
+      return new CacheRepository(
+        createCacheStore({
+          driver,
+          ttlMs,
+          maxEntries,
+          redisUrl: process.env.REDIS_URL,
+        }),
+      );
+    });
+
+    Reflect.set(dependencies, "cache", container.resolve(CORE_CACHE_TOKEN));
+  },
+};
+
+export default cacheProvider;