@grapity/grapity 0.2.0 → 0.3.0

package/dist/cli/index.js

@@ -21,7 +21,8 @@ import yaml from "js-yaml";
 var DEFAULT_CONFIG = {
   mode: "local",
   local: {
-    port: 3750
+    port: 3750,
+    database: "sqlite"
   }
 };
 function getConfig() {
@@ -40,12 +41,18 @@ function getConfig() {
     return DEFAULT_CONFIG;
   }
   const config = parsed;
+  let database = config.local?.database ?? DEFAULT_CONFIG.local.database;
+  if (!config.local?.database && config.local?.sqlitePath) {
+    database = "sqlite";
+  }
   return {
     mode: config.mode ?? DEFAULT_CONFIG.mode,
     remote: config.remote,
     local: {
       port: config.local?.port ?? DEFAULT_CONFIG.local.port,
-      sqlitePath: config.local?.sqlitePath
+      database,
+      sqlitePath: config.local?.sqlitePath,
+      postgresUrl: config.local?.postgresUrl
     }
   };
 }
@@ -56,6 +63,9 @@ function getRegistryUrl() {
   }
   return `http://localhost:${config.local?.port ?? 3750}`;
 }
+function isPostgresqlUrl(value) {
+  return value.startsWith("postgresql://") || value.startsWith("postgres://");
+}
 
 // src/cli/client.ts
 var BreakingChangeError = class extends Error {
@@ -69,16 +79,11 @@ var BreakingChangeError = class extends Error {
 async function request(method, path12, body) {
   const baseUrl = getRegistryUrl();
   const url = `${baseUrl}${path12}`;
-  const config = getConfig();
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  if (config.mode === "remote" && config.remote?.apiKey) {
-    headers["X-API-Key"] = config.remote.apiKey;
-  }
   const response = await fetch(url, {
     method,
-    headers,
+    headers: {
+      "Content-Type": "application/json"
+    },
     body: body ? JSON.stringify(body) : void 0
   });
   if (!response.ok) {
@@ -88,18 +93,13 @@ async function request(method, path12, body) {
     }
     throw new Error(error.message ?? `Request failed: ${response.status}`);
   }
-  const text2 = await response.text();
-  return text2 ? JSON.parse(text2) : void 0;
+  const text3 = await response.text();
+  return text3 ? JSON.parse(text3) : void 0;
 }
 async function requestText(method, path12) {
   const baseUrl = getRegistryUrl();
   const url = `${baseUrl}${path12}`;
-  const config = getConfig();
-  const headers = {};
-  if (config.mode === "remote" && config.remote?.apiKey) {
-    headers["X-API-Key"] = config.remote.apiKey;
-  }
-  const response = await fetch(url, { method, headers });
+  const response = await fetch(url, { method });
   if (!response.ok) {
     const error = await response.json();
     throw new Error(error.message ?? `Request failed: ${response.status}`);
@@ -150,9 +150,9 @@ var client = {
   fetchSpec: async (name, options) => {
     const format = options.format ?? "yaml";
     const path12 = options.semver ? `/v1/specs/${name}/versions/${options.semver}/spec.${format}` : `/v1/specs/${name}/spec.${format}`;
-    const { text: text2, headers } = await requestText("GET", path12);
+    const { text: text3, headers } = await requestText("GET", path12);
     return {
-      content: text2,
+      content: text3,
       resolvedVersion: headers.get("Grapity-Resolved-Version") ?? void 0
     };
   },
@@ -531,27 +531,43 @@ function formatInitSuccess(params) {
   ];
   if (params.mode === "local") {
     if (params.port) lines.push(`  ${c.label("Port")}  ${c.cyan(String(params.port))}`);
-    if (params.dbPath) lines.push(`  ${c.label("Database")}  ${c.dim(params.dbPath)}`);
+    if (params.database) lines.push(`  ${c.label("Database")}  ${c.primary(params.database)}`);
+    if (params.dbPath) lines.push(`  ${c.label("Path")}  ${c.dim(params.dbPath)}`);
+    if (params.postgresUrl) lines.push(`  ${c.label("PostgreSQL")}  ${c.dim(params.postgresUrl)}`);
     lines.push("");
     lines.push(`  ${c.dim("\u203A")} Start the server with:  ${c.primary("grapity serve")}`);
   } else {
     if (params.url) lines.push(`  ${c.label("URL")}  ${c.cyan(params.url)}`);
-    if (params.hasApiKey) lines.push(`  ${c.label("API key")}  ${c.dim("configured")}`);
     lines.push("");
     lines.push(`  ${c.dim("\u203A")} Push a spec with:  ${c.primary("grapity registry push ./openapi.yaml --name my-api")}`);
   }
   return lines.join("\n");
 }
 function formatServeConfig(params) {
-  const modeLabel = `local ${c.label("\xB7")} ${params.mode}`;
   const lines = [
-    `  ${c.label("Mode")}      ${c.primary(modeLabel)}`,
-    `  ${c.label("Port")}      ${c.cyan(String(params.port))}`
+    `  ${c.label("Mode")}      ${c.primary("local")}`,
+    `  ${c.label("Port")}      ${c.cyan(String(params.port))}`,
+    `  ${c.label("Database")}  ${c.primary(params.database)}`
   ];
-  if (params.dbPath) lines.push(`  ${c.label("Database")}  ${c.dim(params.dbPath)}`);
-  lines.push(`  ${c.label("Auth")}      ${c.primary(params.auth)}`);
+  if (params.database === "sqlite" && params.dbPath) {
+    lines.push(`  ${c.label("Path")}      ${c.dim(params.dbPath)}`);
+  }
+  if (params.database === "postgresql" && params.postgresUrl) {
+    lines.push(`  ${c.label("PostgreSQL")}  ${c.dim(maskPostgresUrl(params.postgresUrl))}`);
+  }
   return lines.join("\n");
 }
+function maskPostgresUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.password) {
+      parsed.password = "***";
+    }
+    return parsed.toString();
+  } catch {
+    return url;
+  }
+}
 function formatHubConfig(params) {
   const lines = [
     `  ${c.label("Port")}      ${c.cyan(String(params.port))}`,
@@ -744,18 +760,18 @@ var validateCommand = new Command2("validate").description("Validate a spec agai
 import { Command as Command3 } from "commander";
 var listCommand = new Command3("list").description("List all specs in the registry").option("--type <type>", "Filter by spec type").option("--owner <owner>", "Filter by owner").option("--tags <tags>", "Filter by tags (comma-separated)").action(async (options) => {
   try {
-    const specs2 = await client.listSpecs({
+    const specs3 = await client.listSpecs({
       type: options.type,
       owner: options.owner,
       tags: options.tags?.split(",")
     });
-    if (specs2.length === 0) {
+    if (specs3.length === 0) {
       console.log(formatEmptyState("No specs in the registry.", [
         "Push one with:  grapity registry push ./openapi.yaml --name my-api"
       ]));
       return;
     }
-    for (const spec of specs2) {
+    for (const spec of specs3) {
       console.log(formatSpec(spec));
     }
   } catch (err) {
@@ -1145,10 +1161,10 @@ function convertPathToKong(path12) {
   }
   return converted;
 }
-function routeName(serviceName, index2, path12, methods) {
+function routeName(serviceName, index3, path12, methods) {
   const cleanPath = path12.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
   const methodList = methods.join("-").toLowerCase();
-  return `${serviceName}-${cleanPath}-${methodList}-${index2}`;
+  return `${serviceName}-${cleanPath}-${methodList}-${index3}`;
 }
 function generateDeckYaml(config, envName) {
   const env = config.environments[envName];
@@ -1380,7 +1396,7 @@ import fs8 from "fs";
 import os3 from "os";
 import path8 from "path";
 import yaml4 from "js-yaml";
-var initCommand = new Command18("init").description("Configure grapity registry (local or remote mode)").option("--local", "Use local mode (SQLite)").option("--remote", "Use remote mode (connect to a grapity server)").option("--url <url>", "Registry URL (for remote mode)").option("--api-key <key>", "API key (for remote mode)").option("--port <port>", "Port for local server (default: 3750)").option("--db <path>", "Path to SQLite database file (for local mode)").action(async (options) => {
+var initCommand = new Command18("init").description("Configure grapity registry (local or remote mode)").option("--local", "Use local mode (SQLite or PostgreSQL)").option("--remote", "Use remote mode (connect to a grapity server)").option("--url <url>", "Registry URL (for remote mode)").option("--port <port>", "Port for local server (default: 3750)").option("--db <path-or-url>", "SQLite path or postgresql:// URL (for local mode)").action(async (options) => {
   const configDir = path8.join(os3.homedir(), ".grapity");
   const configPath = path8.join(configDir, "config.yaml");
   let mode;
@@ -1398,7 +1414,7 @@ var initCommand = new Command18("init").description("Configure grapity registry
         "missing flag",
         "Select registry mode: use --local or --remote.",
         [
-          "--local   Run a registry server on this machine (SQLite)",
+          "--local   Run a registry server on this machine",
           "--remote  Connect to an existing grapity server"
         ]
       )
@@ -1407,12 +1423,16 @@ var initCommand = new Command18("init").description("Configure grapity registry
   }
   const config = { mode };
   if (mode === "local") {
+    const dbValue = options.db ?? process.env.GRAPITY_DATABASE_URL;
+    const database = dbValue && isPostgresqlUrl(dbValue) ? "postgresql" : "sqlite";
     config.local = {
       port: options.port ? parseInt(options.port, 10) : 3750,
-      sqlitePath: options.db
+      database
     };
-    if (!config.local.sqlitePath) {
-      config.local.sqlitePath = path8.join(os3.homedir(), ".grapity", "registry.db");
+    if (database === "postgresql") {
+      config.local.postgresUrl = dbValue;
+    } else {
+      config.local.sqlitePath = dbValue ?? path8.join(os3.homedir(), ".grapity", "registry.db");
     }
   } else {
     if (!options.url) {
@@ -1426,8 +1446,7 @@ var initCommand = new Command18("init").description("Configure grapity registry
       process.exit(1);
     }
     config.remote = {
-      url: options.url.replace(/\/$/, ""),
-      apiKey: options.apiKey
+      url: options.url.replace(/\/$/, "")
     };
   }
   if (!fs8.existsSync(configDir)) {
@@ -1440,9 +1459,10 @@ var initCommand = new Command18("init").description("Configure grapity registry
       configPath,
       mode,
       port: config.local?.port,
+      database: config.local?.database,
       dbPath: config.local?.sqlitePath,
-      url: config.remote?.url,
-      hasApiKey: !!config.remote?.apiKey
+      postgresUrl: config.local?.postgresUrl,
+      url: config.remote?.url
     })
   );
 });
@@ -3090,9 +3110,9 @@ var RegistryService = class {
     return { spec, version: version2, compatReport, isNewSpec };
   }
   async listSpecs(filters) {
-    const specs2 = await this.store.listSpecs(filters);
+    const specs3 = await this.store.listSpecs(filters);
     return Promise.all(
-      specs2.map(async (spec) => {
+      specs3.map(async (spec) => {
         const latestVersion = await this.store.getLatestVersion(spec.name);
         return { ...spec, latestVersion: latestVersion ?? void 0 };
       })
@@ -3350,8 +3370,8 @@ var listRoute = new Hono3().get("/", async (c2) => {
   const type = c2.req.query("type");
   const owner = c2.req.query("owner");
   const tags = c2.req.query("tags")?.split(",");
-  const specs2 = await service.listSpecs({ type, owner, tags });
-  return c2.json({ data: specs2 });
+  const specs3 = await service.listSpecs({ type, owner, tags });
+  return c2.json({ data: specs3 });
 });
 
 // src/registry/routes/get-spec.ts
@@ -3985,8 +4005,7 @@ function switchTab(tab) {
 }
 var welcomeRoute = new Hono12().get("/", (c2) => {
   const config = c2.get("config");
-  const mode = config.database === "sqlite" ? "local" : "remote";
-  return c2.html(buildPage(config.port, mode));
+  return c2.html(buildPage(config.port, "local"));
 });
 
 // src/registry/routes/push-gateway-config.ts
@@ -4327,7 +4346,6 @@ var ingestGatewayLogRoute = new Hono18().post("/ingest/:provider/:environment",
     await service.ingestLog(provider, environment, payload);
     return c2.json({ status: "ok" }, 201);
   } catch (err) {
-    console.error("Gateway log ingest error:", err);
     return c2.json({
       error: "bad_request",
       message: err instanceof Error ? err.message : "Invalid log payload",
@@ -4440,9 +4458,7 @@ function createApp(config, store) {
 // src/registry/config.ts
 var defaultConfig = {
   port: 3750,
-  database: "sqlite",
-  sqlitePath: void 0,
-  gracePeriodDays: 30
+  database: "sqlite"
 };
 
 // src/registry/storage/sqlite.ts
@@ -4948,27 +4964,529 @@ var SQLiteSpecStore = class {
   }
 };
 
+// src/registry/storage/postgresql.ts
+import { Pool } from "pg";
+import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
+import { migrate as migrate2 } from "drizzle-orm/node-postgres/migrator";
+import { eq as eq2, and as and2, desc as desc2, sql as sql2 } from "drizzle-orm";
+
+// src/registry/storage/schema-pg.ts
+import { pgTable, text as text2, timestamp, boolean, jsonb, index as index2, integer as integer2 } from "drizzle-orm/pg-core";
+var specs2 = pgTable("specs", {
+  id: text2("id").primaryKey(),
+  name: text2("name").notNull().unique(),
+  type: text2("type", { enum: ["openapi", "asyncapi"] }).notNull(),
+  description: text2("description"),
+  owner: text2("owner"),
+  sourceRepo: text2("source_repo"),
+  tags: jsonb("tags").$type().default([]),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull()
+});
+var specVersions2 = pgTable("spec_versions", {
+  id: text2("id").primaryKey(),
+  specId: text2("spec_id").notNull().references(() => specs2.id),
+  semver: text2("semver").notNull(),
+  content: text2("content").notNull(),
+  checksum: text2("checksum").notNull(),
+  gitRef: text2("git_ref"),
+  pushedBy: text2("pushed_by"),
+  compatibility: jsonb("compatibility").$type(),
+  previousVersion: text2("previous_version"),
+  forceReason: text2("force_reason"),
+  isPrerelease: boolean("is_prerelease").notNull().default(false),
+  createdAt: timestamp("created_at").notNull()
+}, (table) => [
+  index2("idx_spec_versions_spec_id").on(table.specId),
+  index2("idx_spec_versions_semver").on(table.specId, table.semver)
+]);
+var auditLog2 = pgTable("audit_log", {
+  id: text2("id").primaryKey(),
+  action: text2("action", { enum: ["spec.push", "spec.push.force", "spec.delete"] }).notNull(),
+  actor: text2("actor").notNull(),
+  specName: text2("spec_name").notNull(),
+  version: text2("version"),
+  details: jsonb("details").$type(),
+  createdAt: timestamp("created_at").notNull()
+}, (table) => [
+  index2("idx_audit_log_spec_name").on(table.specName),
+  index2("idx_audit_log_created_at").on(table.createdAt)
+]);
+var gatewayConfigs2 = pgTable("gateway_configs", {
+  id: text2("id").primaryKey(),
+  name: text2("name").notNull().unique(),
+  provider: text2("provider", { enum: ["kong"] }).notNull(),
+  specName: text2("spec_name").notNull(),
+  specSemver: text2("spec_semver").notNull(),
+  createdAt: timestamp("created_at").notNull(),
+  updatedAt: timestamp("updated_at").notNull()
+});
+var gatewayConfigVersions2 = pgTable("gateway_config_versions", {
+  id: text2("id").primaryKey(),
+  gatewayConfigId: text2("gateway_config_id").notNull().references(() => gatewayConfigs2.id),
+  routes: jsonb("routes").$type().notNull(),
+  environments: jsonb("environments").$type().notNull(),
+  callerIdentification: jsonb("caller_identification").$type(),
+  content: text2("content").notNull(),
+  checksum: text2("checksum").notNull(),
+  pushedBy: text2("pushed_by"),
+  createdAt: timestamp("created_at").notNull()
+}, (table) => [
+  index2("idx_gateway_config_versions_config_id").on(table.gatewayConfigId)
+]);
+var httpLogs2 = pgTable("http_logs", {
+  id: text2("id").primaryKey(),
+  provider: text2("provider").notNull(),
+  gatewayConfigName: text2("gateway_config_name").notNull(),
+  environment: text2("environment").notNull(),
+  method: text2("method").notNull(),
+  path: text2("path").notNull(),
+  routePath: text2("route_path"),
+  status: integer2("status").notNull(),
+  callerId: text2("caller_id"),
+  callerSource: text2("caller_source"),
+  callerConfidence: text2("caller_confidence").notNull(),
+  occurredAt: timestamp("occurred_at").notNull(),
+  createdAt: timestamp("created_at").notNull()
+}, (table) => [
+  index2("idx_http_logs_config_env").on(table.gatewayConfigName, table.environment),
+  index2("idx_http_logs_occurred_at").on(table.occurredAt),
+  index2("idx_http_logs_caller").on(table.gatewayConfigName, table.environment, table.callerId)
+]);
+var provisions2 = pgTable("provisions", {
+  id: text2("id").primaryKey(),
+  gatewayConfigName: text2("gateway_config_name").notNull(),
+  gatewayConfigVersion: text2("gateway_config_version").notNull(),
+  environment: text2("environment").notNull(),
+  provider: text2("provider", { enum: ["kong"] }).notNull(),
+  synced: boolean("synced").notNull().default(false),
+  actor: text2("actor").notNull(),
+  details: jsonb("details").$type(),
+  createdAt: timestamp("created_at").notNull()
+}, (table) => [
+  index2("idx_provisions_config_name").on(table.gatewayConfigName),
+  index2("idx_provisions_created_at").on(table.createdAt)
+]);
+
+// src/registry/storage/postgresql.ts
+import { v4 as uuid6 } from "uuid";
+var MIGRATIONS_FOLDER2 = PG_MIGRATIONS_FOLDER;
+var PostgreSQLSpecStore = class {
+  db;
+  pool;
+  constructor(postgresUrl) {
+    this.pool = new Pool({ connectionString: postgresUrl });
+    this.db = drizzle2(this.pool);
+  }
+  async migrate() {
+    await migrate2(this.db, {
+      migrationsFolder: MIGRATIONS_FOLDER2
+    });
+  }
+  async end() {
+    await this.pool.end();
+  }
+  async getSpec(name) {
+    const rows = await this.db.select().from(specs2).where(eq2(specs2.name, name)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapSpecRow(rows[0]);
+  }
+  async getSpecVersion(name, semver) {
+    const spec = await this.getSpec(name);
+    if (!spec) return null;
+    const rows = await this.db.select().from(specVersions2).where(and2(eq2(specVersions2.specId, spec.id), eq2(specVersions2.semver, semver))).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapVersionRow(rows[0]);
+  }
+  async getLatestVersion(name) {
+    const spec = await this.getSpec(name);
+    if (!spec) return null;
+    const rows = await this.db.select().from(specVersions2).where(eq2(specVersions2.specId, spec.id)).orderBy(desc2(specVersions2.createdAt), desc2(specVersions2.id)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapVersionRow(rows[0]);
+  }
+  async listSpecs(filters) {
+    const conditions = [];
+    if (filters?.type) conditions.push(eq2(specs2.type, filters.type));
+    if (filters?.owner) conditions.push(eq2(specs2.owner, filters.owner));
+    let rows = conditions.length > 0 ? await this.db.select().from(specs2).where(and2(...conditions)) : await this.db.select().from(specs2);
+    if (filters?.tags && filters.tags.length > 0) {
+      rows = rows.filter((row) => {
+        const rowTags = row.tags ?? [];
+        return filters.tags.every((tag) => rowTags.includes(tag));
+      });
+    }
+    return rows.map((r) => this.mapSpecRow(r));
+  }
+  async listVersions(name, options) {
+    const spec = await this.getSpec(name);
+    if (!spec) return { versions: [], total: 0 };
+    const limit = options?.limit ?? 10;
+    const offset = options?.offset ?? 0;
+    const [countRow] = await this.db.select({ count: sql2`count(*)` }).from(specVersions2).where(eq2(specVersions2.specId, spec.id));
+    const total = Number(countRow?.count ?? 0);
+    const rows = await this.db.select().from(specVersions2).where(eq2(specVersions2.specId, spec.id)).orderBy(desc2(specVersions2.createdAt), desc2(specVersions2.id)).limit(limit).offset(offset);
+    return { versions: rows.map((r) => this.mapVersionRow(r)), total };
+  }
+  async pushSpecVersion(spec, version2) {
+    const existingSpec = await this.getSpec(spec.name);
+    if (!existingSpec) {
+      await this.db.insert(specs2).values({
+        id: spec.id,
+        name: spec.name,
+        type: spec.type,
+        description: spec.description ?? null,
+        owner: spec.owner ?? null,
+        sourceRepo: spec.sourceRepo ?? null,
+        tags: spec.tags ?? [],
+        createdAt: spec.createdAt,
+        updatedAt: spec.updatedAt
+      });
+    } else {
+      await this.db.update(specs2).set({ updatedAt: /* @__PURE__ */ new Date() }).where(eq2(specs2.id, existingSpec.id));
+    }
+    const specId = existingSpec?.id ?? spec.id;
+    await this.db.insert(specVersions2).values({
+      id: version2.id,
+      specId,
+      semver: version2.semver,
+      content: version2.content,
+      checksum: version2.checksum,
+      gitRef: version2.gitRef ?? null,
+      pushedBy: version2.pushedBy ?? null,
+      compatibility: version2.compatibility ?? null,
+      previousVersion: version2.previousVersion ?? null,
+      forceReason: version2.forceReason ?? null,
+      isPrerelease: version2.isPrerelease,
+      createdAt: version2.createdAt
+    });
+    return version2;
+  }
+  async deleteSpec(name) {
+    const existingSpec = await this.getSpec(name);
+    if (!existingSpec) return false;
+    await this.db.delete(specVersions2).where(eq2(specVersions2.specId, existingSpec.id));
+    await this.db.delete(specs2).where(eq2(specs2.id, existingSpec.id));
+    return true;
+  }
+  async getCompatReport(name, semver) {
+    const version2 = await this.getSpecVersion(name, semver);
+    return version2?.compatibility ?? null;
+  }
+  async logAudit(action, actor, specName, version2, details) {
+    await this.db.insert(auditLog2).values({
+      id: uuid6(),
+      action,
+      actor,
+      specName,
+      version: version2 ?? null,
+      details: details ?? null,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  }
+  mapSpecRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      type: row.type,
+      description: row.description ?? void 0,
+      owner: row.owner ?? void 0,
+      sourceRepo: row.sourceRepo ?? void 0,
+      tags: row.tags ?? [],
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  mapVersionRow(row) {
+    return {
+      id: row.id,
+      specId: row.specId,
+      semver: row.semver,
+      content: row.content,
+      checksum: row.checksum,
+      gitRef: row.gitRef ?? void 0,
+      pushedBy: row.pushedBy ?? void 0,
+      compatibility: row.compatibility ?? void 0,
+      previousVersion: row.previousVersion ?? void 0,
+      forceReason: row.forceReason ?? void 0,
+      isPrerelease: row.isPrerelease,
+      createdAt: row.createdAt
+    };
+  }
+  // GatewayConfigStore implementation
+  async getGatewayConfig(name) {
+    const rows = await this.db.select().from(gatewayConfigs2).where(eq2(gatewayConfigs2.name, name)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapGatewayConfigRow(rows[0]);
+  }
+  async listGatewayConfigs() {
+    const rows = await this.db.select().from(gatewayConfigs2);
+    return rows.map((r) => this.mapGatewayConfigRow(r));
+  }
+  async getGatewayConfigVersion(name, versionId) {
+    const config = await this.getGatewayConfig(name);
+    if (!config) return null;
+    const rows = await this.db.select().from(gatewayConfigVersions2).where(and2(eq2(gatewayConfigVersions2.gatewayConfigId, config.id), eq2(gatewayConfigVersions2.id, versionId))).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapGatewayConfigVersionRow(rows[0]);
+  }
+  async getLatestGatewayConfigVersion(name) {
+    const config = await this.getGatewayConfig(name);
+    if (!config) return null;
+    const rows = await this.db.select().from(gatewayConfigVersions2).where(eq2(gatewayConfigVersions2.gatewayConfigId, config.id)).orderBy(desc2(gatewayConfigVersions2.createdAt), desc2(gatewayConfigVersions2.id)).limit(1);
+    if (rows.length === 0) return null;
+    return this.mapGatewayConfigVersionRow(rows[0]);
+  }
+  async listGatewayConfigVersions(name) {
+    const config = await this.getGatewayConfig(name);
+    if (!config) return [];
+    const rows = await this.db.select().from(gatewayConfigVersions2).where(eq2(gatewayConfigVersions2.gatewayConfigId, config.id)).orderBy(desc2(gatewayConfigVersions2.createdAt), desc2(gatewayConfigVersions2.id)).limit(5);
+    return rows.map((r) => this.mapGatewayConfigVersionRow(r));
+  }
+  async pushGatewayConfigVersion(config, version2) {
+    const existingConfig = await this.getGatewayConfig(config.name);
+    if (!existingConfig) {
+      await this.db.insert(gatewayConfigs2).values({
+        id: config.id,
+        name: config.name,
+        provider: config.provider,
+        specName: config.specName,
+        specSemver: config.specSemver,
+        createdAt: config.createdAt,
+        updatedAt: config.updatedAt
+      });
+    } else {
+      await this.db.update(gatewayConfigs2).set({ updatedAt: /* @__PURE__ */ new Date(), specSemver: config.specSemver }).where(eq2(gatewayConfigs2.id, existingConfig.id));
+    }
+    const configId = existingConfig?.id ?? config.id;
+    await this.db.insert(gatewayConfigVersions2).values({
+      id: version2.id,
+      gatewayConfigId: configId,
+      routes: version2.routes,
+      environments: version2.environments,
+      callerIdentification: version2.callerIdentification ?? null,
+      content: version2.content,
+      checksum: version2.checksum,
+      pushedBy: version2.pushedBy ?? null,
+      createdAt: version2.createdAt
+    });
+    const versions = await this.db.select().from(gatewayConfigVersions2).where(eq2(gatewayConfigVersions2.gatewayConfigId, configId)).orderBy(desc2(gatewayConfigVersions2.createdAt), desc2(gatewayConfigVersions2.id));
+    if (versions.length > 5) {
+      const toDelete = versions.slice(5);
+      for (const v of toDelete) {
+        await this.db.delete(gatewayConfigVersions2).where(eq2(gatewayConfigVersions2.id, v.id));
+      }
+    }
+    return version2;
+  }
+  async recordProvision(provision) {
+    await this.db.insert(provisions2).values({
+      id: provision.id,
+      gatewayConfigName: provision.gatewayConfigName,
+      gatewayConfigVersion: provision.gatewayConfigVersion,
+      environment: provision.environment,
+      provider: provision.provider,
+      synced: provision.synced,
+      actor: provision.actor,
+      details: provision.details ?? null,
+      createdAt: provision.createdAt
+    });
+  }
+  async listProvisions(gatewayConfigName) {
+    const rows = gatewayConfigName ? await this.db.select().from(provisions2).where(eq2(provisions2.gatewayConfigName, gatewayConfigName)).orderBy(desc2(provisions2.createdAt)) : await this.db.select().from(provisions2).orderBy(desc2(provisions2.createdAt));
+    return rows.map((r) => ({
+      id: r.id,
+      gatewayConfigName: r.gatewayConfigName,
+      gatewayConfigVersion: r.gatewayConfigVersion,
+      environment: r.environment,
+      provider: r.provider,
+      synced: r.synced,
+      actor: r.actor,
+      details: r.details ?? void 0,
+      createdAt: r.createdAt
+    }));
+  }
+  mapGatewayConfigRow(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      provider: row.provider,
+      specName: row.specName,
+      specSemver: row.specSemver,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    };
+  }
+  mapGatewayConfigVersionRow(row) {
+    return {
+      id: row.id,
+      gatewayConfigId: row.gatewayConfigId,
+      routes: row.routes,
+      environments: row.environments,
+      callerIdentification: row.callerIdentification ?? void 0,
+      content: row.content,
+      checksum: row.checksum,
+      pushedBy: row.pushedBy ?? void 0,
+      createdAt: row.createdAt
+    };
+  }
+  async recordGatewayLog(log) {
+    await this.db.insert(httpLogs2).values({
+      id: log.id,
+      provider: log.provider,
+      gatewayConfigName: log.gatewayConfigName,
+      environment: log.environment,
+      method: log.method,
+      path: log.path,
+      routePath: log.routePath ?? null,
+      status: log.status,
+      callerId: log.callerId ?? null,
+      callerSource: log.callerSource ?? null,
+      callerConfidence: log.callerConfidence,
+      occurredAt: log.occurredAt,
+      createdAt: log.createdAt
+    });
+  }
+  async listGatewayLogs(filters) {
+    const limit = filters.limit ?? 50;
+    const offset = filters.offset ?? 0;
+    let query = this.db.select().from(httpLogs2);
+    const conditions = [];
+    if (filters.gatewayConfigName) {
+      conditions.push(eq2(httpLogs2.gatewayConfigName, filters.gatewayConfigName));
+    }
+    if (filters.environment) {
+      conditions.push(eq2(httpLogs2.environment, filters.environment));
+    }
+    if (filters.path) {
+      conditions.push(eq2(httpLogs2.path, filters.path));
+    }
+    if (filters.method) {
+      conditions.push(eq2(httpLogs2.method, filters.method));
+    }
+    if (filters.status !== void 0) {
+      conditions.push(eq2(httpLogs2.status, filters.status));
+    }
+    if (filters.from) {
+      conditions.push(sql2`${httpLogs2.occurredAt} >= ${filters.from}`);
+    }
+    if (filters.to) {
+      conditions.push(sql2`${httpLogs2.occurredAt} <= ${filters.to}`);
+    }
+    if (conditions.length > 0) {
+      query = query.where(and2(...conditions));
+    }
+    const countResult = await this.db.select({ count: sql2`count(*)` }).from(httpLogs2).where(conditions.length > 0 ? and2(...conditions) : void 0);
+    const total = countResult[0]?.count ?? 0;
+    const rows = await query.orderBy(desc2(httpLogs2.occurredAt)).limit(limit).offset(offset);
+    return {
+      logs: rows.map((r) => ({
+        id: r.id,
+        provider: r.provider,
+        gatewayConfigName: r.gatewayConfigName,
+        environment: r.environment,
+        method: r.method,
+        path: r.path,
+        routePath: r.routePath ?? void 0,
+        status: r.status,
+        callerId: r.callerId ?? void 0,
+        callerSource: r.callerSource ?? void 0,
+        callerConfidence: r.callerConfidence,
+        occurredAt: r.occurredAt,
+        createdAt: r.createdAt
+      })),
+      total
+    };
+  }
+  async getGatewayLog(id) {
+    const rows = await this.db.select().from(httpLogs2).where(eq2(httpLogs2.id, id)).limit(1);
+    if (rows.length === 0) return null;
+    const r = rows[0];
+    return {
+      id: r.id,
+      provider: r.provider,
+      gatewayConfigName: r.gatewayConfigName,
+      environment: r.environment,
+      method: r.method,
+      path: r.path,
+      routePath: r.routePath ?? void 0,
+      status: r.status,
+      callerId: r.callerId ?? void 0,
+      callerSource: r.callerSource ?? void 0,
+      callerConfidence: r.callerConfidence,
+      occurredAt: r.occurredAt,
+      createdAt: r.createdAt
+    };
+  }
+  async getGatewayLogStats(_filters) {
+    const conditions = [];
+    if (_filters.gatewayConfigName) {
+      conditions.push(eq2(httpLogs2.gatewayConfigName, _filters.gatewayConfigName));
+    }
+    if (_filters.environment) {
+      conditions.push(eq2(httpLogs2.environment, _filters.environment));
+    }
+    if (_filters.from) {
+      conditions.push(sql2`${httpLogs2.occurredAt} >= ${_filters.from}`);
+    }
+    if (_filters.to) {
+      conditions.push(sql2`${httpLogs2.occurredAt} <= ${_filters.to}`);
+    }
+    const whereClause = conditions.length > 0 ? and2(...conditions) : void 0;
+    const rows = await this.db.select({
+      gatewayConfigName: httpLogs2.gatewayConfigName,
+      environment: httpLogs2.environment,
+      method: httpLogs2.method,
+      routePath: httpLogs2.routePath,
+      lastSeenAt: sql2`max(${httpLogs2.occurredAt})`,
+      totalCalls: sql2`count(*)`,
+      uniqueCallerIds: sql2`count(distinct ${httpLogs2.callerId})`
+    }).from(httpLogs2).where(whereClause).groupBy(httpLogs2.gatewayConfigName, httpLogs2.environment, httpLogs2.method, httpLogs2.routePath);
+    return rows.map((r) => ({
+      gatewayConfigName: r.gatewayConfigName,
+      environment: r.environment,
+      method: r.method,
+      routePath: r.routePath ?? "/",
+      lastSeenAt: new Date(r.lastSeenAt),
+      totalCalls: r.totalCalls,
+      uniqueCallerIds: r.uniqueCallerIds
+    }));
+  }
+  async deleteGatewayLogsOlderThan(days) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    await this.db.delete(httpLogs2).where(sql2`${httpLogs2.occurredAt} < ${cutoff}`);
+  }
+};
+
 // src/registry/serve.ts
 async function startServer(userConfig) {
   const config = { ...defaultConfig, ...userConfig };
-  if (!config.sqlitePath && config.database === "sqlite") {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-    config.sqlitePath = path9.join(homeDir, ".grapity", "registry.db");
-  }
-  if (config.database === "sqlite" && config.sqlitePath) {
-    const dir = path9.dirname(config.sqlitePath);
+  let store;
+  if (config.database === "postgresql") {
+    if (!config.postgresUrl) {
+      throw new Error("PostgreSQL database requested but no postgresUrl provided.");
+    }
+    store = new PostgreSQLSpecStore(config.postgresUrl);
+  } else {
+    const sqlitePath = config.sqlitePath ?? path9.join(
+      process.env.HOME || process.env.USERPROFILE || ".",
+      ".grapity",
+      "registry.db"
+    );
+    const dir = path9.dirname(sqlitePath);
     if (!fs9.existsSync(dir)) {
       fs9.mkdirSync(dir, { recursive: true });
     }
+    store = new SQLiteSpecStore(sqlitePath);
   }
-  const store = new SQLiteSpecStore(config.sqlitePath);
   await store.migrate();
   const app = createApp(config, store);
-  serve({
+  const server = serve({
     fetch: app.fetch,
     port: config.port
   });
-  return app;
+  return { app, store, server };
 }
 if (process.argv[1] === new URL(import.meta.url).pathname) {
   startServer();
@@ -5036,28 +5554,63 @@ function getPackageVersion() {
     return "unknown";
   }
 }
+function resolveServerConfig(cliOptions, cliConfig) {
+  const envUrl = process.env.GRAPITY_DATABASE_URL;
+  const dbValue = envUrl ?? cliOptions.db;
+  if (dbValue) {
+    if (isPostgresqlUrl(dbValue)) {
+      return { port: cliOptions.port, database: "postgresql", postgresUrl: dbValue };
+    }
+    return { port: cliOptions.port, database: "sqlite", sqlitePath: dbValue };
+  }
+  if (cliConfig.mode === "local") {
+    const local = cliConfig.local;
+    if (local?.database === "postgresql") {
+      if (!local.postgresUrl) {
+        throw new Error(
+          "PostgreSQL is configured but no postgresUrl is set. Run grapity init --local --db postgresql://... or set GRAPITY_DATABASE_URL."
+        );
+      }
+      return { port: cliOptions.port, database: "postgresql", postgresUrl: local.postgresUrl };
+    }
+    return {
+      port: cliOptions.port,
+      database: "sqlite",
+      sqlitePath: local?.sqlitePath ?? path11.join(os4.homedir(), ".grapity", "registry.db")
+    };
+  }
+  return {
+    port: cliOptions.port,
+    database: "sqlite",
+    sqlitePath: path11.join(os4.homedir(), ".grapity", "registry.db")
+  };
+}
 function createServeCommand(_version) {
-  return new Command19("serve").description("Start the local grapity registry server").option("-p, --port <port>", "Port to listen on", "3750").option("--db <url>", "Database URL (sqlite path or postgresql URL)").option("--auth <mode>", "Auth mode: none, api-key, jwt", "none").option("--hub-port <port>", "Port for the developer portal (Hub)", "3000").option("--no-hub", "Skip starting the developer portal").action(async (options) => {
+  return new Command19("serve").description("Start the local grapity registry server").option("-p, --port <port>", "Port to listen on", "3750").option("--hub-port <port>", "Port for the developer portal (Hub)", "3000").option("--no-hub", "Skip starting the developer portal").option("--db <path-or-url>", "SQLite path or postgresql:// URL").action(async (options) => {
     const port = parseInt(options.port, 10);
     const hubPort = parseInt(options.hubPort, 10);
     const startHub = options.hub !== false;
-    const db = options.db;
-    const auth = options.auth;
-    const isPostgres = db?.startsWith("postgresql://");
-    const dbMode = isPostgres ? "postgresql" : "sqlite";
-    const dbPath = isPostgres ? void 0 : db ?? path11.join(os4.homedir(), ".grapity", "registry.db");
     const version2 = getPackageVersion();
+    const cliConfig = getConfig();
+    let serverConfig;
+    try {
+      serverConfig = resolveServerConfig({ port, db: options.db }, cliConfig);
+    } catch (err) {
+      console.error(formatError("invalid config", err.message));
+      process.exit(1);
+    }
     console.log(formatHeader("grapity Registry", `v${version2}`));
     console.log("");
-    console.log(formatServeConfig({ mode: dbMode, port, dbPath, auth }));
+    console.log(
+      formatServeConfig({
+        port,
+        database: serverConfig.database,
+        dbPath: serverConfig.sqlitePath,
+        postgresUrl: serverConfig.postgresUrl
+      })
+    );
     console.log("");
-    await startServer({
-      port,
-      database: dbMode,
-      sqlitePath: dbPath,
-      postgresUrl: isPostgres ? db : void 0,
-      auth: auth === "none" ? { mode: "none" } : { mode: auth }
-    });
+    const { store } = await startServer(serverConfig);
     console.log(formatReady(port));
     if (startHub) {
       console.log("");
@@ -5076,9 +5629,12 @@ function createServeCommand(_version) {
       });
       console.log(formatHubReady(hubPort));
     }
-    process.on("SIGINT", () => {
+    process.on("SIGINT", async () => {
       console.log("");
       console.log(formatShutdown());
+      if ("end" in store && typeof store.end === "function") {
+        await store.end();
+      }
       process.exit(0);
     });
   });