langwatch 0.24.0 → 0.26.0

package/dist/chunk-OO7FCQAD.mjs

@@ -0,0 +1,663 @@
+import {
+  createTracingProxy
+} from "./chunk-FG3JQBJB.mjs";
+import {
+  getLangWatchTracer
+} from "./chunk-43STSE3B.mjs";
+import {
+  buildAuthHeaders
+} from "./chunk-CBEZY3YS.mjs";
+import {
+  LANGWATCH_SDK_NAME_CLIENT,
+  LANGWATCH_SDK_VERSION
+} from "./chunk-WNPVTJDB.mjs";
+import {
+  formatApiErrorMessage
+} from "./chunk-J3KM7ZO7.mjs";
+import {
+  __privateAdd,
+  __privateGet,
+  __privateSet
+} from "./chunk-URTD2WOC.mjs";
+
+// src/client-sdk/services/datasets/errors.ts
+var DatasetError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DatasetError";
+  }
+};
+var DatasetNotFoundError = class extends DatasetError {
+  constructor(slugOrId) {
+    super(`Dataset not found: ${slugOrId}`);
+    this.name = "DatasetNotFoundError";
+  }
+};
+var DatasetApiError = class extends DatasetError {
+  constructor(message, status, operation, originalError) {
+    super(message);
+    this.name = "DatasetApiError";
+    this.status = status;
+    this.operation = operation;
+    this.originalError = originalError;
+  }
+};
+var DatasetValidationError = class extends DatasetError {
+  constructor(message) {
+    super(message);
+    this.name = "DatasetValidationError";
+  }
+};
+var DatasetPlanLimitError = class extends DatasetError {
+  constructor(message, originalError) {
+    super(message);
+    this.name = "DatasetPlanLimitError";
+    if (originalError != null && typeof originalError === "object") {
+      const err = originalError;
+      this.limitType = typeof err.limitType === "string" ? err.limitType : "datasets";
+      this.current = typeof err.current === "number" ? err.current : void 0;
+      this.max = typeof err.max === "number" ? err.max : void 0;
+    } else {
+      this.limitType = "datasets";
+    }
+  }
+};
+
+// src/client-sdk/services/datasets/tracing/tracer.ts
+var tracer = getLangWatchTracer(`${LANGWATCH_SDK_NAME_CLIENT}.datasets`, LANGWATCH_SDK_VERSION);
+
+// src/client-sdk/services/datasets/dataset.service.ts
+var DatasetService = class {
+  constructor(config) {
+    this.config = config;
+    return createTracingProxy(this, tracer);
+  }
+  /**
+   * Handles API errors by mapping status codes to appropriate error types.
+   * @param operation - Description of the operation being performed
+   * @param error - The error object from the API response
+   * @param status - The HTTP status code
+   * @param slugOrId - The dataset identifier (only passed for operations targeting an existing resource)
+   */
+  handleApiError(operation, error, status, slugOrId) {
+    if (status === 404 && slugOrId) {
+      throw new DatasetNotFoundError(slugOrId);
+    }
+    if (status === 403) {
+      const errorMessage2 = this.extractErrorMessage(error, status);
+      throw new DatasetPlanLimitError(errorMessage2, error);
+    }
+    const errorMessage = this.extractErrorMessage(error, status);
+    throw new DatasetApiError(
+      `Failed to ${operation}: ${errorMessage}`,
+      status,
+      operation,
+      error
+    );
+  }
+  /**
+   * Extracts a human-readable error message from an API error response.
+   */
+  extractErrorMessage(error, status) {
+    return formatApiErrorMessage({ error, options: { status } });
+  }
+  /**
+   * Wrapper for API calls to endpoints not yet in the generated OpenAPI types.
+   * Quarantines `as any` casts to a single location.
+   */
+  untypedRequest(method, path, options) {
+    return this.config.langwatchApiClient[method](path, options);
+  }
+  /**
+   * Unwraps an API response, throwing a mapped error if the response contains an error.
+   * Centralizes the repeated `if (error) handleApiError; return data` pattern.
+   */
+  unwrapResponse(response, operation, slugOrId) {
+    if (response.error) {
+      this.handleApiError(operation, response.error, response.response.status, slugOrId);
+    }
+    return response.data;
+  }
+  /**
+   * Fetches a dataset by its slug or ID, returning metadata and entries.
+   *
+   * @param slugOrId - The slug or ID of the dataset
+   * @param _options - Optional configuration
+   * @returns The dataset with metadata and entries
+   */
+  async getDataset(slugOrId, _options) {
+    this.config.logger.debug(`Fetching dataset: ${slugOrId}`);
+    const response = await this.config.langwatchApiClient.GET(
+      "/api/dataset/{slugOrId}",
+      {
+        params: {
+          path: {
+            slugOrId
+          }
+        }
+      }
+    );
+    const data = this.unwrapResponse(
+      response,
+      `fetch dataset "${slugOrId}"`,
+      slugOrId
+    );
+    const entries = data.data.map((item) => ({
+      id: item.id,
+      datasetId: item.datasetId,
+      projectId: item.projectId,
+      entry: item.entry,
+      createdAt: item.createdAt,
+      updatedAt: item.updatedAt
+    }));
+    this.config.logger.debug(
+      `Fetched dataset ${slugOrId} with ${entries.length} entries`
+    );
+    return {
+      id: data.id,
+      name: data.name,
+      slug: data.slug,
+      columnTypes: data.columnTypes,
+      createdAt: data.createdAt,
+      updatedAt: data.updatedAt,
+      entries
+    };
+  }
+  /**
+   * Lists all datasets for the project, with optional pagination.
+   */
+  async listDatasets(options) {
+    this.config.logger.debug("Listing datasets");
+    const response = await this.untypedRequest("GET", "/api/dataset", {
+      params: {
+        query: {
+          page: options == null ? void 0 : options.page,
+          limit: options == null ? void 0 : options.limit
+        }
+      }
+    });
+    return this.unwrapResponse(
+      response,
+      "list datasets"
+    );
+  }
+  /**
+   * Creates a new dataset.
+   */
+  async createDataset(options) {
+    var _a;
+    this.config.logger.debug(`Creating dataset: ${options.name}`);
+    const response = await this.untypedRequest("POST", "/api/dataset", {
+      body: {
+        name: options.name,
+        columnTypes: (_a = options.columnTypes) != null ? _a : []
+      }
+    });
+    return this.unwrapResponse(
+      response,
+      `create dataset "${options.name}"`
+    );
+  }
+  /**
+   * Updates a dataset by its slug or ID.
+   */
+  async updateDataset(slugOrId, options) {
+    this.config.logger.debug(`Updating dataset: ${slugOrId}`);
+    const response = await this.untypedRequest("PATCH", "/api/dataset/{slugOrId}", {
+      params: {
+        path: { slugOrId }
+      },
+      body: options
+    });
+    return this.unwrapResponse(
+      response,
+      `update dataset "${slugOrId}"`,
+      slugOrId
+    );
+  }
+  /**
+   * Deletes (archives) a dataset by its slug or ID.
+   */
+  async deleteDataset(slugOrId) {
+    this.config.logger.debug(`Deleting dataset: ${slugOrId}`);
+    const response = await this.untypedRequest("DELETE", "/api/dataset/{slugOrId}", {
+      params: {
+        path: { slugOrId }
+      }
+    });
+    return this.unwrapResponse(
+      response,
+      `delete dataset "${slugOrId}"`,
+      slugOrId
+    );
+  }
+  /**
+   * Creates records in a dataset in batch.
+   */
+  async createRecords(slugOrId, entries) {
+    this.config.logger.debug(`Creating ${entries.length} records in dataset: ${slugOrId}`);
+    const response = await this.untypedRequest("POST", "/api/dataset/{slugOrId}/records", {
+      params: {
+        path: { slugOrId }
+      },
+      body: { entries }
+    });
+    return this.unwrapResponse(
+      response,
+      `create records in dataset "${slugOrId}"`,
+      slugOrId
+    );
+  }
+  /**
+   * Updates a single record in a dataset.
+   */
+  async updateRecord(slugOrId, recordId, entry) {
+    this.config.logger.debug(`Updating record ${recordId} in dataset: ${slugOrId}`);
+    const response = await this.untypedRequest("PATCH", "/api/dataset/{slugOrId}/records/{recordId}", {
+      params: {
+        path: { slugOrId, recordId }
+      },
+      body: { entry }
+    });
+    return this.unwrapResponse(
+      response,
+      `update record "${recordId}" in dataset "${slugOrId}"`,
+      slugOrId
+    );
+  }
+  /**
+   * Deletes records from a dataset by IDs.
+   */
+  async deleteRecords(slugOrId, recordIds) {
+    this.config.logger.debug(`Deleting ${recordIds.length} records from dataset: ${slugOrId}`);
+    const response = await this.untypedRequest("DELETE", "/api/dataset/{slugOrId}/records", {
+      params: {
+        path: { slugOrId }
+      },
+      body: { recordIds }
+    });
+    return this.unwrapResponse(
+      response,
+      `delete records from dataset "${slugOrId}"`,
+      slugOrId
+    );
+  }
+  /**
+   * Lists records in a dataset with optional pagination.
+   *
+   * @param slugOrId - The slug or ID of the dataset
+   * @param options - Pagination options (page, limit)
+   * @returns Paginated list of records
+   */
+  async listRecords(slugOrId, options) {
+    this.config.logger.debug(`Listing records for dataset: ${slugOrId}`);
+    const response = await this.untypedRequest("GET", "/api/dataset/{slugOrId}/records", {
+      params: {
+        path: { slugOrId },
+        query: {
+          page: options == null ? void 0 : options.page,
+          limit: options == null ? void 0 : options.limit
+        }
+      }
+    });
+    return this.unwrapResponse(
+      response,
+      `list records in dataset "${slugOrId}"`,
+      slugOrId
+    );
+  }
+  /**
+   * Sends a multipart/form-data request using raw fetch.
+   * openapi-fetch hardcodes content-type: application/json, so file uploads
+   * must bypass it. This helper centralizes URL building, auth headers,
+   * error parsing, and response unwrapping.
+   *
+   * @param path - The API path (appended to the endpoint)
+   * @param formData - The FormData payload
+   * @param operation - Human-readable operation name for error messages
+   * @param slugOrId - Optional dataset identifier (passed to handleApiError for 404 mapping)
+   */
+  async fetchMultipart(path, formData, operation, slugOrId) {
+    const { endpoint, apiKey } = this.config;
+    const url = `${endpoint.replace(/\/$/, "")}${path}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: buildAuthHeaders({ apiKey }),
+      body: formData
+    });
+    if (!response.ok) {
+      const rawBody = await response.text();
+      let errorBody = rawBody;
+      if (rawBody) {
+        try {
+          errorBody = JSON.parse(rawBody);
+        } catch (e) {
+        }
+      }
+      this.handleApiError(operation, errorBody, response.status, slugOrId);
+    }
+    return await response.json();
+  }
+  /**
+   * Creates a new dataset from a file upload.
+   *
+   * @param options - The dataset name and file to upload
+   * @returns The created dataset metadata with record count
+   */
+  async createDatasetFromUpload(options) {
+    this.config.logger.debug(`Creating dataset from upload: ${options.name}`);
+    const formData = new FormData();
+    formData.append("name", options.name);
+    formData.append("file", options.file);
+    return this.fetchMultipart(
+      "/api/dataset/upload",
+      formData,
+      `create dataset from upload "${options.name}"`
+    );
+  }
+  /**
+   * Uploads a file with a strategy for handling existing datasets.
+   *
+   * @param slugOrId - The slug or ID of the dataset
+   * @param file - The file to upload (File or Blob)
+   * @param ifExists - Strategy when dataset exists: "append" (default), "replace", or "error"
+   * @returns The upload result
+   */
+  async uploadWithStrategy(slugOrId, file, ifExists = "append") {
+    switch (ifExists) {
+      case "append":
+        return this._uploadAppend(slugOrId, file);
+      case "replace":
+        return this._uploadReplace(slugOrId, file);
+      case "error":
+        return this._uploadError(slugOrId, file);
+    }
+  }
+  /**
+   * Converts a CreateFromUploadResponse to the unified UploadResponse shape.
+   */
+  toUploadResponse(result) {
+    return {
+      dataset: {
+        id: result.id,
+        name: result.name,
+        slug: result.slug,
+        columnTypes: result.columnTypes,
+        createdAt: result.createdAt,
+        updatedAt: result.updatedAt
+      },
+      recordsCreated: result.recordsCreated,
+      datasetId: result.id
+    };
+  }
+  /**
+   * Append strategy: try uploading to existing dataset; if not found, create from file.
+   */
+  async _uploadAppend(slugOrId, file) {
+    try {
+      return await this.uploadFile(slugOrId, file);
+    } catch (error) {
+      if (error instanceof DatasetNotFoundError) {
+        return this.toUploadResponse(await this.createDatasetFromUpload({ name: slugOrId, file }));
+      }
+      throw error;
+    }
+  }
+  /**
+   * Replace strategy: if dataset exists, delete all records then upload; if not found, create from file.
+   */
+  async _uploadReplace(slugOrId, file) {
+    try {
+      await this.getDataset(slugOrId);
+      await this._deleteAllRecords(slugOrId);
+      return await this.uploadFile(slugOrId, file);
+    } catch (error) {
+      if (error instanceof DatasetNotFoundError) {
+        return this.toUploadResponse(await this.createDatasetFromUpload({ name: slugOrId, file }));
+      }
+      throw error;
+    }
+  }
+  /**
+   * Error strategy: if dataset exists, throw 409; if not found, create from file.
+   */
+  async _uploadError(slugOrId, file) {
+    let datasetExists = false;
+    try {
+      await this.getDataset(slugOrId);
+      datasetExists = true;
+    } catch (error) {
+      if (!(error instanceof DatasetNotFoundError)) {
+        throw error;
+      }
+    }
+    if (datasetExists) {
+      throw new DatasetApiError(
+        `Dataset already exists: ${slugOrId}`,
+        409,
+        "upload"
+      );
+    }
+    return this.toUploadResponse(await this.createDatasetFromUpload({ name: slugOrId, file }));
+  }
+  /**
+   * Deletes all records from a dataset by iterating through pages.
+   * Always fetches page 1 since records shift after deletion.
+   * Includes a safety valve to prevent infinite loops.
+   */
+  async _deleteAllRecords(slugOrId) {
+    const BATCH_SIZE = 1e3;
+    const MAX_DELETE_ITERATIONS = 100;
+    let iteration = 0;
+    while (iteration < MAX_DELETE_ITERATIONS) {
+      const page = await this.listRecords(slugOrId, { page: 1, limit: BATCH_SIZE });
+      if (page.data.length === 0) {
+        return;
+      }
+      const ids = page.data.map((record) => record.id);
+      await this.deleteRecords(slugOrId, ids);
+      iteration++;
+    }
+    throw new DatasetApiError(
+      `Failed to delete all records from dataset "${slugOrId}": exceeded ${MAX_DELETE_ITERATIONS} iterations`,
+      0,
+      `delete all records from dataset "${slugOrId}"`
+    );
+  }
+  /**
+   * Uploads a file to an existing dataset.
+   */
+  async uploadFile(slugOrId, file) {
+    this.config.logger.debug(`Uploading file to dataset: ${slugOrId}`);
+    const formData = new FormData();
+    formData.append("file", file);
+    return this.fetchMultipart(
+      `/api/dataset/${encodeURIComponent(slugOrId)}/upload`,
+      formData,
+      `upload file to dataset "${slugOrId}"`,
+      slugOrId
+    );
+  }
+};
+
+// src/client-sdk/services/datasets/datasets.facade.ts
+var _datasetService;
+var DatasetsFacade = class {
+  constructor(config) {
+    __privateAdd(this, _datasetService);
+    /**
+     * Lists all datasets for the project, with optional pagination.
+     *
+     * @param options - Pagination options (page, limit)
+     * @returns Paginated list of datasets with metadata
+     */
+    this.list = (options) => {
+      return __privateGet(this, _datasetService).listDatasets(options);
+    };
+    /**
+     * Creates a new dataset.
+     *
+     * @param options - Dataset creation options (name, columnTypes)
+     * @returns The created dataset metadata
+     */
+    this.create = (options) => {
+      if (!options.name || options.name.trim().length === 0) {
+        throw new DatasetValidationError("Dataset name must not be empty");
+      }
+      return __privateGet(this, _datasetService).createDataset(options);
+    };
+    /**
+     * Fetches a dataset by its slug or ID, returning metadata and entries.
+     *
+     * @param slugOrId - The slug or ID of the dataset to fetch
+     * @param options - Optional configuration
+     * @returns The dataset with metadata and entries
+     *
+     * @example
+     * ```typescript
+     * // Get dataset by slug
+     * const dataset = await langwatch.datasets.get("product-qa");
+     *
+     * // Typed dataset
+     * type MyDatasetEntry = { input: string; expected_output: string; };
+     * const dataset = await langwatch.datasets.get<MyDatasetEntry>("my-dataset");
+     *
+     * // Iterate over entries
+     * for (const entry of dataset.entries) {
+     *   console.log(entry.entry.input);
+     * }
+     * ```
+     */
+    this.get = (slugOrId, options) => {
+      return __privateGet(this, _datasetService).getDataset(slugOrId, options);
+    };
+    /**
+     * Updates a dataset by its slug or ID.
+     *
+     * @param slugOrId - The slug or ID of the dataset to update
+     * @param options - Fields to update (name, columnTypes)
+     * @returns The updated dataset metadata
+     */
+    this.update = (slugOrId, options) => {
+      if (options.name == null && options.columnTypes == null) {
+        throw new DatasetValidationError(
+          "At least one field (name or columnTypes) must be provided for update"
+        );
+      }
+      return __privateGet(this, _datasetService).updateDataset(slugOrId, options);
+    };
+    /**
+     * Deletes (archives) a dataset by its slug or ID.
+     *
+     * @param slugOrId - The slug or ID of the dataset to delete
+     * @returns The archived dataset metadata
+     */
+    this.delete = (slugOrId) => {
+      return __privateGet(this, _datasetService).deleteDataset(slugOrId);
+    };
+    /**
+     * Creates records in a dataset in batch.
+     *
+     * @param slugOrId - The slug or ID of the dataset
+     * @param entries - Array of record entries to create
+     * @returns The created records with IDs
+     */
+    this.createRecords = (slugOrId, entries) => {
+      if (!entries || entries.length === 0) {
+        throw new DatasetValidationError("Entries must not be empty");
+      }
+      return __privateGet(this, _datasetService).createRecords(slugOrId, entries);
+    };
+    /**
+     * Updates a single record in a dataset.
+     *
+     * @param slugOrId - The slug or ID of the dataset
+     * @param recordId - The ID of the record to update
+     * @param entry - The updated entry data
+     * @returns The updated record
+     */
+    this.updateRecord = (slugOrId, recordId, entry) => {
+      return __privateGet(this, _datasetService).updateRecord(slugOrId, recordId, entry);
+    };
+    /**
+     * Deletes records from a dataset by IDs.
+     *
+     * @param slugOrId - The slug or ID of the dataset
+     * @param recordIds - Array of record IDs to delete
+     * @returns Object with the count of deleted records
+     */
+    this.deleteRecords = (slugOrId, recordIds) => {
+      return __privateGet(this, _datasetService).deleteRecords(slugOrId, recordIds);
+    };
+    /**
+     * Lists records in a dataset with optional pagination.
+     *
+     * @param slugOrId - The slug or ID of the dataset
+     * @param options - Pagination options (page, limit)
+     * @returns Paginated list of records
+     *
+     * @example
+     * ```typescript
+     * // List first page of records
+     * const result = await langwatch.datasets.listRecords("my-dataset");
+     *
+     * // With pagination
+     * const page2 = await langwatch.datasets.listRecords("my-dataset", { page: 2, limit: 25 });
+     * ```
+     */
+    this.listRecords = (slugOrId, options) => {
+      return __privateGet(this, _datasetService).listRecords(slugOrId, options);
+    };
+    /**
+     * Uploads a file to a dataset with a configurable strategy for handling existing datasets.
+     *
+     * Strategies:
+     * - `"append"` (default): Upload to existing dataset; if not found, create a new one.
+     * - `"replace"`: Delete all existing records, then upload; if not found, create a new one.
+     * - `"error"`: Throw a 409 error if the dataset already exists; if not found, create a new one.
+     *
+     * @param slugOrId - The slug or ID of the dataset
+     * @param file - The file to upload (File or Blob)
+     * @param options - Upload options including the ifExists strategy
+     * @returns The upload result
+     *
+     * @example
+     * ```typescript
+     * const file = new File(["input,output\nhello,world"], "data.csv", { type: "text/csv" });
+     *
+     * // Append to existing or create new
+     * await langwatch.datasets.upload("my-dataset", file);
+     *
+     * // Replace all records
+     * await langwatch.datasets.upload("my-dataset", file, { ifExists: "replace" });
+     *
+     * // Fail if dataset already exists
+     * await langwatch.datasets.upload("my-dataset", file, { ifExists: "error" });
+     * ```
+     */
+    this.upload = (slugOrId, file, options) => {
+      var _a;
+      if (!file) {
+        throw new DatasetValidationError("File must be provided for upload");
+      }
+      return __privateGet(this, _datasetService).uploadWithStrategy(
+        slugOrId,
+        file,
+        (_a = options == null ? void 0 : options.ifExists) != null ? _a : "append"
+      );
+    };
+    __privateSet(this, _datasetService, new DatasetService(config));
+  }
+};
+_datasetService = new WeakMap();
+
+export {
+  DatasetError,
+  DatasetNotFoundError,
+  DatasetApiError,
+  DatasetValidationError,
+  DatasetPlanLimitError,
+  DatasetService,
+  DatasetsFacade
+};
+//# sourceMappingURL=chunk-OO7FCQAD.mjs.map