geo-engine-node 1.1.0 → 1.1.2

package/dist/index.cjs

@@ -0,0 +1,115 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.js
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var DEFAULTS = {
+  managementUrl: "https://api.geoengine.dev",
+  ingestUrl: "https://ingest.geoengine.dev",
+  timeout: 1e4
+};
+var GeoEngine = class {
+  /**
+   * Inicializa el cliente de Geo-Engine.
+   * @param {string} apiKey - Tu API Key.
+   * @param {Object} [options] - Configuración opcional.
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error("GeoEngine: API Key es requerida.");
+    }
+    this.apiKey = apiKey;
+    this.config = { ...DEFAULTS, ...options };
+    this.userAgent = "GeoEngineNode/1.1.2";
+  }
+  /**
+   * Helper privado para hacer peticiones con timeout
+   */
+  async _request(url, method, body) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.apiKey,
+          "User-Agent": this.userAgent
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(id);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GeoEngine API Error (${response.status}): ${errorText}`);
+      }
+      if (response.status === 204) return null;
+      return await response.json();
+    } catch (error) {
+      clearTimeout(id);
+      if (error.name === "AbortError") {
+        throw new Error(`GeoEngine: La petici\xF3n excedi\xF3 el tiempo l\xEDmite de ${this.config.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Envía una ubicación al motor de ingestión.
+   */
+  async sendLocation(deviceId, lat, lng) {
+    if (!deviceId || lat === void 0 || lng === void 0) {
+      throw new Error("GeoEngine: deviceId, lat y lng son obligatorios.");
+    }
+    const payload = {
+      device_id: deviceId,
+      latitude: parseFloat(lat),
+      longitude: parseFloat(lng),
+      timestamp: Math.floor(Date.now() / 1e3)
+    };
+    return this._request(`${this.config.ingestUrl}/ingest`, "POST", payload);
+  }
+  /**
+   * Crea una nueva geocerca.
+   */
+  async createGeofence(name, coordinates, webhookUrl) {
+    if (!name || !coordinates || coordinates.length < 3) {
+      throw new Error("GeoEngine: Se requiere un nombre y al menos 3 coordenadas.");
+    }
+    const polygon = coordinates.map((p) => [p[1], p[0]]);
+    const first = polygon[0];
+    const last = polygon[polygon.length - 1];
+    if (first[0] !== last[0] || first[1] !== last[1]) {
+      polygon.push(first);
+    }
+    const payload = {
+      name,
+      webhook_url: webhookUrl,
+      geojson: {
+        type: "Polygon",
+        coordinates: [polygon]
+      }
+    };
+    return this._request(`${this.config.managementUrl}/geofences`, "POST", payload);
+  }
+};
+var index_default = GeoEngine;

package/dist/index.d.cts

@@ -0,0 +1,110 @@
+const DEFAULTS = {
+  managementUrl: 'https://api.geoengine.dev',
+  ingestUrl: 'https://ingest.geoengine.dev',
+  timeout: 10000
+};
+
+class GeoEngine {
+  /**
+   * Inicializa el cliente de Geo-Engine.
+   * @param {string} apiKey - Tu API Key.
+   * @param {Object} [options] - Configuración opcional.
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error('GeoEngine: API Key es requerida.');
+    }
+
+    this.apiKey = apiKey;
+    this.config = { ...DEFAULTS, ...options };
+    this.userAgent = 'GeoEngineNode/1.1.2';
+  }
+
+  /**
+   * Helper privado para hacer peticiones con timeout
+   */
+  async _request(url, method, body) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), this.config.timeout);
+
+    try {
+      const response = await fetch(url, {
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': this.apiKey,
+          'User-Agent': this.userAgent
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+
+      clearTimeout(id);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GeoEngine API Error (${response.status}): ${errorText}`);
+      }
+
+      if (response.status === 204) return null;
+
+      return await response.json();
+    } catch (error) {
+      clearTimeout(id);
+      if (error.name === 'AbortError') {
+        throw new Error(`GeoEngine: La petición excedió el tiempo límite de ${this.config.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Envía una ubicación al motor de ingestión.
+   */
+  async sendLocation(deviceId, lat, lng) {
+    if (!deviceId || lat === undefined || lng === undefined) {
+      throw new Error("GeoEngine: deviceId, lat y lng son obligatorios.");
+    }
+
+    const payload = {
+      device_id: deviceId,
+      latitude: parseFloat(lat),
+      longitude: parseFloat(lng),
+      timestamp: Math.floor(Date.now() / 1000)
+    };
+
+    return this._request(`${this.config.ingestUrl}/ingest`, 'POST', payload);
+  }
+
+  /**
+   * Crea una nueva geocerca.
+   */
+  async createGeofence(name, coordinates, webhookUrl) {
+    if (!name || !coordinates || coordinates.length < 3) {
+      throw new Error("GeoEngine: Se requiere un nombre y al menos 3 coordenadas.");
+    }
+
+    // Convertir formato simple [[lat,lng]] a GeoJSON [Lng, Lat]
+    const polygon = coordinates.map(p => [p[1], p[0]]);
+
+    // Cerrar polígono automáticamente
+    const first = polygon[0];
+    const last = polygon[polygon.length - 1];
+    if (first[0] !== last[0] || first[1] !== last[1]) {
+      polygon.push(first);
+    }
+
+    const payload = {
+      name,
+      webhook_url: webhookUrl,
+      geojson: {
+        type: 'Polygon',
+        coordinates: [polygon]
+      }
+    };
+
+    return this._request(`${this.config.managementUrl}/geofences`, 'POST', payload);
+  }
+}
+
+export { GeoEngine as default };

package/dist/index.d.ts

@@ -0,0 +1,110 @@
+const DEFAULTS = {
+  managementUrl: 'https://api.geoengine.dev',
+  ingestUrl: 'https://ingest.geoengine.dev',
+  timeout: 10000
+};
+
+class GeoEngine {
+  /**
+   * Inicializa el cliente de Geo-Engine.
+   * @param {string} apiKey - Tu API Key.
+   * @param {Object} [options] - Configuración opcional.
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error('GeoEngine: API Key es requerida.');
+    }
+
+    this.apiKey = apiKey;
+    this.config = { ...DEFAULTS, ...options };
+    this.userAgent = 'GeoEngineNode/1.1.2';
+  }
+
+  /**
+   * Helper privado para hacer peticiones con timeout
+   */
+  async _request(url, method, body) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), this.config.timeout);
+
+    try {
+      const response = await fetch(url, {
+        method: method,
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': this.apiKey,
+          'User-Agent': this.userAgent
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+
+      clearTimeout(id);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GeoEngine API Error (${response.status}): ${errorText}`);
+      }
+
+      if (response.status === 204) return null;
+
+      return await response.json();
+    } catch (error) {
+      clearTimeout(id);
+      if (error.name === 'AbortError') {
+        throw new Error(`GeoEngine: La petición excedió el tiempo límite de ${this.config.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Envía una ubicación al motor de ingestión.
+   */
+  async sendLocation(deviceId, lat, lng) {
+    if (!deviceId || lat === undefined || lng === undefined) {
+      throw new Error("GeoEngine: deviceId, lat y lng son obligatorios.");
+    }
+
+    const payload = {
+      device_id: deviceId,
+      latitude: parseFloat(lat),
+      longitude: parseFloat(lng),
+      timestamp: Math.floor(Date.now() / 1000)
+    };
+
+    return this._request(`${this.config.ingestUrl}/ingest`, 'POST', payload);
+  }
+
+  /**
+   * Crea una nueva geocerca.
+   */
+  async createGeofence(name, coordinates, webhookUrl) {
+    if (!name || !coordinates || coordinates.length < 3) {
+      throw new Error("GeoEngine: Se requiere un nombre y al menos 3 coordenadas.");
+    }
+
+    // Convertir formato simple [[lat,lng]] a GeoJSON [Lng, Lat]
+    const polygon = coordinates.map(p => [p[1], p[0]]);
+
+    // Cerrar polígono automáticamente
+    const first = polygon[0];
+    const last = polygon[polygon.length - 1];
+    if (first[0] !== last[0] || first[1] !== last[1]) {
+      polygon.push(first);
+    }
+
+    const payload = {
+      name,
+      webhook_url: webhookUrl,
+      geojson: {
+        type: 'Polygon',
+        coordinates: [polygon]
+      }
+    };
+
+    return this._request(`${this.config.managementUrl}/geofences`, 'POST', payload);
+  }
+}
+
+export { GeoEngine as default };

package/dist/index.js

@@ -0,0 +1,95 @@
+// index.js
+var DEFAULTS = {
+  managementUrl: "https://api.geoengine.dev",
+  ingestUrl: "https://ingest.geoengine.dev",
+  timeout: 1e4
+};
+var GeoEngine = class {
+  /**
+   * Inicializa el cliente de Geo-Engine.
+   * @param {string} apiKey - Tu API Key.
+   * @param {Object} [options] - Configuración opcional.
+   */
+  constructor(apiKey, options = {}) {
+    if (!apiKey) {
+      throw new Error("GeoEngine: API Key es requerida.");
+    }
+    this.apiKey = apiKey;
+    this.config = { ...DEFAULTS, ...options };
+    this.userAgent = "GeoEngineNode/1.1.2";
+  }
+  /**
+   * Helper privado para hacer peticiones con timeout
+   */
+  async _request(url, method, body) {
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "X-API-Key": this.apiKey,
+          "User-Agent": this.userAgent
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(id);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`GeoEngine API Error (${response.status}): ${errorText}`);
+      }
+      if (response.status === 204) return null;
+      return await response.json();
+    } catch (error) {
+      clearTimeout(id);
+      if (error.name === "AbortError") {
+        throw new Error(`GeoEngine: La petici\xF3n excedi\xF3 el tiempo l\xEDmite de ${this.config.timeout}ms`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Envía una ubicación al motor de ingestión.
+   */
+  async sendLocation(deviceId, lat, lng) {
+    if (!deviceId || lat === void 0 || lng === void 0) {
+      throw new Error("GeoEngine: deviceId, lat y lng son obligatorios.");
+    }
+    const payload = {
+      device_id: deviceId,
+      latitude: parseFloat(lat),
+      longitude: parseFloat(lng),
+      timestamp: Math.floor(Date.now() / 1e3)
+    };
+    return this._request(`${this.config.ingestUrl}/ingest`, "POST", payload);
+  }
+  /**
+   * Crea una nueva geocerca.
+   */
+  async createGeofence(name, coordinates, webhookUrl) {
+    if (!name || !coordinates || coordinates.length < 3) {
+      throw new Error("GeoEngine: Se requiere un nombre y al menos 3 coordenadas.");
+    }
+    const polygon = coordinates.map((p) => [p[1], p[0]]);
+    const first = polygon[0];
+    const last = polygon[polygon.length - 1];
+    if (first[0] !== last[0] || first[1] !== last[1]) {
+      polygon.push(first);
+    }
+    const payload = {
+      name,
+      webhook_url: webhookUrl,
+      geojson: {
+        type: "Polygon",
+        coordinates: [polygon]
+      }
+    };
+    return this._request(`${this.config.managementUrl}/geofences`, "POST", payload);
+  }
+};
+var index_default = GeoEngine;
+export {
+  index_default as default
+};

package/index.js

@@ -17,7 +17,7 @@ class GeoEngine {
 
     this.apiKey = apiKey;
     this.config = { ...DEFAULTS, ...options };
-    this.userAgent = 'GeoEngineNode/1.0.0';
+    this.userAgent = 'GeoEngineNode/1.1.2';
   }
 
   /**
@@ -42,22 +42,13 @@ class GeoEngine {
       clearTimeout(id);
 
       if (!response.ok) {
-        // Intentar leer el error en JSON, si falla, leer texto
-        let errorData;
-        try {
-          errorData = await response.json();
-        } catch (e) {
-          errorData = { error: await response.text() };
-        }
-
-        throw new Error(`GeoEngine API Error (${response.status}): ${errorData.error || JSON.stringify(errorData)}`);
+        const errorText = await response.text();
+        throw new Error(`GeoEngine API Error (${response.status}): ${errorText}`);
       }
 
-      // Si la respuesta es 204 No Content o vacía, devolver null
       if (response.status === 204) return null;
 
       return await response.json();
-
     } catch (error) {
       clearTimeout(id);
       if (error.name === 'AbortError') {

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "geo-engine-node",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
-  "description": "SDK oficial para Geo-Engine. Rastreo de activos y gestión de geocercas.",
-  "main": "index.js",
+  "description": "SDK oficial para Geo-Engine...",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "example": "node examples/simulation.js",
     "release:patch": "npm version patch && npm publish --access public",
-    "release:minor": "npm version minor && npm publish --access public"
+    "release:minor": "npm version minor && npm publish --access public",
+    "build": "tsup index.js --format cjs,esm --dts --clean"
   },
   "keywords": [
     "geofencing",
@@ -18,8 +28,11 @@
   ],
   "author": "Geo-Engine Team",
   "license": "MIT",
-  "dependencies": {},
   "engines": {
     "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
   }
-}
+}