@dealcrawl/sdk 2.11.1 → 2.12.0

package/dist/index.mjs

@@ -1633,6 +1633,75 @@ var DataResource = class {
       sortOrder: "desc"
     });
   }
+  /**
+   * Get full job details with result
+   *
+   * @example
+   * ```ts
+   * const job = await client.data.getJob("job_abc123");
+   * console.log(job.result);
+   * console.log(job.dealsFound);
+   * ```
+   */
+  async getJob(jobId) {
+    if (!jobId || !jobId.trim()) {
+      throw new Error("jobId is required and cannot be empty");
+    }
+    const result = await get(
+      this.ctx,
+      `/v1/data/jobs/${jobId}`
+    );
+    return result.data;
+  }
+  /**
+   * Get only the result of a completed job
+   *
+   * @example
+   * ```ts
+   * const result = await client.data.getJobResult("job_abc123");
+   * console.log(result.result);
+   * ```
+   */
+  async getJobResult(jobId) {
+    if (!jobId || !jobId.trim()) {
+      throw new Error("jobId is required and cannot be empty");
+    }
+    const result = await get(
+      this.ctx,
+      `/v1/data/jobs/${jobId}/result`
+    );
+    return result.data;
+  }
+  /**
+   * Export job results in various formats
+   * Supports: json, markdown, llm, csv
+   *
+   * @example
+   * ```ts
+   * // Export as JSON
+   * const jsonData = await client.data.exportJob("job_abc123", "json");
+   *
+   * // Export as Markdown
+   * const markdown = await client.data.exportJob("job_abc123", "markdown");
+   *
+   * // Export as LLM-optimized format
+   * const llmText = await client.data.exportJob("job_abc123", "llm");
+   *
+   * // Export as CSV
+   * const csv = await client.data.exportJob("job_abc123", "csv");
+   * ```
+   */
+  async exportJob(jobId, format = "json") {
+    if (!jobId || !jobId.trim()) {
+      throw new Error("jobId is required and cannot be empty");
+    }
+    const result = await get(
+      this.ctx,
+      `/v1/data/jobs/${jobId}/export`,
+      { format }
+    );
+    return result.data;
+  }
   // ============================================
   // DEALS
   // ============================================
@@ -3009,6 +3078,31 @@ var StatusResource = class {
     );
     return result.data;
   }
+  /**
+   * Get errors from a job
+   * Useful for debugging large crawls without loading full results
+   *
+   * @example
+   * ```ts
+   * const errors = await client.status.getJobErrors("job_abc123", {
+   *   limit: 50,
+   *   offset: 0
+   * });
+   * console.log(errors.data);
+   * console.log(errors.pagination.total);
+   * ```
+   */
+  async getJobErrors(jobId, options) {
+    const result = await get(
+      this.ctx,
+      `/v1/status/${jobId}/errors`,
+      {
+        limit: options?.limit,
+        offset: options?.offset
+      }
+    );
+    return result.data;
+  }
   /**
    * Cancel a pending or active job
    *
@@ -3244,6 +3338,106 @@ var WebhooksResource = class {
     const all = await this.list();
     return all.data.filter((w) => w.event === event);
   }
+  /**
+   * Rotate webhook secret
+   * Rotates the secret while keeping the old one valid during grace period
+   *
+   * @example
+   * ```ts
+   * const result = await client.webhooks.rotateSecret("webhook_abc123", {
+   *   newSecret: "new-secure-secret-key",
+   *   gracePeriodHours: 24
+   * });
+   * console.log(result.secretVersion);
+   * console.log(result.previousSecretValidUntil);
+   * ```
+   */
+  async rotateSecret(webhookId, options) {
+    if (!webhookId || !webhookId.trim()) {
+      throw new Error("webhookId is required and cannot be empty");
+    }
+    if (!options.newSecret || options.newSecret.length < 16) {
+      throw new Error("newSecret must be at least 16 characters long");
+    }
+    const result = await post(
+      this.ctx,
+      `/v1/webhooks/${webhookId}/rotate`,
+      {
+        newSecret: options.newSecret,
+        gracePeriodHours: options.gracePeriodHours ?? 24
+      }
+    );
+    return result.data;
+  }
+  /**
+   * Get webhook secret rotation status
+   * Check current secret version and grace period status
+   *
+   * @example
+   * ```ts
+   * const status = await client.webhooks.getSecretStatus("webhook_abc123");
+   * console.log(status.secretVersion);
+   * if (status.gracePeriod?.active) {
+   *   console.log(`Grace period expires: ${status.gracePeriod.expiresAt}`);
+   * }
+   * ```
+   */
+  async getSecretStatus(webhookId) {
+    if (!webhookId || !webhookId.trim()) {
+      throw new Error("webhookId is required and cannot be empty");
+    }
+    const result = await get(
+      this.ctx,
+      `/v1/webhooks/${webhookId}/secret-status`
+    );
+    return result.data;
+  }
+  /**
+   * Verify webhook signature and replay protection
+   * Validates signature, timestamp, and nonce from received webhook
+   *
+   * @example
+   * ```ts
+   * const isValid = await client.webhooks.verifySignature({
+   *   webhookId: "webhook_abc123",
+   *   payload: receivedPayload,
+   *   signature: headers["x-dealcrawl-signature"],
+   *   timestamp: parseInt(headers["x-dealcrawl-timestamp"]),
+   *   nonce: headers["x-dealcrawl-nonce"]
+   * });
+   * if (isValid.valid) {
+   *   console.log("Webhook is valid");
+   * } else {
+   *   console.log(`Invalid: ${isValid.error}`);
+   * }
+   * ```
+   */
+  async verifySignature(options) {
+    if (!options.webhookId || !options.webhookId.trim()) {
+      throw new Error("webhookId is required and cannot be empty");
+    }
+    if (!options.signature) {
+      throw new Error("signature is required");
+    }
+    if (!options.timestamp || options.timestamp <= 0) {
+      throw new Error("timestamp is required and must be positive");
+    }
+    if (!options.nonce || !/^[0-9a-f]{32}$/i.test(options.nonce)) {
+      throw new Error("nonce must be a 32-character hex string");
+    }
+    const result = await post(
+      this.ctx,
+      "/v1/webhooks/verify",
+      {
+        webhookId: options.webhookId,
+        payload: options.payload,
+        signature: options.signature,
+        timestamp: options.timestamp,
+        nonce: options.nonce
+      }
+    );
+    return result.data;
+  }
 };
 
 // src/client.ts