gorsee 0.2.3 → 0.2.5

package/src/plugins/resend.ts

@@ -1,78 +0,0 @@
-// Resend email plugin -- uses native fetch, no SDK dependency
-
-import type { GorseePlugin } from "./index.ts"
-import { definePlugin } from "./index.ts"
-
-export interface ResendPluginConfig {
-  apiKey: string
-  from?: string
-}
-
-export interface SendEmailOptions {
-  to: string | string[]
-  subject: string
-  html?: string
-  text?: string
-  from?: string
-}
-
-export interface Mailer {
-  send(options: SendEmailOptions): Promise<{ id: string }>
-}
-
-const RESEND_API = "https://api.resend.com"
-
-let mailerInstance: Mailer | null = null
-
-/** Returns the mailer instance (available after setup) */
-export function getMailer(): Mailer {
-  if (!mailerInstance) {
-    throw new Error("Resend not initialized. Did you register resendPlugin?")
-  }
-  return mailerInstance
-}
-
-function createMailer(config: ResendPluginConfig): Mailer {
-  return {
-    async send(options: SendEmailOptions): Promise<{ id: string }> {
-      const body = {
-        from: options.from ?? config.from ?? "onboarding@resend.dev",
-        to: Array.isArray(options.to) ? options.to : [options.to],
-        subject: options.subject,
-        ...(options.html ? { html: options.html } : {}),
-        ...(options.text ? { text: options.text } : {}),
-      }
-
-      const res = await fetch(`${RESEND_API}/emails`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${config.apiKey}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(body),
-      })
-
-      if (!res.ok) {
-        const err = await res.text()
-        throw new Error(`Resend API error (${res.status}): ${err}`)
-      }
-
-      return (await res.json()) as { id: string }
-    },
-  }
-}
-
-/** Creates a Resend email plugin */
-export function resendPlugin(config: ResendPluginConfig): GorseePlugin {
-  return definePlugin({
-    name: "gorsee-resend",
-
-    async setup() {
-      mailerInstance = createMailer(config)
-    },
-
-    async teardown() {
-      mailerInstance = null
-    },
-  })
-}

package/src/plugins/s3.ts

@@ -1,102 +0,0 @@
-// S3-compatible object storage plugin -- uses native fetch, no AWS SDK
-
-import type { GorseePlugin } from "./index.ts"
-import { definePlugin } from "./index.ts"
-
-export interface S3PluginConfig {
-  bucket: string
-  region?: string
-  endpoint?: string
-  accessKeyId?: string
-  secretAccessKey?: string
-}
-
-export interface StorageClient {
-  upload(key: string, body: ArrayBuffer | ReadableStream | string, contentType?: string): Promise<string>
-  download(key: string): Promise<Response>
-  delete(key: string): Promise<void>
-  list(prefix?: string): Promise<string[]>
-}
-
-let storageClient: StorageClient | null = null
-
-/** Returns the storage client (available after setup) */
-export function getStorage(): StorageClient {
-  if (!storageClient) {
-    throw new Error("S3 not initialized. Did you register s3Plugin?")
-  }
-  return storageClient
-}
-
-function buildEndpoint(config: S3PluginConfig): string {
-  if (config.endpoint) return config.endpoint.replace(/\/$/, "")
-  const region = config.region ?? "us-east-1"
-  return `https://${config.bucket}.s3.${region}.amazonaws.com`
-}
-
-function createStorageClient(config: S3PluginConfig): StorageClient {
-  const baseUrl = buildEndpoint(config)
-  const headers: Record<string, string> = {}
-
-  // Basic auth headers (simplified -- production should use AWS Signature V4)
-  if (config.accessKeyId) {
-    headers["x-amz-access-key"] = config.accessKeyId
-  }
-
-  return {
-    async upload(key: string, body: ArrayBuffer | ReadableStream | string, contentType?: string) {
-      const url = `${baseUrl}/${encodeURIComponent(key)}`
-      const ct = contentType ?? "application/octet-stream"
-      const fetchBody: BodyInit = body instanceof ArrayBuffer
-        ? new Blob([body], { type: ct })
-        : body
-      const res = await fetch(url, {
-        method: "PUT",
-        headers: { ...headers, "Content-Type": ct },
-        body: fetchBody,
-      })
-      if (!res.ok) throw new Error(`S3 upload failed: ${res.status} ${res.statusText}`)
-      return url
-    },
-
-    async download(key) {
-      const url = `${baseUrl}/${encodeURIComponent(key)}`
-      const res = await fetch(url, { headers })
-      if (!res.ok) throw new Error(`S3 download failed: ${res.status} ${res.statusText}`)
-      return res
-    },
-
-    async delete(key) {
-      const url = `${baseUrl}/${encodeURIComponent(key)}`
-      const res = await fetch(url, { method: "DELETE", headers })
-      if (!res.ok) throw new Error(`S3 delete failed: ${res.status} ${res.statusText}`)
-    },
-
-    async list(prefix) {
-      const params = prefix ? `?list-type=2&prefix=${encodeURIComponent(prefix)}` : "?list-type=2"
-      const res = await fetch(`${baseUrl}${params}`, { headers })
-      if (!res.ok) throw new Error(`S3 list failed: ${res.status} ${res.statusText}`)
-      const xml = await res.text()
-      const keys: string[] = []
-      const regex = /<Key>([^<]+)<\/Key>/g
-      let match: RegExpExecArray | null
-      while ((match = regex.exec(xml)) !== null) keys.push(match[1]!)
-      return keys
-    },
-  }
-}
-
-/** Creates an S3-compatible storage plugin */
-export function s3Plugin(config: S3PluginConfig): GorseePlugin {
-  return definePlugin({
-    name: "gorsee-s3",
-
-    async setup() {
-      storageClient = createStorageClient(config)
-    },
-
-    async teardown() {
-      storageClient = null
-    },
-  })
-}

package/src/plugins/stripe.ts

@@ -1,133 +0,0 @@
-// Stripe payments plugin -- uses native fetch, no stripe SDK dependency
-
-import type { MiddlewareFn, Context } from "../server/middleware.ts"
-import type { GorseePlugin } from "./index.ts"
-import { definePlugin } from "./index.ts"
-
-export interface StripePluginConfig {
-  secretKey: string
-  webhookSecret?: string
-}
-
-export interface CheckoutSessionOptions {
-  lineItems: Array<{ price: string; quantity: number }>
-  mode?: "payment" | "subscription"
-  successUrl: string
-  cancelUrl: string
-}
-
-export interface StripeEvent {
-  id: string
-  type: string
-  data: { object: Record<string, unknown> }
-}
-
-export interface StripeClient {
-  createCheckoutSession(options: CheckoutSessionOptions): Promise<{ url: string; id: string }>
-  verifyWebhook(request: Request): Promise<StripeEvent>
-}
-
-const STRIPE_API = "https://api.stripe.com/v1"
-
-let stripeClient: StripeClient | null = null
-
-/** Returns the Stripe client (available after setup) */
-export function getStripe(): StripeClient {
-  if (!stripeClient) {
-    throw new Error("Stripe not initialized. Did you register stripePlugin?")
-  }
-  return stripeClient
-}
-
-function createStripeClient(config: StripePluginConfig): StripeClient {
-  const authHeader = `Basic ${btoa(config.secretKey + ":")}`
-
-  return {
-    async createCheckoutSession(options) {
-      const params = new URLSearchParams()
-      params.set("mode", options.mode ?? "payment")
-      params.set("success_url", options.successUrl)
-      params.set("cancel_url", options.cancelUrl)
-      options.lineItems.forEach((item, i) => {
-        params.set(`line_items[${i}][price]`, item.price)
-        params.set(`line_items[${i}][quantity]`, String(item.quantity))
-      })
-
-      const res = await fetch(`${STRIPE_API}/checkout/sessions`, {
-        method: "POST",
-        headers: { Authorization: authHeader, "Content-Type": "application/x-www-form-urlencoded" },
-        body: params.toString(),
-      })
-
-      if (!res.ok) {
-        const err = await res.text()
-        throw new Error(`Stripe API error (${res.status}): ${err}`)
-      }
-
-      const data = (await res.json()) as { url: string; id: string }
-      return { url: data.url, id: data.id }
-    },
-
-    async verifyWebhook(request: Request) {
-      const body = await request.text()
-      const sig = request.headers.get("stripe-signature") ?? ""
-
-      if (!config.webhookSecret) {
-        throw new Error("Webhook secret not configured")
-      }
-
-      // Verify signature using HMAC-SHA256
-      const encoder = new TextEncoder()
-      const timestamp = sig.split(",").find((s) => s.startsWith("t="))?.slice(2) ?? ""
-      const v1Sig = sig.split(",").find((s) => s.startsWith("v1="))?.slice(3) ?? ""
-      const payload = `${timestamp}.${body}`
-
-      const key = await crypto.subtle.importKey(
-        "raw",
-        encoder.encode(config.webhookSecret),
-        { name: "HMAC", hash: "SHA-256" },
-        false,
-        ["sign"],
-      )
-      const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload))
-      const expected = Array.from(new Uint8Array(signature))
-        .map((b) => b.toString(16).padStart(2, "0"))
-        .join("")
-
-      if (expected !== v1Sig) {
-        throw new Error("Invalid webhook signature")
-      }
-
-      return JSON.parse(body) as StripeEvent
-    },
-  }
-}
-
-/** Creates a Stripe payments plugin */
-export function stripePlugin(config: StripePluginConfig): GorseePlugin {
-  return definePlugin({
-    name: "gorsee-stripe",
-
-    async setup(app) {
-      stripeClient = createStripeClient(config)
-
-      // Register webhook route if webhook secret is configured
-      if (config.webhookSecret) {
-        app.addRoute("/api/stripe/webhook", async (ctx) => {
-          try {
-            const event = await stripeClient!.verifyWebhook(ctx.request)
-            return new Response(JSON.stringify({ received: true, type: event.type }), {
-              headers: { "Content-Type": "application/json" },
-            })
-          } catch (err) {
-            return new Response(JSON.stringify({ error: String(err) }), { status: 400 })
-          }
-        })
-      }
-    },
-
-    async teardown() {
-      stripeClient = null
-    },
-  })
-}

package/src/plugins/tailwind.ts

@@ -1,92 +0,0 @@
-// Tailwind CSS integration plugin -- build pipeline hook
-
-import type { GorseePlugin } from "./index.ts"
-import { definePlugin } from "./index.ts"
-
-export interface TailwindPluginConfig {
-  configPath?: string
-  inputCSS?: string
-  outputCSS?: string
-}
-
-/** Generates tailwind.config.ts content */
-export function generateTailwindConfig(options?: {
-  content?: string[]
-  theme?: Record<string, unknown>
-}): string {
-  const content = options?.content ?? [
-    "./routes/**/*.{tsx,ts}",
-    "./components/**/*.{tsx,ts}",
-  ]
-  const themeStr = options?.theme
-    ? JSON.stringify(options.theme, null, 4)
-    : "{}"
-
-  return `/** @type {import('tailwindcss').Config} */
-export default {
-  content: ${JSON.stringify(content, null, 4)},
-  theme: {
-    extend: ${themeStr},
-  },
-  plugins: [],
-}
-`
-}
-
-/** Generates base CSS with @tailwind directives */
-export function generateTailwindCSS(): string {
-  return `@tailwind base;
-@tailwind components;
-@tailwind utilities;
-`
-}
-
-/** Creates a Tailwind CSS integration plugin */
-export function tailwindPlugin(config: TailwindPluginConfig = {}): GorseePlugin {
-  const inputCSS = config.inputCSS ?? "./styles/globals.css"
-  const outputCSS = config.outputCSS ?? "./.gorsee/client/tailwind.css"
-
-  return definePlugin({
-    name: "gorsee-tailwind",
-
-    async setup() {
-      // Generate tailwind.config.ts if it doesn't exist
-      const configPath = config.configPath ?? "./tailwind.config.ts"
-      const file = Bun.file(configPath)
-      if (!(await file.exists())) {
-        await Bun.write(configPath, generateTailwindConfig())
-      }
-    },
-
-    buildPlugins() {
-      return [
-        {
-          name: "gorsee-tailwind-transform",
-          setup(build) {
-            build.onLoad({ filter: /\.css$/ }, async (args) => {
-              const source = await Bun.file(args.path).text()
-
-              // If file contains @tailwind directives, process it
-              if (source.includes("@tailwind")) {
-                try {
-                  const proc = Bun.spawn(
-                    ["bunx", "tailwindcss", "-i", args.path, "-o", outputCSS, "--minify"],
-                    { stdin: "inherit", stdout: "pipe", stderr: "pipe" },
-                  )
-                  await proc.exited
-                  const processed = await Bun.file(outputCSS).text()
-                  return { contents: processed, loader: "css" }
-                } catch {
-                  // Fallback: return raw CSS if tailwindcss CLI not available
-                  return { contents: source, loader: "css" }
-                }
-              }
-
-              return undefined
-            })
-          },
-        },
-      ]
-    },
-  })
-}

package/src/prod.ts

@@ -1,252 +0,0 @@
-// Gorsee.js Production Server
-// Serves pre-built client bundles + SSR pages from dist/
-
-import { createRouter, matchRoute, buildStaticMap } from "./router/index.ts"
-import { securityHeaders } from "./security/headers.ts"
-import { createRateLimiter } from "./security/rate-limit.ts"
-import { renderToStream, streamJsx } from "./runtime/stream.ts"
-import { resetServerHead, getServerHead } from "./runtime/head.ts"
-import type { MiddlewareFn } from "./server/middleware.ts"
-import { compress } from "./server/compress.ts"
-import { log, setLogLevel } from "./log/index.ts"
-import { loadEnv } from "./env/index.ts"
-import { generateNonce, wrapHTML } from "./server/html-shell.ts"
-import { renderNotFoundPage } from "./server/not-found.ts"
-import { createRateLimitResponse, handleRPCWithHeaders } from "./server/request-preflight.ts"
-import {
-  buildPartialResponsePayload,
-  createClientScriptPath,
-  renderPageDocument,
-} from "./server/page-render.ts"
-import { handleRouteRequest } from "./server/route-request.ts"
-import { servePrefixedStaticFile, serveStaticFile } from "./server/static-file.ts"
-import {
-  getClientBundleForRoute,
-  getPrerenderedHtmlPath,
-  isPrerenderedRoute,
-  loadBuildManifest,
-} from "./server/manifest.ts"
-import { join } from "node:path"
-import { createProjectContext, resolveRuntimeEnv, type RuntimeOptions } from "./runtime/project.ts"
-// Route type used implicitly via createRouter return
-
-interface StartProductionServerOptions extends RuntimeOptions {
-  port?: number
-  registerSignalHandlers?: boolean
-}
-
-interface ProductionRuntimeState {
-  cwd: string
-  routesDir: string
-  publicDir: string
-  distDir: string
-  clientDir: string
-  manifest: Awaited<ReturnType<typeof loadBuildManifest>>
-  routes: Awaited<ReturnType<typeof createRouter>>
-  staticMap: ReturnType<typeof buildStaticMap>
-  rateLimiter: ReturnType<typeof createRateLimiter>
-  compressMiddleware: ReturnType<typeof compress>
-}
-
-async function tryServeStatic(
-  pathname: string,
-  request: Request,
-  publicDir: string,
-  clientDir: string,
-  secHeaders: Record<string, string>,
-): Promise<Response | null> {
-  if (pathname === "/") return null
-  // Client assets from dist/
-  const bundleResponse = await servePrefixedStaticFile(pathname, "/_gorsee/", clientDir, {
-    contentType: "application/javascript",
-    cacheControl: "public, max-age=31536000, immutable",
-    extraHeaders: secHeaders,
-  })
-  if (bundleResponse) return bundleResponse
-
-  // Public files
-  return serveStaticFile(publicDir, pathname.slice(1), {
-    request,
-    etag: true,
-    cacheControl: "public, max-age=3600",
-    extraHeaders: secHeaders,
-  })
-}
-
-async function tryServePrerenderedPage(
-  pathname: string,
-  request: Request,
-  manifest: Awaited<ReturnType<typeof loadBuildManifest>>,
-  distDir: string,
-  secHeaders: Record<string, string>,
-): Promise<Response | null> {
-  if (request.method !== "GET") return null
-  if (!isPrerenderedRoute(manifest, pathname)) return null
-
-  return serveStaticFile(join(distDir, "static"), getPrerenderedHtmlPath(pathname), {
-    request,
-    etag: true,
-    cacheControl: "public, max-age=3600",
-    contentType: "text/html; charset=utf-8",
-    extraHeaders: secHeaders,
-  })
-}
-
-export async function startProductionServer(options: StartProductionServerOptions = {}) {
-  const runtime = createProjectContext(options)
-  const registerSignalHandlers = options.registerSignalHandlers ?? true
-
-  await loadEnv(runtime.cwd)
-  const envConfig = resolveRuntimeEnv(process.env)
-  const port = options.port ?? envConfig.port
-  const fetchHandler = await createProductionFetchHandler({ cwd: runtime.cwd, env: process.env })
-  log.info("production server starting", { cwd: runtime.cwd })
-
-  const server = Bun.serve({
-    port,
-    fetch: fetchHandler,
-  })
-
-  log.info("production server started", { url: `http://localhost:${server.port}` })
-
-  // Graceful shutdown
-  if (registerSignalHandlers) {
-    const shutdown = () => {
-      log.info("shutting down...")
-      server.stop(true) // close existing connections gracefully
-      process.exit(0)
-    }
-    process.on("SIGTERM", shutdown)
-    process.on("SIGINT", shutdown)
-  }
-
-  return server
-}
-
-export async function createProductionFetchHandler(
-  options: Pick<StartProductionServerOptions, "cwd" | "env"> = {},
-): Promise<(request: Request, server?: { requestIP(request: Request): { address: string } | null }) => Promise<Response>> {
-  const state = await loadProductionRuntimeState(options)
-
-  return async (request, server) => {
-    const url = new URL(request.url)
-    const pathname = url.pathname
-
-    const ip = server?.requestIP(request)?.address ?? "unknown"
-    const rateLimitResponse = createRateLimitResponse(state.rateLimiter, ip)
-    if (rateLimitResponse) return rateLimitResponse
-
-    const nonce = generateNonce()
-    const secHeaders = securityHeaders({}, nonce)
-
-    const rpcResponse = await handleRPCWithHeaders(request, secHeaders)
-    if (rpcResponse) return rpcResponse
-
-    const staticResponse = await tryServeStatic(pathname, request, state.publicDir, state.clientDir, secHeaders)
-    if (staticResponse) return staticResponse
-
-    const prerenderedResponse = await tryServePrerenderedPage(pathname, request, state.manifest, state.distDir, secHeaders)
-    if (prerenderedResponse) return prerenderedResponse
-
-    const match = matchRoute(state.routes, pathname, state.staticMap)
-    if (!match) {
-      return new Response(await renderNotFoundPage(state.routesDir, nonce), {
-        status: 404,
-        headers: { "Content-Type": "text/html", ...secHeaders },
-      })
-    }
-
-    try {
-      return await handleRouteRequest({
-        match,
-        request,
-        extraMiddlewares: [state.compressMiddleware satisfies MiddlewareFn],
-        onPartialRequest: async ({ ctx, resolved }) => {
-          const { pageComponent, loaderData, cssFiles } = resolved
-          const rendered = renderPageDocument(pageComponent, ctx, match.params, loaderData)
-          const clientScript = createClientScriptPath(getClientBundleForRoute(state.manifest, match.route.path))
-          const partialPayload = buildPartialResponsePayload(
-            rendered,
-            loaderData,
-            match.params,
-            cssFiles,
-            clientScript,
-          )
-          return new Response(JSON.stringify(partialPayload), {
-            headers: { "Content-Type": "application/json", ...secHeaders },
-          })
-        },
-        onPageRequest: async ({ ctx, resolved }) => {
-          const { pageComponent, loaderData, cssFiles, renderMode } = resolved
-
-          const pageProps = { params: match.params, ctx, data: loaderData }
-          const clientScript = createClientScriptPath(getClientBundleForRoute(state.manifest, match.route.path))
-
-          if (renderMode === "stream") {
-            resetServerHead()
-            const vnode = streamJsx(pageComponent as any, pageProps)
-            const stream = renderToStream(vnode, {
-              shell: (body: string) => wrapHTML(body, nonce, {
-                clientScript,
-                loaderData,
-                params: match.params,
-                cssFiles,
-                headElements: getServerHead(),
-              }),
-            })
-            return new Response(stream, {
-              headers: { "Content-Type": "text/html", ...secHeaders },
-            })
-          }
-
-          const rendered = renderPageDocument(pageComponent, ctx, match.params, loaderData)
-          const html = wrapHTML(rendered.html, nonce, {
-            clientScript,
-            loaderData,
-            params: match.params,
-            cssFiles,
-            headElements: rendered.headElements,
-          })
-          return new Response(html, {
-            headers: { "Content-Type": "text/html", ...secHeaders },
-          })
-        },
-      })
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err)
-      log.error("request error", { path: pathname, error: message })
-      return new Response(wrapHTML("<h1>500</h1><p>Internal Server Error</p>", nonce), {
-        status: 500,
-        headers: { "Content-Type": "text/html", ...secHeaders },
-      })
-    }
-  }
-}
-
-async function loadProductionRuntimeState(options: RuntimeOptions = {}): Promise<ProductionRuntimeState> {
-  const runtime = createProjectContext(options)
-
-  await loadEnv(runtime.cwd)
-  const envConfig = resolveRuntimeEnv(process.env)
-  setLogLevel(envConfig.logLevel)
-
-  const manifest = await loadBuildManifest(runtime.paths.distDir)
-  log.info("loaded manifest", { routes: Object.keys(manifest.routes).length, built: manifest.buildTime })
-
-  const routes = await createRouter(runtime.paths.routesDir)
-  const staticMap = buildStaticMap(routes)
-  const rateLimiter = createRateLimiter(envConfig.rateLimit, envConfig.rateWindow)
-
-  return {
-    cwd: runtime.cwd,
-    routesDir: runtime.paths.routesDir,
-    publicDir: runtime.paths.publicDir,
-    distDir: runtime.paths.distDir,
-    clientDir: runtime.paths.clientDir,
-    manifest,
-    routes,
-    staticMap,
-    rateLimiter,
-    compressMiddleware: compress(),
-  }
-}

package/src/reactive/computed.ts

@@ -1,7 +0,0 @@
-import { computed as alienComputed } from "alien-signals"
-
-export type ComputedGetter<T> = () => T
-
-export function createComputed<T>(fn: () => T): ComputedGetter<T> {
-  return alienComputed(fn)
-}

package/src/reactive/effect.ts

@@ -1,7 +0,0 @@
-import { effect as alienEffect } from "alien-signals"
-
-export type CleanupFn = () => void
-
-export function createEffect(fn: () => void): CleanupFn {
-  return alienEffect(fn)
-}

package/src/reactive/index.ts

@@ -1,7 +0,0 @@
-export { createSignal } from "./signal.ts"
-export { createComputed } from "./computed.ts"
-export { createEffect } from "./effect.ts"
-export { createResource, invalidateResource, invalidateAll } from "./resource.ts"
-export { createStore } from "./store.ts"
-export { createLive, type LiveOptions, type LiveSignal } from "./live.ts"
-export { createMutation, type Mutation, type MutationState, type MutationOptions } from "./optimistic.ts"