gorsee 0.1.3 → 0.2.1

package/src/plugins/prisma.ts

@@ -0,0 +1,85 @@
+// Prisma integration plugin -- zero external dependencies
+
+import type { MiddlewareFn, Context } from "../server/middleware.ts"
+import type { GorseePlugin } from "./index.ts"
+import { definePlugin } from "./index.ts"
+
+export interface PrismaPluginConfig {
+  schemaPath?: string
+  datasourceUrl?: string
+}
+
+let prismaClient: unknown = null
+
+/** Returns the current Prisma client (available after setup) */
+export function getPrisma<T = unknown>(): T {
+  if (!prismaClient) {
+    throw new Error("Prisma not initialized. Did you register prismaPlugin?")
+  }
+  return prismaClient as T
+}
+
+/** Middleware that attaches prisma to ctx.locals.prisma */
+export function prismaMiddleware(client: unknown): MiddlewareFn {
+  return async (ctx: Context, next) => {
+    ctx.locals.prisma = client
+    return next()
+  }
+}
+
+/** Generates a basic schema.prisma content string */
+export function generatePrismaSchema(config: PrismaPluginConfig): string {
+  const url = config.datasourceUrl ?? "file:./dev.db"
+  const provider = url.startsWith("file:") ? "sqlite"
+    : url.startsWith("postgres") ? "postgresql"
+    : "mysql"
+
+  return `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = "${url}"
+}
+
+// Add your models below
+// model User {
+//   id    Int     @id @default(autoincrement())
+//   email String  @unique
+//   name  String?
+// }
+`
+}
+
+/** Creates a Prisma integration plugin */
+export function prismaPlugin(config: PrismaPluginConfig = {}): GorseePlugin {
+  return definePlugin({
+    name: "gorsee-prisma",
+
+    async setup(app) {
+      try {
+        // Dynamic import -- PrismaClient must be generated by user
+        const { PrismaClient } = await import("@prisma/client" as string)
+        prismaClient = new PrismaClient({
+          datasourceUrl: config.datasourceUrl,
+        })
+      } catch {
+        // If @prisma/client not available, create a placeholder
+        prismaClient = {
+          _placeholder: true,
+          _message: "Run `bunx prisma generate` to create the client",
+        }
+      }
+
+      app.addMiddleware(prismaMiddleware(prismaClient))
+    },
+
+    async teardown() {
+      if (prismaClient && typeof (prismaClient as any).$disconnect === "function") {
+        await (prismaClient as any).$disconnect()
+      }
+      prismaClient = null
+    },
+  })
+}

package/src/plugins/resend.ts

@@ -0,0 +1,78 @@
+// 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

@@ -0,0 +1,102 @@
+// 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

@@ -0,0 +1,133 @@
+// 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

@@ -0,0 +1,92 @@
+// 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
+            })
+          },
+        },
+      ]
+    },
+  })
+}