hazo_connect 2.0.2 → 2.1.0

package/app/globals.css

@@ -0,0 +1,16 @@
+/* globals.css defines base Tailwind layers and root-level tokens for hazo_connect. */
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* base_layer sets foundational styles shared across the library. */
+:root {
+  color-scheme: light;
+}
+
+/* body_reset normalizes default margins and background color. */
+body {
+  margin: 0;
+  background-color: #f8fafc;
+}
+

package/app/hazo_connect/api/sqlite/data/route.ts

@@ -0,0 +1,188 @@
+import { NextRequest, NextResponse } from "next/server"
+import {
+  getSqliteAdminService,
+  type RowQueryOptions,
+  type SqliteFilterOperator,
+  type SqliteWhereFilter
+} from "hazo_connect"
+
+export const dynamic = "force-dynamic"
+const allowedOperators: SqliteFilterOperator[] = [
+  "eq",
+  "neq",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "ilike",
+  "is"
+]
+
+export async function GET(request: NextRequest) {
+  const url = new URL(request.url)
+  const table = url.searchParams.get("table")
+  if (!table) {
+    return NextResponse.json(
+      { error: "Query parameter 'table' is required." },
+      { status: 400 }
+    )
+  }
+
+  try {
+    const service = getSqliteAdminService()
+    const options = parseRowQueryOptions(url.searchParams)
+    const page = await service.getTableData(table, options)
+    return NextResponse.json({ data: page.rows, total: page.total })
+  } catch (error) {
+    return toErrorResponse(error, `Failed to fetch data for table '${table}'`)
+  }
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const service = getSqliteAdminService()
+    const payload = await request.json()
+    const table = payload?.table
+    const data = payload?.data
+
+    if (!table || typeof data !== "object" || Array.isArray(data)) {
+      return NextResponse.json(
+        { error: "Request body must include 'table' and a 'data' object." },
+        { status: 400 }
+      )
+    }
+
+    const inserted = await service.insertRow(table, data)
+    return NextResponse.json({ data: inserted })
+  } catch (error) {
+    return toErrorResponse(error, "Failed to insert row")
+  }
+}
+
+export async function PATCH(request: NextRequest) {
+  try {
+    const service = getSqliteAdminService()
+    const payload = await request.json()
+    const table = payload?.table
+    const data = payload?.data
+    const criteria = payload?.criteria
+
+    if (
+      !table ||
+      typeof data !== "object" ||
+      Array.isArray(data) ||
+      typeof criteria !== "object" ||
+      criteria === null ||
+      Array.isArray(criteria)
+    ) {
+      return NextResponse.json(
+        {
+          error:
+            "Request body must include 'table', 'data' object, and a 'criteria' object for the rows to update."
+        },
+        { status: 400 }
+      )
+    }
+
+    const rows = await service.updateRows(table, criteria, data)
+    return NextResponse.json({ data: rows, updated: rows.length })
+  } catch (error) {
+    return toErrorResponse(error, "Failed to update rows")
+  }
+}
+
+export async function DELETE(request: NextRequest) {
+  try {
+    const service = getSqliteAdminService()
+    const payload = await request.json()
+    const table = payload?.table
+    const criteria = payload?.criteria
+
+    if (
+      !table ||
+      typeof criteria !== "object" ||
+      criteria === null ||
+      Array.isArray(criteria)
+    ) {
+      return NextResponse.json(
+        {
+          error:
+            "Request body must include 'table' and a 'criteria' object for the rows to delete."
+        },
+        { status: 400 }
+      )
+    }
+
+    const rows = await service.deleteRows(table, criteria)
+    return NextResponse.json({ data: rows, deleted: rows.length })
+  } catch (error) {
+    return toErrorResponse(error, "Failed to delete rows")
+  }
+}
+
+function parseRowQueryOptions(params: URLSearchParams): RowQueryOptions {
+  const limitParam = params.get("limit")
+  const offsetParam = params.get("offset")
+  const orderBy = params.get("orderBy") ?? undefined
+  const orderDirection = parseOrderDirection(params.get("orderDirection"))
+  const filters = parseFilters(params)
+
+  const limit = limitParam ? Number.parseInt(limitParam, 10) : undefined
+  const offset = offsetParam ? Number.parseInt(offsetParam, 10) : undefined
+
+  return {
+    limit: Number.isNaN(limit) ? undefined : limit,
+    offset: Number.isNaN(offset) ? undefined : offset,
+    order_by: orderBy ?? undefined,
+    order_direction: orderDirection,
+    filters: filters.length ? filters : undefined
+  }
+}
+
+function parseFilters(params: URLSearchParams): SqliteWhereFilter[] {
+  const filters: SqliteWhereFilter[] = []
+
+  params.forEach((value, key) => {
+    const match = key.match(/^filter\[(.+?)\](?:\[(.+)\])?$/)
+    if (!match) {
+      return
+    }
+    const column = match[1]
+    const operatorValue = (match[2] ?? "eq").toLowerCase()
+    if (!isAllowedOperator(operatorValue)) {
+      throw new Error(`Unsupported filter operator '${operatorValue}'`)
+    }
+    filters.push({
+      column,
+      operator: operatorValue as SqliteFilterOperator,
+      value
+    })
+  })
+
+  return filters
+}
+
+function parseOrderDirection(
+  direction: string | null
+): "asc" | "desc" | undefined {
+  if (!direction) {
+    return undefined
+  }
+  const normalized = direction.toLowerCase()
+  if (normalized === "asc" || normalized === "desc") {
+    return normalized
+  }
+  throw new Error(`Unsupported order direction '${direction}'`)
+}
+
+function isAllowedOperator(value: string): value is SqliteFilterOperator {
+  return allowedOperators.includes(value as SqliteFilterOperator)
+}
+
+function toErrorResponse(error: unknown, fallback: string) {
+  const message = error instanceof Error ? error.message : fallback
+  const status = message.toLowerCase().includes("required") ? 400 : 500
+  return NextResponse.json({ error: message }, { status })
+}
+

package/app/hazo_connect/api/sqlite/schema/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest, NextResponse } from "next/server"
+import { getSqliteAdminService } from "hazo_connect"
+
+export const dynamic = "force-dynamic"
+
+export async function GET(request: NextRequest) {
+  const service = getSqliteAdminService()
+  const url = new URL(request.url)
+  const table = url.searchParams.get("table")
+
+  if (!table) {
+    return NextResponse.json(
+      { error: "Query parameter 'table' is required." },
+      { status: 400 }
+    )
+  }
+
+  try {
+    const schema = await service.getTableSchema(table)
+    return NextResponse.json({ data: schema })
+  } catch (error) {
+    return toErrorResponse(error, `Failed to load schema for table '${table}'`)
+  }
+}
+
+function toErrorResponse(error: unknown, fallback: string) {
+  const message = error instanceof Error ? error.message : fallback
+  const status = message.toLowerCase().includes("required") ? 400 : 500
+  return NextResponse.json({ error: message }, { status })
+}
+

package/app/hazo_connect/api/sqlite/tables/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from "next/server"
+import { getSqliteAdminService } from "hazo_connect"
+
+export const dynamic = "force-dynamic"
+
+export async function GET() {
+  try {
+    const service = getSqliteAdminService()
+    const tables = await service.listTables()
+    return NextResponse.json({ data: tables })
+  } catch (error) {
+    return toErrorResponse(error, "Failed to list SQLite tables")
+  }
+}
+
+function toErrorResponse(error: unknown, fallback: string) {
+  const message = error instanceof Error ? error.message : fallback
+  const status = message.toLowerCase().includes("required") ? 400 : 500
+  return NextResponse.json({ error: message }, { status })
+}
+

package/app/hazo_connect/middleware.ts

@@ -0,0 +1,40 @@
+/**
+ * Purpose: Middleware to check if SQLite admin UI is enabled before allowing access to routes.
+ *
+ * This middleware ensures that the admin UI routes are only accessible when explicitly enabled
+ * in the hazo_connect configuration.
+ */
+
+import { NextResponse } from "next/server"
+import type { NextRequest } from "next/server"
+
+export function middleware(request: NextRequest) {
+  // Check if this is an admin UI route
+  if (
+    request.nextUrl.pathname.startsWith("/hazo_connect/sqlite_admin") ||
+    request.nextUrl.pathname.startsWith("/hazo_connect/api/sqlite")
+  ) {
+    // Check if admin UI is enabled via environment variable or config
+    // The admin service will throw an error if not enabled, but we can provide a better message here
+    const adminUiEnabled =
+      process.env.HAZO_CONNECT_ENABLE_ADMIN_UI === "true" ||
+      process.env.ENABLE_SQLITE_ADMIN_UI === "true"
+
+    if (!adminUiEnabled) {
+      return NextResponse.json(
+        {
+          error:
+            "SQLite admin UI is not enabled. Set 'enable_admin_ui: true' in your hazo_connect configuration or set HAZO_CONNECT_ENABLE_ADMIN_UI=true environment variable."
+        },
+        { status: 403 }
+      )
+    }
+  }
+
+  return NextResponse.next()
+}
+
+export const config = {
+  matcher: ["/hazo_connect/sqlite_admin/:path*", "/hazo_connect/api/sqlite/:path*"]
+}
+

package/app/hazo_connect/sqlite_admin/page.tsx

@@ -0,0 +1,26 @@
+import { getSqliteAdminService, type TableSummary } from "hazo_connect"
+import SqliteAdminClient from "./sqlite-admin-client"
+
+export const dynamic = "force-dynamic"
+
+export default async function SqliteAdminPage() {
+  const service = getSqliteAdminService()
+
+  try {
+    const tables = await service.listTables()
+    return <SqliteAdminClient initialTables={tables} />
+  } catch (error) {
+    const message =
+      error instanceof Error ? error.message : "Failed to initialise SQLite admin UI."
+
+    return (
+      <section className="mx-auto flex max-w-4xl flex-col gap-4 p-6">
+        <h1 className="text-2xl font-semibold text-slate-900">SQLite Admin</h1>
+        <p className="rounded-md border border-red-200 bg-red-50 p-4 text-sm text-red-700">
+          {message}
+        </p>
+      </section>
+    )
+  }
+}
+