@topgunbuild/server 0.10.1 → 0.11.0

package/dist/{chunk-IQNKZPW3.mjs → chunk-Z3TONATT.mjs}

@@ -24370,17 +24370,18 @@ function buildTLSOptions(config2) {
   return options;
 }
 function createNetworkModule(config2, _deps) {
+  let currentRequestHandler = (_req, res) => {
+    res.writeHead(200);
+    res.end(config2.tls?.enabled ? "TopGun Server Running (Secure)" : "TopGun Server Running");
+  };
+  const requestDispatcher = (req, res) => {
+    currentRequestHandler(req, res);
+  };
   let httpServer;
   if (config2.tls?.enabled) {
-    httpServer = createHttpsServer(buildTLSOptions(config2.tls), (_req, res) => {
-      res.writeHead(200);
-      res.end("TopGun Server Running (Secure)");
-    });
+    httpServer = createHttpsServer(buildTLSOptions(config2.tls), requestDispatcher);
   } else {
-    httpServer = createHttpServer((_req, res) => {
-      res.writeHead(200);
-      res.end("TopGun Server Running");
-    });
+    httpServer = createHttpServer(requestDispatcher);
   }
   httpServer.maxConnections = config2.maxConnections ?? 1e4;
   httpServer.timeout = config2.serverTimeout ?? 12e4;
@@ -24418,6 +24419,11 @@ function createNetworkModule(config2, _deps) {
       httpServer.listen(config2.port, () => {
         logger.info({ port: config2.port }, "Server Coordinator listening");
       });
+    },
+    // Deferred wiring: allows ServerFactory to inject the /sync handler
+    // after HttpSyncHandler is assembled
+    setHttpRequestHandler: (handler) => {
+      currentRequestHandler = handler;
     }
   };
 }
@@ -27480,6 +27486,253 @@ var QueryHandler = class {
   }
 };
 
+// src/coordinator/http-sync-handler.ts
+import { HLC as HLC8, LWWMap as LWWMap10 } from "@topgunbuild/core";
+var HttpSyncHandler = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /**
+   * Process a complete HTTP sync request and return a response.
+   *
+   * @param request - Parsed and validated HttpSyncRequest body
+   * @param authToken - JWT token from Authorization header
+   * @returns HttpSyncResponse with acks, deltas, query/search results
+   * @throws Error with message starting with '401:' for auth failures
+   * @throws Error with message starting with '403:' for permission failures
+   */
+  async handleSyncRequest(request, authToken) {
+    let principal;
+    try {
+      principal = this.config.authHandler.verifyToken(authToken);
+    } catch (err) {
+      throw new Error(`401: Authentication failed: ${err.message}`);
+    }
+    this.config.hlc.update({
+      millis: request.clientHlc.millis,
+      counter: request.clientHlc.counter,
+      nodeId: request.clientHlc.nodeId
+    });
+    const response = {
+      serverHlc: this.config.hlc.now()
+    };
+    const errors = [];
+    if (request.operations && request.operations.length > 0) {
+      const ackResults = await this.processOperations(request.operations, principal, errors);
+      if (ackResults.processedCount > 0) {
+        response.ack = {
+          lastId: ackResults.lastId,
+          results: ackResults.results.length > 0 ? ackResults.results : void 0
+        };
+      }
+    }
+    if (request.syncMaps && request.syncMaps.length > 0) {
+      response.deltas = await this.computeDeltas(request.syncMaps, principal, errors);
+    }
+    if (request.queries && request.queries.length > 0) {
+      response.queryResults = await this.executeQueries(request.queries, principal, errors);
+    }
+    if (request.searches && request.searches.length > 0) {
+      response.searchResults = await this.executeSearches(request.searches, principal, errors);
+    }
+    if (errors.length > 0) {
+      response.errors = errors;
+    }
+    response.serverHlc = this.config.hlc.now();
+    return response;
+  }
+  /**
+   * Process a batch of client operations.
+   */
+  async processOperations(operations, principal, errors) {
+    let lastId = "";
+    let processedCount = 0;
+    const results = [];
+    for (const op of operations) {
+      const opId = op.id || `http-op-${processedCount}`;
+      const isRemove = op.opType === "REMOVE" || op.record && op.record.value === null;
+      const action = isRemove ? "REMOVE" : "PUT";
+      if (!this.config.securityManager.checkPermission(principal, op.mapName, action)) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Operation on ${op.mapName}/${op.key}`
+        });
+        results.push({
+          opId,
+          success: false,
+          achievedLevel: "FIRE_AND_FORGET",
+          error: "Access denied"
+        });
+        continue;
+      }
+      try {
+        const result = await this.config.operationHandler.applyOpToMap(op);
+        if (result.rejected) {
+          results.push({
+            opId,
+            success: false,
+            achievedLevel: "FIRE_AND_FORGET",
+            error: "Operation rejected by conflict resolver"
+          });
+        } else {
+          results.push({
+            opId,
+            success: true,
+            achievedLevel: "MEMORY"
+          });
+        }
+        processedCount++;
+        lastId = opId;
+      } catch (err) {
+        logger.error({ err, opId }, "HTTP sync operation failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Operation failed",
+          context: `Operation ${opId} on ${op.mapName}/${op.key}`
+        });
+        results.push({
+          opId,
+          success: false,
+          achievedLevel: "FIRE_AND_FORGET",
+          error: err.message || "Operation failed"
+        });
+      }
+    }
+    return { processedCount, lastId, results };
+  }
+  /**
+   * Compute deltas by iterating the in-memory LWWMap and filtering records
+   * newer than the client's lastSyncTimestamp using HLC.compare().
+   */
+  async computeDeltas(syncMaps, principal, errors) {
+    const deltas = [];
+    for (const { mapName, lastSyncTimestamp } of syncMaps) {
+      if (!this.config.securityManager.checkPermission(principal, mapName, "READ")) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Read deltas for ${mapName}`
+        });
+        continue;
+      }
+      try {
+        const map2 = await this.config.storageManager.getMapAsync(mapName);
+        if (!(map2 instanceof LWWMap10)) {
+          errors.push({
+            code: 400,
+            message: "HTTP sync only supports LWWMap deltas",
+            context: `Map ${mapName} is not an LWWMap`
+          });
+          continue;
+        }
+        const records = [];
+        for (const key of map2.allKeys()) {
+          const record2 = map2.getRecord(key);
+          if (!record2) continue;
+          if (HLC8.compare(record2.timestamp, lastSyncTimestamp) > 0) {
+            records.push({
+              key,
+              record: record2,
+              eventType: record2.value === null ? "REMOVE" : "PUT"
+            });
+          }
+        }
+        const serverSyncTimestamp = this.config.hlc.now();
+        deltas.push({
+          mapName,
+          records,
+          serverSyncTimestamp
+        });
+      } catch (err) {
+        logger.error({ err, mapName }, "HTTP sync delta computation failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Delta computation failed",
+          context: `Map ${mapName}`
+        });
+      }
+    }
+    return deltas.length > 0 ? deltas : void 0;
+  }
+  /**
+   * Execute one-shot queries.
+   */
+  async executeQueries(queries, principal, errors) {
+    const results = [];
+    for (const query of queries) {
+      if (!this.config.securityManager.checkPermission(principal, query.mapName, "READ")) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Query ${query.queryId} on ${query.mapName}`
+        });
+        continue;
+      }
+      try {
+        const coreQuery = {
+          where: query.filter,
+          limit: query.limit
+        };
+        const queryResults = await this.config.queryConversionHandler.executeLocalQuery(
+          query.mapName,
+          coreQuery
+        );
+        const hasMore = query.limit ? queryResults.length >= query.limit : false;
+        results.push({
+          queryId: query.queryId,
+          results: queryResults,
+          hasMore
+        });
+      } catch (err) {
+        logger.error({ err, queryId: query.queryId }, "HTTP sync query failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Query failed",
+          context: `Query ${query.queryId} on ${query.mapName}`
+        });
+      }
+    }
+    return results.length > 0 ? results : void 0;
+  }
+  /**
+   * Execute one-shot searches.
+   */
+  async executeSearches(searches, principal, errors) {
+    const results = [];
+    for (const search of searches) {
+      if (!this.config.securityManager.checkPermission(principal, search.mapName, "READ")) {
+        errors.push({
+          code: 403,
+          message: "Access denied",
+          context: `Search ${search.searchId} on ${search.mapName}`
+        });
+        continue;
+      }
+      try {
+        const searchResult = this.config.searchCoordinator.search(
+          search.mapName,
+          search.query,
+          search.options
+        );
+        results.push({
+          searchId: search.searchId,
+          results: searchResult.results || [],
+          totalCount: searchResult.totalCount
+        });
+      } catch (err) {
+        logger.error({ err, searchId: search.searchId }, "HTTP sync search failed");
+        errors.push({
+          code: 500,
+          message: err.message || "Search failed",
+          context: `Search ${search.searchId} on ${search.mapName}`
+        });
+      }
+    }
+    return results.length > 0 ? results : void 0;
+  }
+};
+
 // src/coordinator/websocket-handler.ts
 import * as crypto2 from "crypto";
 import { serialize as serialize5, deserialize, MessageSchema } from "@topgunbuild/core";
@@ -30557,7 +30810,7 @@ function createBootstrapController(config2) {
 
 // src/ServerFactory.ts
 import { createServer as createHttpServer2 } from "http";
-import { PARTITION_COUNT as PARTITION_COUNT7 } from "@topgunbuild/core";
+import { PARTITION_COUNT as PARTITION_COUNT7, serialize as serialize7, deserialize as deserialize2, HttpSyncRequestSchema } from "@topgunbuild/core";
 
 // src/debug/DebugEndpoints.ts
 import {
@@ -31420,6 +31673,25 @@ var ServerFactory = class _ServerFactory {
         journalSubscriptions
       }
     } = handlers;
+    const httpSyncHandler = new HttpSyncHandler({
+      authHandler,
+      operationHandler,
+      storageManager,
+      queryConversionHandler,
+      searchCoordinator,
+      hlc,
+      securityManager
+    });
+    if (network.setHttpRequestHandler) {
+      network.setHttpRequestHandler((req, res) => {
+        if (req.method === "POST" && req.url === "/sync") {
+          _ServerFactory.handleHttpSync(req, res, httpSyncHandler);
+          return;
+        }
+        res.writeHead(200);
+        res.end(config2.tls?.enabled ? "TopGun Server Running (Secure)" : "TopGun Server Running");
+      });
+    }
     const lifecycle = createLifecycleModule(
       { nodeId: config2.nodeId },
       {
@@ -31522,6 +31794,70 @@ var ServerFactory = class _ServerFactory {
     }
     return coordinator;
   }
+  /**
+   * Handle an HTTP sync request by parsing the body, validating auth,
+   * delegating to HttpSyncHandler, and serializing the response.
+   */
+  static handleHttpSync(req, res, handler) {
+    const authHeader = req.headers["authorization"] || "";
+    const token = authHeader.startsWith("Bearer ") ? authHeader.slice(7) : "";
+    if (!token) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Missing Authorization header" }));
+      return;
+    }
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", async () => {
+      try {
+        const body = Buffer.concat(chunks);
+        const contentType = req.headers["content-type"] || "";
+        const isJson = contentType.includes("application/json");
+        let parsed;
+        if (isJson) {
+          parsed = JSON.parse(body.toString("utf-8"));
+        } else {
+          parsed = deserialize2(body);
+        }
+        const validation = HttpSyncRequestSchema.safeParse(parsed);
+        if (!validation.success) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Invalid request body",
+            details: validation.error.issues
+          }));
+          return;
+        }
+        const response = await handler.handleSyncRequest(validation.data, token);
+        if (isJson) {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify(response));
+        } else {
+          const responseBytes = serialize7(response);
+          res.writeHead(200, { "Content-Type": "application/x-msgpack" });
+          res.end(Buffer.from(responseBytes));
+        }
+      } catch (err) {
+        const message = err.message || "Internal server error";
+        if (message.startsWith("401:")) {
+          res.writeHead(401, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: message.slice(5).trim() }));
+        } else if (message.startsWith("403:")) {
+          res.writeHead(403, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: message.slice(5).trim() }));
+        } else {
+          logger.error({ err }, "HTTP sync request failed");
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Internal server error" }));
+        }
+      }
+    });
+    req.on("error", (err) => {
+      logger.error({ err }, "HTTP sync request stream error");
+      res.writeHead(400, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Request stream error" }));
+    });
+  }
   static createMetricsServer(bootstrap, settings, debug, metrics) {
     const server = createHttpServer2(async (req, res) => {
       const bootstrapHandled = await bootstrap.handle(req, res);
@@ -31657,4 +31993,4 @@ export {
   createBootstrapController,
   ServerFactory
 };
-//# sourceMappingURL=chunk-IQNKZPW3.mjs.map
+//# sourceMappingURL=chunk-Z3TONATT.mjs.map