nothing-browser 0.0.16 → 0.0.18

package/piggy/server/index.d.ts

@@ -1,21 +1,58 @@
+// piggy/server/index.d.ts
 import { Elysia } from "elysia";
+
 export type BeforeMiddleware = (ctx: {
-    params: Record<string, string>;
-    query: Record<string, string>;
-    body: any;
-    headers: Record<string, string>;
-    set: any;
+  params: Record<string, string>;
+  query: Record<string, string>;
+  body: any;
+  headers: Record<string, string>;
+  set: any;
 }) => void | Promise<void>;
-export type RouteHandler = (params: Record<string, string>, query: Record<string, string>, body: any) => Promise<any>;
+
+export type RouteHandler = (
+  params: Record<string, string>,
+  query: Record<string, string>,
+  body: any
+) => Promise<any>;
+
+export interface RouteParameter {
+  name: string;
+  in: "query" | "path" | "header" | "cookie";
+  description?: string;
+  required?: boolean;
+  schema?: Record<string, any>;
+}
+
+export interface RouteDetail {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  deprecated?: boolean;
+  hide?: boolean;
+  parameters?: RouteParameter[];
+}
+
 export interface RouteConfig {
-    path: string;
-    method: "GET" | "POST" | "PUT" | "DELETE";
-    handler: RouteHandler;
-    ttl: number;
-    before: BeforeMiddleware[];
+  path: string;
+  method: "GET" | "POST" | "PUT" | "DELETE";
+  handler: RouteHandler;
+  ttl: number;
+  before: BeforeMiddleware[];
+  detail?: RouteDetail;
 }
+
 export declare const routeRegistry: Map<string, RouteConfig>;
 export declare const keepAliveSites: Set<string>;
-export declare function startServer(port: number, hostname?: string): Promise<Elysia>;
-export declare function stopServer(): void;
-//# sourceMappingURL=index.d.ts.map
+
+export declare function startServer(
+  port: number,
+  hostname?: string,
+  openapiOpts?: {
+    title?: string;
+    version?: string;
+    description?: string;
+    path?: string;
+  }
+): Promise<Elysia>;
+
+export declare function stopServer(): void;

package/piggy/server/index.ts

@@ -1,5 +1,6 @@
 // piggy/server/index.ts
 import { Elysia } from "elysia";
+import { openapi } from "@elysiajs/openapi";
 import * as cache from "../cache/memory";
 import logger from "../logger";
 
@@ -17,12 +18,30 @@ export type RouteHandler = (
   body: any
 ) => Promise<any>;
 
+export interface RouteParameter {
+  name: string;
+  in: "query" | "path" | "header" | "cookie";
+  description?: string;
+  required?: boolean;
+  schema?: Record<string, any>;
+}
+
+export interface RouteDetail {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  deprecated?: boolean;
+  hide?: boolean;
+  parameters?: RouteParameter[];
+}
+
 export interface RouteConfig {
   path: string;
   method: "GET" | "POST" | "PUT" | "DELETE";
   handler: RouteHandler;
   ttl: number;
   before: BeforeMiddleware[];
+  detail?: RouteDetail;
 }
 
 export const routeRegistry = new Map<string, RouteConfig>();
@@ -45,28 +64,56 @@ function mapError(err: Error, site: string) {
 
 let _app: Elysia | null = null;
 
-export async function startServer(port: number, hostname = "0.0.0.0"): Promise<Elysia> {
+export async function startServer(
+  port: number,
+  hostname = "0.0.0.0",
+  openapiOpts?: {
+    title?: string;
+    version?: string;
+    description?: string;
+    path?: string;
+  }
+): Promise<Elysia> {
   _app = new Elysia();
 
-  // ── Health route ────────────────────────────────────────────────────────────
+  // ── OpenAPI ───────────────────────────────────────────────────────────────
+  _app.use(
+    openapi({
+      path: openapiOpts?.path ?? "/openapi",
+      documentation: {
+        info: {
+          title:       openapiOpts?.title       ?? "Piggy API",
+          version:     openapiOpts?.version     ?? "1.0.0",
+          description: openapiOpts?.description ?? "Auto-generated docs for all registered piggy routes",
+        },
+      },
+    })
+  );
+
+  // ── Health ────────────────────────────────────────────────────────────────
   _app.get("/health", () => ({
     status: "ok",
     routes: routeRegistry.size,
     cacheEntries: cache.size(),
     uptime: process.uptime(),
-  }));
+  }), {
+    detail: { tags: ["_piggy"], summary: "Health check" },
+  });
 
-  // ── Cache management routes ─────────────────────────────────────────────────
+  // ── Cache ─────────────────────────────────────────────────────────────────
   _app.delete("/cache", () => {
     cache.clear();
     return { cleared: true };
+  }, {
+    detail: { tags: ["_piggy"], summary: "Clear all cache entries" },
   });
 
-  _app.get("/cache/keys", () => ({ keys: cache.keys() }));
+  _app.get("/cache/keys", () => ({ keys: cache.keys() }), {
+    detail: { tags: ["_piggy"], summary: "List all cache keys" },
+  });
 
-  // ── Registered site routes ──────────────────────────────────────────────────
+  // ── Registered site routes ────────────────────────────────────────────────
   for (const [registryKey, config] of routeRegistry.entries()) {
-    // registryKey format is "siteName:path" e.g. "movie:/title"
     const colonIdx = registryKey.indexOf(":");
     const siteName = registryKey.substring(0, colonIdx);
     const fullPath = `/${siteName}${config.path}`;
@@ -75,7 +122,6 @@ export async function startServer(port: number, hostname = "0.0.0.0"): Promise<E
     logger.info(`[server] mounting ${config.method} ${fullPath} (ttl=${config.ttl}ms)`);
 
     const routeHandler = async ({ params, query, body, headers, set }: any) => {
-      // 1. Run before middleware
       for (const mw of config.before) {
         try {
           await mw({ params, query, body, headers, set });
@@ -85,7 +131,6 @@ export async function startServer(port: number, hostname = "0.0.0.0"): Promise<E
         }
       }
 
-      // 2. Cache check
       const cacheKey = `${siteName}:${fullPath}:${JSON.stringify({ params, query })}`;
       const hit = cache.get(cacheKey);
       if (hit !== null) {
@@ -94,7 +139,6 @@ export async function startServer(port: number, hostname = "0.0.0.0"): Promise<E
         return hit;
       }
 
-      // 3. Execute handler
       let result: any;
       try {
         result = await config.handler(params, query, body);
@@ -104,7 +148,6 @@ export async function startServer(port: number, hostname = "0.0.0.0"): Promise<E
         return mapped;
       }
 
-      // 4. Store in cache
       if (config.ttl > 0) {
         cache.set(cacheKey, result, config.ttl);
         set.headers["x-cache"] = "MISS";
@@ -113,15 +156,25 @@ export async function startServer(port: number, hostname = "0.0.0.0"): Promise<E
       return result;
     };
 
-    if (method === "get")         _app.get(fullPath, routeHandler);
-    else if (method === "post")   _app.post(fullPath, routeHandler);
-    else if (method === "put")    _app.put(fullPath, routeHandler);
-    else if (method === "delete") _app.delete(fullPath, routeHandler);
+    const routeDetail = {
+      tags:        config.detail?.tags        ?? [siteName],
+      summary:     config.detail?.summary     ?? `${config.method} ${fullPath}`,
+      description: config.detail?.description,
+      deprecated:  config.detail?.deprecated  ?? false,
+      hide:        config.detail?.hide        ?? false,
+      parameters:  config.detail?.parameters  ?? [],
+    };
+
+    if (method === "get")         _app.get(fullPath, routeHandler,    { detail: routeDetail });
+    else if (method === "post")   _app.post(fullPath, routeHandler,   { detail: routeDetail });
+    else if (method === "put")    _app.put(fullPath, routeHandler,    { detail: routeDetail });
+    else if (method === "delete") _app.delete(fullPath, routeHandler, { detail: routeDetail });
   }
 
   _app.listen({ port, hostname });
 
   logger.success(`🚀 Piggy API server → http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`);
+  logger.success(`📖 OpenAPI docs     → http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}/openapi`);
   logger.info(`   Routes mounted: ${routeRegistry.size}`);
   routeRegistry.forEach((cfg, key) => {
     const siteName = key.substring(0, key.indexOf(":"));

package/piggy/store/index.d.ts

@@ -0,0 +1,26 @@
+// piggy/store/index.d.ts
+export type FieldType = "string" | "number" | "boolean" | "object" | "array";
+
+export interface FieldSchema {
+  type: FieldType;
+  required?: boolean;
+  default?: any;
+}
+
+export interface StoreSchema {
+  name: string;
+  destination: string;
+  fields: Record<string, FieldSchema>;
+}
+
+export interface PiggyStoreConfig {
+  stores: StoreSchema[];
+}
+
+export declare function loadStoreConfig(configPath?: string): PiggyStoreConfig;
+export declare function getSchema(storeName: string): StoreSchema | null;
+export declare function shapeRecord(data: Record<string, any>, schema: StoreSchema): Record<string, any>;
+export declare function storeRecord(
+  storeName: string,
+  data: Record<string, any> | Record<string, any>[]
+): Promise<{ stored: number; skipped: number }>;

package/piggy/store/index.ts

@@ -0,0 +1,230 @@
+// piggy/store/index.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import logger from "../logger";
+
+// ── Types ─────────────────────────────────────────────────────────────────────
+
+export type FieldType = "string" | "number" | "boolean" | "object" | "array";
+
+export interface FieldSchema {
+  type: FieldType;
+  required?: boolean;        // default false — missing = NULL not error
+  default?: any;             // fallback if missing (overrides NULL)
+}
+
+export interface StoreSchema {
+  name: string;              // store identifier (matches site name or custom)
+  destination: string;       // "./data.json" or "./data.db"
+  fields: Record<string, FieldSchema>;
+}
+
+export interface PiggyStoreConfig {
+  stores: StoreSchema[];
+}
+
+// ── Load piggy.store.json ─────────────────────────────────────────────────────
+
+let _config: PiggyStoreConfig | null = null;
+
+export function loadStoreConfig(configPath = "./piggy.store.json"): PiggyStoreConfig {
+  if (_config) return _config;
+
+  const abs = resolve(configPath);
+  if (!existsSync(abs)) {
+    logger.warn(`[store] piggy.store.json not found at ${abs} — store() calls will no-op`);
+    return { stores: [] };
+  }
+
+  try {
+    _config = JSON.parse(readFileSync(abs, "utf8")) as PiggyStoreConfig;
+    logger.success(`[store] loaded ${_config.stores.length} schema(s) from ${abs}`);
+    return _config;
+  } catch (e: any) {
+    logger.error(`[store] failed to parse piggy.store.json: ${e.message}`);
+    return { stores: [] };
+  }
+}
+
+export function getSchema(storeName: string): StoreSchema | null {
+  const config = loadStoreConfig();
+  return config.stores.find(s => s.name === storeName) ?? null;
+}
+
+// ── Validate & shape one record against schema ────────────────────────────────
+
+export function shapeRecord(data: Record<string, any>, schema: StoreSchema): Record<string, any> {
+  const shaped: Record<string, any> = {};
+
+  for (const [field, def] of Object.entries(schema.fields)) {
+    const raw = data[field];
+
+    // Missing field
+    if (raw === undefined || raw === null) {
+      if (def.default !== undefined) {
+        shaped[field] = def.default;
+      } else {
+        shaped[field] = null;  // NULL — not an error, just absent
+      }
+      continue;
+    }
+
+    // Type coercion / validation
+    switch (def.type) {
+      case "string":
+        shaped[field] = String(raw);
+        break;
+      case "number":
+        const n = Number(raw);
+        shaped[field] = isNaN(n) ? null : n;
+        break;
+      case "boolean":
+        shaped[field] = Boolean(raw);
+        break;
+      case "object":
+        shaped[field] = typeof raw === "object" && !Array.isArray(raw) ? raw : null;
+        break;
+      case "array":
+        shaped[field] = Array.isArray(raw) ? raw : null;
+        break;
+      default:
+        shaped[field] = raw;
+    }
+  }
+
+  // Extra fields on incoming data are silently dropped — not in schema = ignored
+  return shaped;
+}
+
+// ── JSON backend ──────────────────────────────────────────────────────────────
+
+function appendToJson(destination: string, record: Record<string, any>): void {
+  const abs = resolve(destination);
+  mkdirSync(dirname(abs), { recursive: true });
+
+  let existing: any[] = [];
+  if (existsSync(abs)) {
+    try {
+      existing = JSON.parse(readFileSync(abs, "utf8"));
+      if (!Array.isArray(existing)) existing = [existing];
+    } catch {
+      existing = [];
+    }
+  }
+
+  existing.push({ ...record, _storedAt: new Date().toISOString() });
+  writeFileSync(abs, JSON.stringify(existing, null, 2), "utf8");
+}
+
+// ── SQLite backend ────────────────────────────────────────────────────────────
+
+function appendToSqlite(destination: string, record: Record<string, any>, schema: StoreSchema): void {
+  // Use bun:sqlite if available, else require better-sqlite3
+  const abs = resolve(destination);
+  mkdirSync(dirname(abs), { recursive: true });
+
+  const isBun = typeof (globalThis as any).Bun !== "undefined";
+
+  if (isBun) {
+    const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+    const db = new Database(abs);
+    ensureTable(db, schema, "bun");
+    insertRecord(db, schema, record, "bun");
+    db.close();
+  } else {
+    const Database = require("better-sqlite3");
+    const db = new Database(abs);
+    ensureTable(db, schema, "node");
+    insertRecord(db, schema, record, "node");
+    db.close();
+  }
+}
+
+function ensureTable(db: any, schema: StoreSchema, runtime: "bun" | "node"): void {
+  const tableName = schema.name.replace(/[^a-zA-Z0-9_]/g, "_");
+  const cols = Object.entries(schema.fields).map(([name, def]) => {
+    const sqlType = def.type === "number" ? "REAL"
+      : def.type === "boolean" ? "INTEGER"
+      : def.type === "object" || def.type === "array" ? "TEXT"  // JSON stringified
+      : "TEXT";
+    return `  ${name} ${sqlType}`;
+  });
+  cols.push("  _storedAt TEXT");
+
+  const sql = `CREATE TABLE IF NOT EXISTS ${tableName} (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n${cols.join(",\n")}\n)`;
+
+  if (runtime === "bun") {
+    db.run(sql);
+  } else {
+    db.prepare(sql).run();
+  }
+}
+
+function insertRecord(db: any, schema: StoreSchema, record: Record<string, any>, runtime: "bun" | "node"): void {
+  const tableName = schema.name.replace(/[^a-zA-Z0-9_]/g, "_");
+  const fields = [...Object.keys(schema.fields), "_storedAt"];
+  const values = fields.map(f => {
+    if (f === "_storedAt") return new Date().toISOString();
+    const v = record[f];
+    // Serialize objects/arrays as JSON strings for SQLite
+    if (v !== null && (typeof v === "object" || Array.isArray(v))) return JSON.stringify(v);
+    return v ?? null;
+  });
+
+  const placeholders = runtime === "bun"
+    ? fields.map((_, i) => `?${i + 1}`).join(", ")
+    : fields.map(() => "?").join(", ");
+
+  const sql = `INSERT INTO ${tableName} (${fields.join(", ")}) VALUES (${placeholders})`;
+
+  if (runtime === "bun") {
+    db.run(sql, values);
+  } else {
+    db.prepare(sql).run(values);
+  }
+}
+
+// ── Main store function ───────────────────────────────────────────────────────
+
+export async function storeRecord(
+  storeName: string,
+  data: Record<string, any> | Record<string, any>[]
+): Promise<{ stored: number; skipped: number }> {
+  const schema = getSchema(storeName);
+
+  if (!schema) {
+    logger.warn(`[store] no schema found for "${storeName}" in piggy.store.json — data not stored`);
+    return { stored: 0, skipped: 1 };
+  }
+
+  const records = Array.isArray(data) ? data : [data];
+  let stored = 0;
+  let skipped = 0;
+
+  const isJson = schema.destination.endsWith(".json");
+  const isSqlite = schema.destination.endsWith(".db") || schema.destination.endsWith(".sqlite");
+
+  for (const record of records) {
+    try {
+      const shaped = shapeRecord(record, schema);
+
+      if (isJson) {
+        appendToJson(schema.destination, shaped);
+      } else if (isSqlite) {
+        appendToSqlite(schema.destination, shaped, schema);
+      } else {
+        logger.error(`[store] unsupported destination format: ${schema.destination} (use .json or .db)`);
+        skipped++;
+        continue;
+      }
+
+      stored++;
+      logger.success(`[store][${storeName}] stored record → ${schema.destination}`);
+    } catch (e: any) {
+      logger.error(`[store][${storeName}] failed to store record: ${e.message}`);
+      skipped++;
+    }
+  }
+
+  return { stored, skipped };
+}