@squadbase/vite-server 0.0.1-build-1

package/dist/index.js

@@ -0,0 +1,743 @@
+// src/index.ts
+import { Hono as Hono5 } from "hono";
+import { cors } from "hono/cors";
+import path4 from "path";
+
+// src/registry.ts
+import { readdir, readFile, mkdir } from "fs/promises";
+import { watch as fsWatch2 } from "fs";
+import path2 from "path";
+
+// src/connector-client/registry.ts
+import { readFileSync, watch as fsWatch } from "fs";
+import path from "path";
+
+// src/connector-client/postgresql.ts
+import pg from "pg";
+var { Pool } = pg;
+function createPostgreSQLClient(connectionString) {
+  const pool = new Pool({ connectionString, ssl: { rejectUnauthorized: false } });
+  return {
+    async query(sql, params) {
+      const result = await pool.query(sql, params);
+      return { rows: result.rows };
+    }
+  };
+}
+
+// src/connector-client/env.ts
+function resolveEnvVar(entry, key, slug) {
+  const envVarName = entry.envVars[key];
+  if (!envVarName) {
+    throw new Error(`Connector "${slug}" is missing envVars mapping for key "${key}"`);
+  }
+  const value = process.env[envVarName];
+  if (!value) {
+    throw new Error(`Environment variable "${envVarName}" (for "${slug}.${key}") is not set`);
+  }
+  return value;
+}
+
+// src/connector-client/bigquery.ts
+function createBigQueryClient(entry, slug) {
+  const projectId = resolveEnvVar(entry, "project-id", slug);
+  const serviceAccountJsonBase64 = resolveEnvVar(entry, "service-account-json-base64", slug);
+  const serviceAccountJson = Buffer.from(serviceAccountJsonBase64, "base64").toString("utf-8");
+  let gcpCredentials;
+  try {
+    gcpCredentials = JSON.parse(serviceAccountJson);
+  } catch {
+    throw new Error(
+      `BigQuery service account JSON (decoded from base64) is not valid JSON for slug "${slug}"`
+    );
+  }
+  return {
+    async query(sql) {
+      const { BigQuery } = await import("@google-cloud/bigquery");
+      const bq = new BigQuery({ projectId, credentials: gcpCredentials });
+      const [job] = await bq.createQueryJob({ query: sql });
+      const [allRows] = await job.getQueryResults({ timeoutMs: 3e4 });
+      return { rows: allRows };
+    }
+  };
+}
+
+// src/connector-client/snowflake.ts
+function createSnowflakeClient(entry, slug) {
+  const accountIdentifier = resolveEnvVar(entry, "account", slug);
+  const user = resolveEnvVar(entry, "user", slug);
+  const role = resolveEnvVar(entry, "role", slug);
+  const warehouse = resolveEnvVar(entry, "warehouse", slug);
+  const privateKeyBase64 = resolveEnvVar(entry, "private-key-base64", slug);
+  const privateKey = Buffer.from(privateKeyBase64, "base64").toString("utf-8");
+  return {
+    async query(sql) {
+      const snowflake = (await import("snowflake-sdk")).default;
+      snowflake.configure({ logLevel: "ERROR" });
+      const connection = snowflake.createConnection({
+        account: accountIdentifier,
+        username: user,
+        role,
+        warehouse,
+        authenticator: "SNOWFLAKE_JWT",
+        privateKey
+      });
+      await new Promise((resolve, reject) => {
+        connection.connect((err) => {
+          if (err) reject(new Error(`Snowflake connect failed: ${err.message}`));
+          else resolve();
+        });
+      });
+      const rows = await new Promise((resolve, reject) => {
+        connection.execute({
+          sqlText: sql,
+          complete: (err, _stmt, rows2) => {
+            if (err) reject(new Error(`Snowflake query failed: ${err.message}`));
+            else resolve(rows2 ?? []);
+          }
+        });
+      });
+      connection.destroy((err) => {
+        if (err) console.warn(`[connector-client] Snowflake destroy error: ${err.message}`);
+      });
+      return { rows };
+    }
+  };
+}
+
+// src/connector-client/registry.ts
+function createConnectorRegistry() {
+  let connectionsCache = null;
+  const clientCache = /* @__PURE__ */ new Map();
+  function getConnectionsFilePath() {
+    return process.env.CONNECTIONS_PATH ?? path.join(process.cwd(), "../../.squadbase/connections.json");
+  }
+  function loadConnections() {
+    if (connectionsCache !== null) return connectionsCache;
+    const filePath = getConnectionsFilePath();
+    try {
+      const raw = readFileSync(filePath, "utf-8");
+      connectionsCache = JSON.parse(raw);
+    } catch {
+      connectionsCache = {};
+    }
+    return connectionsCache;
+  }
+  async function getClient2(connectorSlug, connectorType) {
+    if (!connectorSlug) {
+      const cacheKey = "__squadbase-db__";
+      const cached2 = clientCache.get(cacheKey);
+      if (cached2) return cached2;
+      const url = process.env.SQUADBASE_POSTGRESQL_URL;
+      if (!url) throw new Error("SQUADBASE_POSTGRESQL_URL environment variable is not set");
+      const client = createPostgreSQLClient(url);
+      clientCache.set(cacheKey, client);
+      return client;
+    }
+    const cached = clientCache.get(connectorSlug);
+    if (cached) return cached;
+    const connections = loadConnections();
+    const entry = connections[connectorSlug];
+    if (!entry) {
+      throw new Error(`connector slug '${connectorSlug}' not found in .squadbase/connections.json`);
+    }
+    const resolvedType = connectorType ?? entry.connectorType;
+    if (!resolvedType) {
+      throw new Error(
+        `connector type could not be determined for slug '${connectorSlug}'. Specify connectorType in the data-source JSON or in .squadbase/connections.json.`
+      );
+    }
+    if (resolvedType === "snowflake") {
+      return createSnowflakeClient(entry, connectorSlug);
+    }
+    if (resolvedType === "bigquery") {
+      return createBigQueryClient(entry, connectorSlug);
+    }
+    if (resolvedType === "postgresql" || resolvedType === "squadbase-db") {
+      const urlEnvName = entry.envVars["connection-url"];
+      if (!urlEnvName) {
+        throw new Error(`'connection-url' is not defined in envVars for connector '${connectorSlug}'`);
+      }
+      const connectionUrl = process.env[urlEnvName];
+      if (!connectionUrl) {
+        throw new Error(
+          `environment variable '${urlEnvName}' (mapped from connector '${connectorSlug}') is not set`
+        );
+      }
+      const client = createPostgreSQLClient(connectionUrl);
+      clientCache.set(connectorSlug, client);
+      return client;
+    }
+    throw new Error(
+      `connector type '${resolvedType}' is not supported. Supported: "snowflake", "bigquery", "postgresql", "squadbase-db"`
+    );
+  }
+  function reloadEnvFile2(envPath) {
+    try {
+      const raw = readFileSync(envPath, "utf-8");
+      for (const line of raw.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const eqIdx = trimmed.indexOf("=");
+        if (eqIdx === -1) continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        const value = trimmed.slice(eqIdx + 1).trim();
+        if (key) process.env[key] = value;
+      }
+      console.log("[connector-client] .env reloaded");
+    } catch {
+    }
+  }
+  function watchConnectionsFile2() {
+    const filePath = getConnectionsFilePath();
+    const envPath = path.join(process.cwd(), "..", "..", ".env");
+    try {
+      fsWatch(filePath, { persistent: false }, () => {
+        console.log("[connector-client] connections.json changed, clearing cache");
+        connectionsCache = null;
+        clientCache.clear();
+        setImmediate(() => reloadEnvFile2(envPath));
+      });
+    } catch {
+    }
+  }
+  return { getClient: getClient2, reloadEnvFile: reloadEnvFile2, watchConnectionsFile: watchConnectionsFile2 };
+}
+
+// src/connector-client/index.ts
+var { getClient, reloadEnvFile, watchConnectionsFile } = createConnectorRegistry();
+
+// src/registry.ts
+var dataSources = /* @__PURE__ */ new Map();
+var viteServer = null;
+function validateHandlerPath(dirPath, handlerPath) {
+  const absolute = path2.resolve(dirPath, handlerPath);
+  const normalizedDir = path2.resolve(dirPath);
+  if (!absolute.startsWith(normalizedDir + path2.sep)) {
+    throw new Error(`Handler path escapes data-source directory: ${handlerPath}`);
+  }
+  if (!absolute.endsWith(".ts")) {
+    throw new Error(`Handler must be a .ts file: ${handlerPath}`);
+  }
+  return absolute;
+}
+async function loadTypeScriptHandler(absolutePath) {
+  let mod;
+  if (viteServer) {
+    const module = viteServer.moduleGraph.getModuleById(absolutePath);
+    if (module) viteServer.moduleGraph.invalidateModule(module);
+    mod = await viteServer.ssrLoadModule(absolutePath);
+  } else {
+    const { pathToFileURL } = await import("url");
+    mod = await import(pathToFileURL(absolutePath).href);
+  }
+  const handler = mod.default;
+  if (typeof handler !== "function") {
+    throw new Error(`Handler must export a default function: ${absolutePath}`);
+  }
+  return handler;
+}
+function buildQuery(queryTemplate, parameterMeta, runtimeParams) {
+  const defaults = new Map(
+    parameterMeta.map((p) => [p.name, p.default ?? null])
+  );
+  const placeholderToIndex = /* @__PURE__ */ new Map();
+  const values = [];
+  const text = queryTemplate.replace(
+    /\{\{(\w+)\}\}/g,
+    (_match, name) => {
+      if (!placeholderToIndex.has(name)) {
+        const value = Object.prototype.hasOwnProperty.call(runtimeParams, name) ? runtimeParams[name] : defaults.get(name) ?? null;
+        values.push(value);
+        placeholderToIndex.set(name, values.length);
+      }
+      return `$${placeholderToIndex.get(name)}`;
+    }
+  );
+  return { text, values };
+}
+var defaultDataSourceDir = path2.join(process.cwd(), "data-source");
+async function initialize() {
+  console.log(
+    `[registry] loading data sources from ${defaultDataSourceDir}...`
+  );
+  dataSources.clear();
+  const dirPath = process.env.DATA_SOURCE_DIR || defaultDataSourceDir;
+  await mkdir(dirPath, { recursive: true });
+  const files = await readdir(dirPath);
+  const jsonFiles = files.filter((f) => f.endsWith(".json"));
+  const results = await Promise.allSettled(
+    jsonFiles.map(async (file) => {
+      const slug = file.replace(/\.json$/, "");
+      const raw = await readFile(`${dirPath}/${file}`, "utf-8");
+      const def = JSON.parse(raw);
+      if (!def.description) {
+        console.warn(`[registry] Skipping ${file}: missing description`);
+        return;
+      }
+      if (def.type === "typescript") {
+        if (!def.handlerPath) {
+          console.warn(`[registry] Skipping ${file}: missing handlerPath`);
+          return;
+        }
+        const absoluteHandlerPath = validateHandlerPath(dirPath, def.handlerPath);
+        const dataSourceDef = {
+          description: def.description,
+          parameters: def.parameters ?? [],
+          response: def.response,
+          cacheConfig: def.cache,
+          handler: async () => {
+            throw new Error("TypeScript handler must be called via _tsHandlerPath");
+          },
+          _isTypescript: true,
+          _tsHandlerPath: absoluteHandlerPath
+        };
+        dataSources.set(slug, dataSourceDef);
+        console.log(`[registry] registered (typescript): ${slug}`);
+      } else {
+        const sqlDef = def;
+        if (!sqlDef.query) {
+          console.warn(`[registry] Skipping ${file}: missing query`);
+          return;
+        }
+        const dataSourceDef = {
+          description: sqlDef.description,
+          parameters: sqlDef.parameters ?? [],
+          response: sqlDef.response,
+          connectorSlug: sqlDef.connectorSlug,
+          cacheConfig: sqlDef.cache,
+          handler: async (runtimeParams) => {
+            const client = await getClient(sqlDef.connectorSlug, sqlDef.connectorType);
+            const isExternalConnector = sqlDef.connectorType === "snowflake" || sqlDef.connectorType === "bigquery";
+            let queryText;
+            let queryValues;
+            if (isExternalConnector) {
+              const defaults = new Map(
+                (sqlDef.parameters ?? []).map((p) => [p.name, p.default ?? null])
+              );
+              queryText = sqlDef.query.replace(
+                /\{\{(\w+)\}\}/g,
+                (_match, name) => {
+                  const value = Object.prototype.hasOwnProperty.call(
+                    runtimeParams,
+                    name
+                  ) ? runtimeParams[name] : defaults.get(name) ?? "";
+                  if (typeof value === "string")
+                    return `'${value.replace(/'/g, "''")}'`;
+                  if (value === null || value === void 0) return "NULL";
+                  return String(value);
+                }
+              );
+              queryValues = [];
+            } else {
+              const built = buildQuery(
+                sqlDef.query,
+                sqlDef.parameters ?? [],
+                runtimeParams
+              );
+              queryText = built.text;
+              queryValues = built.values;
+            }
+            const result = await client.query(queryText, queryValues);
+            return result.rows;
+          }
+        };
+        dataSources.set(slug, dataSourceDef);
+        console.log(`[registry] registered: ${slug}`);
+      }
+    })
+  );
+  results.forEach((result, i) => {
+    if (result.status === "rejected") {
+      console.error(
+        `[registry] Failed to load ${jsonFiles[i]}:`,
+        result.reason
+      );
+    }
+  });
+  console.log(`[registry] ${dataSources.size} data source(s) ready`);
+}
+var reloadTimer = null;
+function startWatching() {
+  const dirPath = process.env.DATA_SOURCE_DIR || defaultDataSourceDir;
+  try {
+    fsWatch2(dirPath, { persistent: false }, (_event, filename) => {
+      if (!filename?.endsWith(".json") && !filename?.endsWith(".ts")) return;
+      if (reloadTimer) clearTimeout(reloadTimer);
+      reloadTimer = setTimeout(async () => {
+        console.log("[registry] data-source changed, reloading...");
+        await initialize();
+      }, 300);
+    });
+    console.log("[registry] watching data-source directory");
+  } catch {
+    console.warn(
+      "[registry] could not watch data-source directory (static load only)"
+    );
+  }
+}
+function getDataSource(slug) {
+  return dataSources.get(slug);
+}
+function getAllMeta() {
+  return Array.from(dataSources.entries()).map(([slug, def]) => ({
+    slug,
+    description: def.description,
+    parameters: def.parameters,
+    response: def.response,
+    connectorSlug: def.connectorSlug
+  }));
+}
+function getMeta(slug) {
+  const def = dataSources.get(slug);
+  if (!def) return void 0;
+  return {
+    slug,
+    description: def.description,
+    parameters: def.parameters,
+    response: def.response,
+    connectorSlug: def.connectorSlug
+  };
+}
+
+// src/routes/data-source.ts
+import { Hono } from "hono";
+
+// src/cache.ts
+var MAX_SIZE = 100;
+var cache = /* @__PURE__ */ new Map();
+var totalHits = 0;
+var totalMisses = 0;
+function cacheGet(key) {
+  const entry = cache.get(key);
+  if (!entry) {
+    totalMisses++;
+    return void 0;
+  }
+  cache.delete(key);
+  cache.set(key, entry);
+  return entry;
+}
+function isFresh(entry) {
+  if (entry.ttl <= 0) return false;
+  const ageMs = Date.now() - entry.cachedAt;
+  return ageMs < entry.ttl * 1e3;
+}
+function cacheSet(key, data, ttl) {
+  if (ttl <= 0) return;
+  if (cache.has(key)) {
+    cache.delete(key);
+  } else if (cache.size >= MAX_SIZE) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey !== void 0) {
+      cache.delete(oldestKey);
+      console.log(`[cache] evicted: ${oldestKey}`);
+    }
+  }
+  cache.set(key, {
+    data,
+    cachedAt: Date.now(),
+    ttl,
+    hits: 0
+  });
+}
+function recordHit(key) {
+  totalHits++;
+  const entry = cache.get(key);
+  if (entry) {
+    entry.hits++;
+  }
+}
+function invalidateSlug(slug) {
+  const prefix = `${slug}:`;
+  let count = 0;
+  for (const key of cache.keys()) {
+    if (key.startsWith(prefix)) {
+      cache.delete(key);
+      count++;
+    }
+  }
+  console.log(`[cache] invalidated ${count} entries for slug: ${slug}`);
+  return count;
+}
+function invalidateAll() {
+  const count = cache.size;
+  cache.clear();
+  totalHits = 0;
+  totalMisses = 0;
+  console.log(`[cache] invalidated all ${count} entries`);
+  return count;
+}
+function getStats() {
+  const now = Date.now();
+  const entries = Array.from(cache.entries()).map(([key, entry]) => ({
+    key,
+    cachedAt: entry.cachedAt,
+    ttl: entry.ttl,
+    ageSeconds: Math.floor((now - entry.cachedAt) / 1e3),
+    hits: entry.hits,
+    expired: !isFresh(entry)
+  }));
+  return {
+    size: cache.size,
+    maxSize: MAX_SIZE,
+    totalHits,
+    totalMisses,
+    entries
+  };
+}
+function buildCacheKey(slug, params) {
+  const sortedParams = Object.fromEntries(
+    Object.entries(params).sort(([a], [b]) => a.localeCompare(b))
+  );
+  return `${slug}:${JSON.stringify(sortedParams)}`;
+}
+
+// src/lib/csv.ts
+function convertRowsToCsv(rows) {
+  if (rows.length === 0) return "";
+  const headers = Object.keys(rows[0]);
+  const escape = (v) => {
+    const s = v === null || v === void 0 ? "" : String(v);
+    return s.includes(",") || s.includes('"') || s.includes("\n") ? `"${s.replace(/"/g, '""')}"` : s;
+  };
+  return [
+    headers.join(","),
+    ...rows.map((r) => headers.map((h) => escape(r[h])).join(","))
+  ].join("\n");
+}
+
+// src/routes/data-source.ts
+var app = new Hono();
+function buildResponse(c, result, response) {
+  const contentType = response?.defaultContentType ?? "application/json";
+  if (contentType === "text/csv") {
+    const csv = convertRowsToCsv(result);
+    return c.text(csv, 200, { "Content-Type": "text/csv; charset=utf-8" });
+  }
+  const schema = response?.content?.["application/json"]?.schema;
+  if (schema?.type === "object" && schema.properties) {
+    return c.json(result);
+  }
+  return c.json({ data: result });
+}
+app.get("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  const ds = getDataSource(slug);
+  if (!ds) {
+    return c.json({ error: `Data source '${slug}' not found` }, 404);
+  }
+  try {
+    let result;
+    if (ds._isTypescript && ds._tsHandlerPath) {
+      const handler = await loadTypeScriptHandler(ds._tsHandlerPath);
+      result = await handler(c);
+    } else {
+      result = await ds.handler({});
+    }
+    return buildResponse(c, result, ds.response);
+  } catch (e) {
+    console.error(`[data-source] ${slug} error:`, e);
+    return c.json(
+      { error: e instanceof Error ? e.message : "Internal error" },
+      500
+    );
+  }
+});
+app.post("/:slug", async (c) => {
+  const slug = c.req.param("slug");
+  const ds = getDataSource(slug);
+  if (!ds) {
+    return c.json({ error: `Data source '${slug}' not found` }, 404);
+  }
+  try {
+    const body = await c.req.json().catch(() => ({}));
+    const params = body.params ?? {};
+    const cacheConfig = ds.cacheConfig;
+    const ttl = cacheConfig?.ttl ?? 0;
+    if (ttl <= 0) {
+      let result2;
+      if (ds._isTypescript && ds._tsHandlerPath) {
+        const handler = await loadTypeScriptHandler(ds._tsHandlerPath);
+        result2 = await handler(c);
+      } else {
+        result2 = await ds.handler(params);
+      }
+      return buildResponse(c, result2, ds.response);
+    }
+    const cacheKey = buildCacheKey(slug, params);
+    const cached = cacheGet(cacheKey);
+    if (cached) {
+      if (isFresh(cached)) {
+        recordHit(cacheKey);
+        const ageSeconds = Math.floor((Date.now() - cached.cachedAt) / 1e3);
+        c.header("X-Cache", "HIT");
+        c.header("X-Cache-Age", String(ageSeconds));
+        c.header("Cache-Control", `max-age=${ttl - ageSeconds}`);
+        return buildResponse(c, cached.data, ds.response);
+      }
+      if (cacheConfig?.staleWhileRevalidate) {
+        recordHit(cacheKey);
+        const ageSeconds = Math.floor((Date.now() - cached.cachedAt) / 1e3);
+        c.header("X-Cache", "STALE");
+        c.header("X-Cache-Age", String(ageSeconds));
+        c.header("Cache-Control", `max-age=0, stale-while-revalidate=${ttl}`);
+        void (async () => {
+          try {
+            let freshData;
+            if (ds._isTypescript && ds._tsHandlerPath) {
+              const tsHandler = await loadTypeScriptHandler(ds._tsHandlerPath);
+              freshData = await tsHandler(c);
+            } else {
+              freshData = await ds.handler(params);
+            }
+            cacheSet(cacheKey, freshData, ttl);
+            console.log(`[cache] background revalidated: ${cacheKey}`);
+          } catch (e) {
+            console.error(`[cache] background revalidation failed for ${slug}:`, e);
+          }
+        })();
+        return buildResponse(c, cached.data, ds.response);
+      }
+    }
+    let result;
+    if (ds._isTypescript && ds._tsHandlerPath) {
+      const handler = await loadTypeScriptHandler(ds._tsHandlerPath);
+      result = await handler(c);
+    } else {
+      result = await ds.handler(params);
+    }
+    cacheSet(cacheKey, result, ttl);
+    c.header("X-Cache", "MISS");
+    c.header("X-Cache-Age", "0");
+    c.header("Cache-Control", `max-age=${ttl}`);
+    return buildResponse(c, result, ds.response);
+  } catch (e) {
+    console.error(`[data-source] ${slug} error:`, e);
+    return c.json(
+      { error: e instanceof Error ? e.message : "Internal error" },
+      500
+    );
+  }
+});
+var data_source_default = app;
+
+// src/routes/data-source-meta.ts
+import { Hono as Hono2 } from "hono";
+var app2 = new Hono2();
+app2.get("/", (c) => {
+  return c.json(getAllMeta());
+});
+app2.get("/:slug", (c) => {
+  const slug = c.req.param("slug");
+  const meta = getMeta(slug);
+  if (!meta) {
+    return c.json({ error: `Data source '${slug}' not found` }, 404);
+  }
+  return c.json(meta);
+});
+var data_source_meta_default = app2;
+
+// src/routes/cache.ts
+import { Hono as Hono3 } from "hono";
+var app3 = new Hono3();
+app3.get("/stats", (c) => {
+  const stats = getStats();
+  const total = stats.totalHits + stats.totalMisses;
+  const hitRate = total > 0 ? `${(stats.totalHits / total * 100).toFixed(2)}%` : "N/A";
+  return c.json({ ...stats, hitRate });
+});
+app3.post("/invalidate", (c) => {
+  const count = invalidateAll();
+  return c.json({ invalidated: count, message: "All cache entries cleared" });
+});
+app3.post("/invalidate/:slug", (c) => {
+  const slug = c.req.param("slug");
+  const count = invalidateSlug(slug);
+  return c.json({ slug, invalidated: count });
+});
+var cache_default = app3;
+
+// src/routes/pages.ts
+import { Hono as Hono4 } from "hono";
+import path3 from "path";
+import fs from "fs";
+var DATA_DIR = process.env.DATA_DIR ?? path3.join(process.cwd(), "data");
+var app4 = new Hono4();
+function getPageList() {
+  if (!fs.existsSync(DATA_DIR)) return [];
+  const files = fs.readdirSync(DATA_DIR).filter((f) => f.endsWith(".json"));
+  const pages = files.map((file) => {
+    const name = path3.basename(file, ".json");
+    const urlPath = name === "home" ? "/" : "/" + name.replace(/-/g, "/");
+    let title = name.charAt(0).toUpperCase() + name.slice(1).replace(/-/g, " ");
+    try {
+      const raw = JSON.parse(
+        fs.readFileSync(path3.join(DATA_DIR, file), "utf-8")
+      );
+      const puckData = raw.pageData || raw;
+      if (puckData?.root?.props?.title) {
+        title = puckData.root.props.title;
+      }
+    } catch {
+    }
+    return { name, path: urlPath, title };
+  });
+  pages.sort((a, b) => {
+    if (a.name === "home") return -1;
+    if (b.name === "home") return 1;
+    return a.name.localeCompare(b.name);
+  });
+  return pages;
+}
+app4.get("/pages", (c) => c.json(getPageList()));
+app4.get("/page-data", (c) => {
+  const page = c.req.query("page") || "home";
+  const safePage = page.replace(/[^a-zA-Z0-9-_]/g, "");
+  const filePath = path3.join(DATA_DIR, `${safePage}.json`);
+  if (!fs.existsSync(filePath)) return c.json({ error: "not found" }, 404);
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (raw.pageData) {
+      return c.json({
+        runtimeData: raw.runtimeData || { queries: [] },
+        pageData: raw.pageData
+      });
+    }
+    return c.json({ runtimeData: { queries: [] }, pageData: raw });
+  } catch {
+    return c.json({ error: "Failed to parse file" }, 500);
+  }
+});
+app4.get("/runtime-data", (c) => {
+  const page = c.req.query("page") || "home";
+  const safePage = page.replace(/[^a-zA-Z0-9-_]/g, "");
+  const filePath = path3.join(DATA_DIR, `${safePage}.json`);
+  if (!fs.existsSync(filePath)) return c.json({ queries: [] });
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    return c.json(raw.runtimeData || { queries: [] });
+  } catch {
+    return c.json({ queries: [] });
+  }
+});
+var pages_default = app4;
+
+// src/index.ts
+var apiApp = new Hono5();
+apiApp.use("/*", cors());
+apiApp.route("/data-source", data_source_default);
+apiApp.route("/data-source-meta", data_source_meta_default);
+apiApp.route("/cache", cache_default);
+apiApp.route("/", pages_default);
+reloadEnvFile(path4.join(process.cwd(), "..", "..", ".env"));
+await initialize();
+startWatching();
+watchConnectionsFile();
+var app5 = new Hono5();
+app5.get("/healthz", (c) => c.json({ status: "ok" }));
+app5.route("/api", apiApp);
+var src_default = app5;
+export {
+  src_default as default
+};