@stack0/sdk 0.2.0 → 0.2.1

package/dist/webdata/index.mjs

@@ -0,0 +1,691 @@
+// src/lib/http-client.ts
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || "https://api.stack0.com/v1";
+  }
+  getHeaders() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  async request(method, path, body) {
+    const url = `${this.baseUrl}${path}`;
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: this.getHeaders(),
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        await this.handleErrorResponse(response);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      if (error instanceof Error && "statusCode" in error) {
+        throw error;
+      }
+      throw this.createError("Network error", error);
+    }
+  }
+  async handleErrorResponse(response) {
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+      errorBody = { message: response.statusText };
+    }
+    const error = new Error(errorBody?.message || `HTTP ${response.status}`);
+    error.statusCode = response.status;
+    error.code = errorBody?.code ?? "";
+    error.response = errorBody;
+    throw error;
+  }
+  createError(message, cause) {
+    const error = new Error(message);
+    error.cause = cause;
+    return error;
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+};
+
+// src/webdata/client.ts
+var Webdata = class {
+  http;
+  constructor(config) {
+    this.http = new HttpClient(config);
+  }
+  // ==========================================================================
+  // SCREENSHOTS
+  // ==========================================================================
+  /**
+   * Capture a screenshot of a URL
+   *
+   * @example
+   * ```typescript
+   * const { id, status } = await webdata.screenshot({
+   *   url: 'https://example.com',
+   *   format: 'png',
+   *   fullPage: true,
+   *   deviceType: 'desktop',
+   * });
+   *
+   * // Poll for completion
+   * const screenshot = await webdata.getScreenshot({ id });
+   * console.log(screenshot.imageUrl);
+   * ```
+   */
+  async screenshot(request) {
+    return this.http.post("/webdata/screenshots", request);
+  }
+  /**
+   * Get a screenshot by ID
+   *
+   * @example
+   * ```typescript
+   * const screenshot = await webdata.getScreenshot({ id: 'screenshot-id' });
+   * if (screenshot.status === 'completed') {
+   *   console.log(screenshot.imageUrl);
+   * }
+   * ```
+   */
+  async getScreenshot(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    const path = `/webdata/screenshots/${request.id}${query ? `?${query}` : ""}`;
+    const response = await this.http.get(path);
+    return this.convertScreenshotDates(response);
+  }
+  /**
+   * List screenshots with pagination and filters
+   *
+   * @example
+   * ```typescript
+   * const { items, nextCursor } = await webdata.listScreenshots({
+   *   status: 'completed',
+   *   limit: 20,
+   * });
+   * ```
+   */
+  async listScreenshots(request = {}) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    if (request.status) params.set("status", request.status);
+    if (request.url) params.set("url", request.url);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.cursor) params.set("cursor", request.cursor);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/webdata/screenshots${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      items: response.items.map((item) => this.convertScreenshotDates(item))
+    };
+  }
+  /**
+   * Delete a screenshot
+   *
+   * @example
+   * ```typescript
+   * await webdata.deleteScreenshot({ id: 'screenshot-id' });
+   * ```
+   */
+  async deleteScreenshot(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    return this.http.delete(
+      `/webdata/screenshots/${request.id}${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * Capture a screenshot and wait for completion
+   *
+   * @example
+   * ```typescript
+   * const screenshot = await webdata.screenshotAndWait({
+   *   url: 'https://example.com',
+   *   format: 'png',
+   * });
+   * console.log(screenshot.imageUrl);
+   * ```
+   */
+  async screenshotAndWait(request, options = {}) {
+    const { pollInterval = 1e3, timeout = 6e4 } = options;
+    const startTime = Date.now();
+    const { id } = await this.screenshot(request);
+    while (Date.now() - startTime < timeout) {
+      const screenshot = await this.getScreenshot({
+        id,
+        environment: request.environment,
+        projectId: request.projectId
+      });
+      if (screenshot.status === "completed" || screenshot.status === "failed") {
+        if (screenshot.status === "failed") {
+          throw new Error(screenshot.error || "Screenshot failed");
+        }
+        return screenshot;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error("Screenshot timed out");
+  }
+  // ==========================================================================
+  // EXTRACTIONS
+  // ==========================================================================
+  /**
+   * Extract content from a URL
+   *
+   * @example
+   * ```typescript
+   * const { id, status } = await webdata.extract({
+   *   url: 'https://example.com/article',
+   *   mode: 'markdown',
+   *   includeMetadata: true,
+   * });
+   *
+   * // Poll for completion
+   * const extraction = await webdata.getExtraction({ id });
+   * console.log(extraction.markdown);
+   * ```
+   */
+  async extract(request) {
+    return this.http.post("/webdata/extractions", request);
+  }
+  /**
+   * Get an extraction by ID
+   *
+   * @example
+   * ```typescript
+   * const extraction = await webdata.getExtraction({ id: 'extraction-id' });
+   * if (extraction.status === 'completed') {
+   *   console.log(extraction.markdown);
+   *   console.log(extraction.pageMetadata);
+   * }
+   * ```
+   */
+  async getExtraction(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    const path = `/webdata/extractions/${request.id}${query ? `?${query}` : ""}`;
+    const response = await this.http.get(path);
+    return this.convertExtractionDates(response);
+  }
+  /**
+   * List extractions with pagination and filters
+   *
+   * @example
+   * ```typescript
+   * const { items, nextCursor } = await webdata.listExtractions({
+   *   status: 'completed',
+   *   limit: 20,
+   * });
+   * ```
+   */
+  async listExtractions(request = {}) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    if (request.status) params.set("status", request.status);
+    if (request.url) params.set("url", request.url);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.cursor) params.set("cursor", request.cursor);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/webdata/extractions${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      items: response.items.map((item) => this.convertExtractionDates(item))
+    };
+  }
+  /**
+   * Delete an extraction
+   *
+   * @example
+   * ```typescript
+   * await webdata.deleteExtraction({ id: 'extraction-id' });
+   * ```
+   */
+  async deleteExtraction(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    return this.http.delete(
+      `/webdata/extractions/${request.id}${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * Extract content and wait for completion
+   *
+   * @example
+   * ```typescript
+   * const extraction = await webdata.extractAndWait({
+   *   url: 'https://example.com/article',
+   *   mode: 'markdown',
+   * });
+   * console.log(extraction.markdown);
+   * ```
+   */
+  async extractAndWait(request, options = {}) {
+    const { pollInterval = 1e3, timeout = 6e4 } = options;
+    const startTime = Date.now();
+    const { id } = await this.extract(request);
+    while (Date.now() - startTime < timeout) {
+      const extraction = await this.getExtraction({
+        id,
+        environment: request.environment,
+        projectId: request.projectId
+      });
+      if (extraction.status === "completed" || extraction.status === "failed") {
+        if (extraction.status === "failed") {
+          throw new Error(extraction.error || "Extraction failed");
+        }
+        return extraction;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error("Extraction timed out");
+  }
+  // ==========================================================================
+  // SCHEDULES
+  // ==========================================================================
+  /**
+   * Create a scheduled screenshot or extraction job
+   *
+   * @example
+   * ```typescript
+   * const { id } = await webdata.createSchedule({
+   *   name: 'Daily homepage screenshot',
+   *   url: 'https://example.com',
+   *   type: 'screenshot',
+   *   frequency: 'daily',
+   *   config: { format: 'png', fullPage: true },
+   * });
+   * ```
+   */
+  async createSchedule(request) {
+    return this.http.post("/webdata/schedules", request);
+  }
+  /**
+   * Update a schedule
+   *
+   * @example
+   * ```typescript
+   * await webdata.updateSchedule({
+   *   id: 'schedule-id',
+   *   frequency: 'weekly',
+   *   isActive: false,
+   * });
+   * ```
+   */
+  async updateSchedule(request) {
+    const { id, environment, projectId, ...data } = request;
+    const params = new URLSearchParams();
+    if (environment) params.set("environment", environment);
+    if (projectId) params.set("projectId", projectId);
+    const query = params.toString();
+    return this.http.post(
+      `/webdata/schedules/${id}${query ? `?${query}` : ""}`,
+      data
+    );
+  }
+  /**
+   * Get a schedule by ID
+   *
+   * @example
+   * ```typescript
+   * const schedule = await webdata.getSchedule({ id: 'schedule-id' });
+   * console.log(schedule.nextRunAt);
+   * ```
+   */
+  async getSchedule(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    const path = `/webdata/schedules/${request.id}${query ? `?${query}` : ""}`;
+    const response = await this.http.get(path);
+    return this.convertScheduleDates(response);
+  }
+  /**
+   * List schedules with pagination and filters
+   *
+   * @example
+   * ```typescript
+   * const { items, nextCursor } = await webdata.listSchedules({
+   *   type: 'screenshot',
+   *   isActive: true,
+   * });
+   * ```
+   */
+  async listSchedules(request = {}) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    if (request.type) params.set("type", request.type);
+    if (request.isActive !== void 0) params.set("isActive", request.isActive.toString());
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.cursor) params.set("cursor", request.cursor);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/webdata/schedules${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      items: response.items.map((item) => this.convertScheduleDates(item))
+    };
+  }
+  /**
+   * Delete a schedule
+   *
+   * @example
+   * ```typescript
+   * await webdata.deleteSchedule({ id: 'schedule-id' });
+   * ```
+   */
+  async deleteSchedule(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    return this.http.delete(
+      `/webdata/schedules/${request.id}${query ? `?${query}` : ""}`
+    );
+  }
+  /**
+   * Toggle a schedule on or off
+   *
+   * @example
+   * ```typescript
+   * const { isActive } = await webdata.toggleSchedule({ id: 'schedule-id' });
+   * console.log(`Schedule is now ${isActive ? 'active' : 'paused'}`);
+   * ```
+   */
+  async toggleSchedule(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    return this.http.post(
+      `/webdata/schedules/${request.id}/toggle${query ? `?${query}` : ""}`,
+      {}
+    );
+  }
+  // ==========================================================================
+  // USAGE
+  // ==========================================================================
+  /**
+   * Get usage statistics
+   *
+   * @example
+   * ```typescript
+   * const usage = await webdata.getUsage({
+   *   periodStart: '2024-01-01T00:00:00Z',
+   *   periodEnd: '2024-01-31T23:59:59Z',
+   * });
+   * console.log(`Screenshots: ${usage.screenshotsTotal}`);
+   * console.log(`Extractions: ${usage.extractionsTotal}`);
+   * ```
+   */
+  async getUsage(request = {}) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.periodStart) params.set("periodStart", request.periodStart);
+    if (request.periodEnd) params.set("periodEnd", request.periodEnd);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/webdata/usage${query ? `?${query}` : ""}`
+    );
+    return this.convertUsageDates(response);
+  }
+  // ==========================================================================
+  // BATCH JOBS
+  // ==========================================================================
+  /**
+   * Create a batch screenshot job for multiple URLs
+   *
+   * @example
+   * ```typescript
+   * const { id, totalUrls } = await webdata.batchScreenshots({
+   *   urls: [
+   *     'https://example.com',
+   *     'https://example.org',
+   *   ],
+   *   config: { format: 'png', fullPage: true },
+   * });
+   *
+   * // Poll for completion
+   * const job = await webdata.getBatchJob({ id });
+   * console.log(`Progress: ${job.processedUrls}/${job.totalUrls}`);
+   * ```
+   */
+  async batchScreenshots(request) {
+    return this.http.post("/webdata/batch/screenshots", request);
+  }
+  /**
+   * Create a batch extraction job for multiple URLs
+   *
+   * @example
+   * ```typescript
+   * const { id, totalUrls } = await webdata.batchExtractions({
+   *   urls: [
+   *     'https://example.com/article1',
+   *     'https://example.com/article2',
+   *   ],
+   *   config: { mode: 'markdown' },
+   * });
+   * ```
+   */
+  async batchExtractions(request) {
+    return this.http.post("/webdata/batch/extractions", request);
+  }
+  /**
+   * Get a batch job by ID
+   *
+   * @example
+   * ```typescript
+   * const job = await webdata.getBatchJob({ id: 'batch-id' });
+   * console.log(`Status: ${job.status}`);
+   * console.log(`Progress: ${job.processedUrls}/${job.totalUrls}`);
+   * ```
+   */
+  async getBatchJob(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    const path = `/webdata/batch/${request.id}${query ? `?${query}` : ""}`;
+    const response = await this.http.get(path);
+    return this.convertBatchJobDates(response);
+  }
+  /**
+   * List batch jobs with pagination and filters
+   *
+   * @example
+   * ```typescript
+   * const { items, nextCursor } = await webdata.listBatchJobs({
+   *   status: 'completed',
+   *   type: 'screenshot',
+   *   limit: 20,
+   * });
+   * ```
+   */
+  async listBatchJobs(request = {}) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    if (request.status) params.set("status", request.status);
+    if (request.type) params.set("type", request.type);
+    if (request.limit) params.set("limit", request.limit.toString());
+    if (request.cursor) params.set("cursor", request.cursor);
+    const query = params.toString();
+    const response = await this.http.get(
+      `/webdata/batch${query ? `?${query}` : ""}`
+    );
+    return {
+      ...response,
+      items: response.items.map((item) => this.convertBatchJobDates(item))
+    };
+  }
+  /**
+   * Cancel a batch job
+   *
+   * @example
+   * ```typescript
+   * await webdata.cancelBatchJob({ id: 'batch-id' });
+   * ```
+   */
+  async cancelBatchJob(request) {
+    const params = new URLSearchParams();
+    if (request.environment) params.set("environment", request.environment);
+    if (request.projectId) params.set("projectId", request.projectId);
+    const query = params.toString();
+    return this.http.post(
+      `/webdata/batch/${request.id}/cancel${query ? `?${query}` : ""}`,
+      {}
+    );
+  }
+  /**
+   * Create a batch screenshot job and wait for completion
+   *
+   * @example
+   * ```typescript
+   * const job = await webdata.batchScreenshotsAndWait({
+   *   urls: ['https://example.com', 'https://example.org'],
+   *   config: { format: 'png' },
+   * });
+   * console.log(`Completed: ${job.successfulUrls} successful, ${job.failedUrls} failed`);
+   * ```
+   */
+  async batchScreenshotsAndWait(request, options = {}) {
+    const { pollInterval = 2e3, timeout = 3e5 } = options;
+    const startTime = Date.now();
+    const { id } = await this.batchScreenshots(request);
+    while (Date.now() - startTime < timeout) {
+      const job = await this.getBatchJob({
+        id,
+        environment: request.environment,
+        projectId: request.projectId
+      });
+      if (job.status === "completed" || job.status === "failed" || job.status === "cancelled") {
+        return job;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error("Batch job timed out");
+  }
+  /**
+   * Create a batch extraction job and wait for completion
+   *
+   * @example
+   * ```typescript
+   * const job = await webdata.batchExtractionsAndWait({
+   *   urls: ['https://example.com/article1', 'https://example.com/article2'],
+   *   config: { mode: 'markdown' },
+   * });
+   * console.log(`Completed: ${job.successfulUrls} successful`);
+   * ```
+   */
+  async batchExtractionsAndWait(request, options = {}) {
+    const { pollInterval = 2e3, timeout = 3e5 } = options;
+    const startTime = Date.now();
+    const { id } = await this.batchExtractions(request);
+    while (Date.now() - startTime < timeout) {
+      const job = await this.getBatchJob({
+        id,
+        environment: request.environment,
+        projectId: request.projectId
+      });
+      if (job.status === "completed" || job.status === "failed" || job.status === "cancelled") {
+        return job;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error("Batch job timed out");
+  }
+  // ==========================================================================
+  // HELPERS
+  // ==========================================================================
+  convertScreenshotDates(screenshot) {
+    if (typeof screenshot.createdAt === "string") {
+      screenshot.createdAt = new Date(screenshot.createdAt);
+    }
+    if (screenshot.completedAt && typeof screenshot.completedAt === "string") {
+      screenshot.completedAt = new Date(screenshot.completedAt);
+    }
+    return screenshot;
+  }
+  convertExtractionDates(extraction) {
+    if (typeof extraction.createdAt === "string") {
+      extraction.createdAt = new Date(extraction.createdAt);
+    }
+    if (extraction.completedAt && typeof extraction.completedAt === "string") {
+      extraction.completedAt = new Date(extraction.completedAt);
+    }
+    return extraction;
+  }
+  convertScheduleDates(schedule) {
+    if (typeof schedule.createdAt === "string") {
+      schedule.createdAt = new Date(schedule.createdAt);
+    }
+    if (typeof schedule.updatedAt === "string") {
+      schedule.updatedAt = new Date(schedule.updatedAt);
+    }
+    if (schedule.lastRunAt && typeof schedule.lastRunAt === "string") {
+      schedule.lastRunAt = new Date(schedule.lastRunAt);
+    }
+    if (schedule.nextRunAt && typeof schedule.nextRunAt === "string") {
+      schedule.nextRunAt = new Date(schedule.nextRunAt);
+    }
+    return schedule;
+  }
+  convertUsageDates(usage) {
+    if (typeof usage.periodStart === "string") {
+      usage.periodStart = new Date(usage.periodStart);
+    }
+    if (typeof usage.periodEnd === "string") {
+      usage.periodEnd = new Date(usage.periodEnd);
+    }
+    return usage;
+  }
+  convertBatchJobDates(job) {
+    if (typeof job.createdAt === "string") {
+      job.createdAt = new Date(job.createdAt);
+    }
+    if (job.startedAt && typeof job.startedAt === "string") {
+      job.startedAt = new Date(job.startedAt);
+    }
+    if (job.completedAt && typeof job.completedAt === "string") {
+      job.completedAt = new Date(job.completedAt);
+    }
+    return job;
+  }
+};
+
+export { Webdata };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map