@mixedbread/sdk 0.9.3 → 0.10.0

package/src/internal/qs/utils.ts

@@ -0,0 +1,265 @@
+import { RFC1738 } from './formats';
+import type { DefaultEncoder, Format } from './types';
+import { isArray } from '../utils/values';
+
+export let has = (obj: object, key: PropertyKey): boolean => (
+  (has = (Object as any).hasOwn ?? Function.prototype.call.bind(Object.prototype.hasOwnProperty)),
+  has(obj, key)
+);
+
+const hex_table = /* @__PURE__ */ (() => {
+  const array = [];
+  for (let i = 0; i < 256; ++i) {
+    array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
+  }
+
+  return array;
+})();
+
+function compact_queue<T extends Record<string, any>>(queue: Array<{ obj: T; prop: string }>) {
+  while (queue.length > 1) {
+    const item = queue.pop();
+    if (!item) continue;
+
+    const obj = item.obj[item.prop];
+
+    if (isArray(obj)) {
+      const compacted: unknown[] = [];
+
+      for (let j = 0; j < obj.length; ++j) {
+        if (typeof obj[j] !== 'undefined') {
+          compacted.push(obj[j]);
+        }
+      }
+
+      // @ts-ignore
+      item.obj[item.prop] = compacted;
+    }
+  }
+}
+
+function array_to_object(source: any[], options: { plainObjects: boolean }) {
+  const obj = options && options.plainObjects ? Object.create(null) : {};
+  for (let i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== 'undefined') {
+      obj[i] = source[i];
+    }
+  }
+
+  return obj;
+}
+
+export function merge(
+  target: any,
+  source: any,
+  options: { plainObjects?: boolean; allowPrototypes?: boolean } = {},
+) {
+  if (!source) {
+    return target;
+  }
+
+  if (typeof source !== 'object') {
+    if (isArray(target)) {
+      target.push(source);
+    } else if (target && typeof target === 'object') {
+      if ((options && (options.plainObjects || options.allowPrototypes)) || !has(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+
+    return target;
+  }
+
+  if (!target || typeof target !== 'object') {
+    return [target].concat(source);
+  }
+
+  let mergeTarget = target;
+  if (isArray(target) && !isArray(source)) {
+    // @ts-ignore
+    mergeTarget = array_to_object(target, options);
+  }
+
+  if (isArray(target) && isArray(source)) {
+    source.forEach(function (item, i) {
+      if (has(target, i)) {
+        const targetItem = target[i];
+        if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
+          target[i] = merge(targetItem, item, options);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+
+  return Object.keys(source).reduce(function (acc, key) {
+    const value = source[key];
+
+    if (has(acc, key)) {
+      acc[key] = merge(acc[key], value, options);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+}
+
+export function assign_single_source(target: any, source: any) {
+  return Object.keys(source).reduce(function (acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+}
+
+export function decode(str: string, _: any, charset: string) {
+  const strWithoutPlus = str.replace(/\+/g, ' ');
+  if (charset === 'iso-8859-1') {
+    // unescape never throws, no try...catch needed:
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  // utf-8
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e) {
+    return strWithoutPlus;
+  }
+}
+
+const limit = 1024;
+
+export const encode: (
+  str: any,
+  defaultEncoder: DefaultEncoder,
+  charset: string,
+  type: 'key' | 'value',
+  format: Format,
+) => string = (str, _defaultEncoder, charset, _kind, format: Format) => {
+  // This code was originally written by Brian White for the io.js core querystring library.
+  // It has been adapted here for stricter adherence to RFC 3986
+  if (str.length === 0) {
+    return str;
+  }
+
+  let string = str;
+  if (typeof str === 'symbol') {
+    string = Symbol.prototype.toString.call(str);
+  } else if (typeof str !== 'string') {
+    string = String(str);
+  }
+
+  if (charset === 'iso-8859-1') {
+    return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
+      return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
+    });
+  }
+
+  let out = '';
+  for (let j = 0; j < string.length; j += limit) {
+    const segment = string.length >= limit ? string.slice(j, j + limit) : string;
+    const arr = [];
+
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d || // -
+        c === 0x2e || // .
+        c === 0x5f || // _
+        c === 0x7e || // ~
+        (c >= 0x30 && c <= 0x39) || // 0-9
+        (c >= 0x41 && c <= 0x5a) || // a-z
+        (c >= 0x61 && c <= 0x7a) || // A-Z
+        (format === RFC1738 && (c === 0x28 || c === 0x29)) // ( )
+      ) {
+        arr[arr.length] = segment.charAt(i);
+        continue;
+      }
+
+      if (c < 0x80) {
+        arr[arr.length] = hex_table[c];
+        continue;
+      }
+
+      if (c < 0x800) {
+        arr[arr.length] = hex_table[0xc0 | (c >> 6)]! + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      if (c < 0xd800 || c >= 0xe000) {
+        arr[arr.length] =
+          hex_table[0xe0 | (c >> 12)]! + hex_table[0x80 | ((c >> 6) & 0x3f)] + hex_table[0x80 | (c & 0x3f)];
+        continue;
+      }
+
+      i += 1;
+      c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+
+      arr[arr.length] =
+        hex_table[0xf0 | (c >> 18)]! +
+        hex_table[0x80 | ((c >> 12) & 0x3f)] +
+        hex_table[0x80 | ((c >> 6) & 0x3f)] +
+        hex_table[0x80 | (c & 0x3f)];
+    }
+
+    out += arr.join('');
+  }
+
+  return out;
+};
+
+export function compact(value: any) {
+  const queue = [{ obj: { o: value }, prop: 'o' }];
+  const refs = [];
+
+  for (let i = 0; i < queue.length; ++i) {
+    const item = queue[i];
+    // @ts-ignore
+    const obj = item.obj[item.prop];
+
+    const keys = Object.keys(obj);
+    for (let j = 0; j < keys.length; ++j) {
+      const key = keys[j]!;
+      const val = obj[key];
+      if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
+        queue.push({ obj: obj, prop: key });
+        refs.push(val);
+      }
+    }
+  }
+
+  compact_queue(queue);
+
+  return value;
+}
+
+export function is_regexp(obj: any) {
+  return Object.prototype.toString.call(obj) === '[object RegExp]';
+}
+
+export function is_buffer(obj: any) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+}
+
+export function combine(a: any, b: any) {
+  return [].concat(a, b);
+}
+
+export function maybe_map<T>(val: T[], fn: (v: T) => T) {
+  if (isArray(val)) {
+    const mapped = [];
+    for (let i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]!));
+    }
+    return mapped;
+  }
+  return fn(val);
+}

package/src/resources/data-sources/connectors.ts

@@ -2,7 +2,7 @@
 
 import { APIResource } from '../../core/resource';
 import { APIPromise } from '../../core/api-promise';
-import { LimitOffset, type LimitOffsetParams, PagePromise } from '../../core/pagination';
+import { Cursor, type CursorParams, PagePromise } from '../../core/pagination';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
@@ -73,10 +73,10 @@ export class Connectors extends APIResource {
     dataSourceID: string,
     query: ConnectorListParams | null | undefined = {},
     options?: RequestOptions,
-  ): PagePromise<DataSourceConnectorsLimitOffset, DataSourceConnector> {
+  ): PagePromise<DataSourceConnectorsCursor, DataSourceConnector> {
     return this._client.getAPIList(
       path`/v1/data_sources/${dataSourceID}/connectors`,
-      LimitOffset<DataSourceConnector>,
+      Cursor<DataSourceConnector>,
       { query, ...options },
     );
   }
@@ -99,7 +99,7 @@ export class Connectors extends APIResource {
   }
 }
 
-export type DataSourceConnectorsLimitOffset = LimitOffset<DataSourceConnector>;
+export type DataSourceConnectorsCursor = Cursor<DataSourceConnector>;
 
 /**
  * Service-level representation of a connector.
@@ -168,7 +168,7 @@ export interface DataSourceConnector {
   /**
    * The sync error of the connector
    */
-  error: string | null;
+  error: { [key: string]: unknown } | null;
 
   /**
    * The type of the object
@@ -249,7 +249,7 @@ export interface ConnectorUpdateParams {
   /**
    * Body param: The metadata of the connector
    */
-  metadata?: Record<string, unknown> | null;
+  metadata?: { [key: string]: unknown } | null;
 
   /**
    * Body param: Whether the connector should be synced after update
@@ -267,7 +267,7 @@ export interface ConnectorUpdateParams {
   polling_interval?: number | string | null;
 }
 
-export interface ConnectorListParams extends LimitOffsetParams {}
+export interface ConnectorListParams extends CursorParams {}
 
 export interface ConnectorDeleteParams {
   /**
@@ -280,7 +280,7 @@ export declare namespace Connectors {
   export {
     type DataSourceConnector as DataSourceConnector,
     type ConnectorDeleteResponse as ConnectorDeleteResponse,
-    type DataSourceConnectorsLimitOffset as DataSourceConnectorsLimitOffset,
+    type DataSourceConnectorsCursor as DataSourceConnectorsCursor,
     type ConnectorCreateParams as ConnectorCreateParams,
     type ConnectorRetrieveParams as ConnectorRetrieveParams,
     type ConnectorUpdateParams as ConnectorUpdateParams,

package/src/resources/data-sources/data-sources.ts

@@ -11,10 +11,10 @@ import {
   ConnectorUpdateParams,
   Connectors,
   DataSourceConnector,
-  DataSourceConnectorsLimitOffset,
+  DataSourceConnectorsCursor,
 } from './connectors';
 import { APIPromise } from '../../core/api-promise';
-import { LimitOffset, type LimitOffsetParams, PagePromise } from '../../core/pagination';
+import { Cursor, type CursorParams, PagePromise } from '../../core/pagination';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 
@@ -67,8 +67,8 @@ export class DataSources extends APIResource {
   list(
     query: DataSourceListParams | null | undefined = {},
     options?: RequestOptions,
-  ): PagePromise<DataSourcesLimitOffset, DataSource> {
-    return this._client.getAPIList('/v1/data_sources/', LimitOffset<DataSource>, { query, ...options });
+  ): PagePromise<DataSourcesCursor, DataSource> {
+    return this._client.getAPIList('/v1/data_sources/', Cursor<DataSource>, { query, ...options });
   }
 
   /**
@@ -81,7 +81,7 @@ export class DataSources extends APIResource {
   }
 }
 
-export type DataSourcesLimitOffset = LimitOffset<DataSource>;
+export type DataSourcesCursor = Cursor<DataSource>;
 
 /**
  * Service-level representation of a data source.
@@ -181,7 +181,7 @@ export interface DataSourceOauth2Params {
   /**
    * Additional parameters for the OAuth2 flow
    */
-  additional_params?: Record<string, unknown> | null;
+  additional_params?: { [key: string]: unknown } | null;
 }
 
 export type DataSourceType = 'notion' | 'linear';
@@ -408,7 +408,7 @@ export declare namespace DataSourceUpdateParams {
   }
 }
 
-export interface DataSourceListParams extends LimitOffsetParams {}
+export interface DataSourceListParams extends CursorParams {}
 
 DataSources.Connectors = Connectors;
 
@@ -421,7 +421,7 @@ export declare namespace DataSources {
     type NotionDataSource as NotionDataSource,
     type Oauth2Params as Oauth2Params,
     type DataSourceDeleteResponse as DataSourceDeleteResponse,
-    type DataSourcesLimitOffset as DataSourcesLimitOffset,
+    type DataSourcesCursor as DataSourcesCursor,
     type DataSourceCreateParams as DataSourceCreateParams,
     type DataSourceUpdateParams as DataSourceUpdateParams,
     type DataSourceListParams as DataSourceListParams,
@@ -431,7 +431,7 @@ export declare namespace DataSources {
     Connectors as Connectors,
     type DataSourceConnector as DataSourceConnector,
     type ConnectorDeleteResponse as ConnectorDeleteResponse,
-    type DataSourceConnectorsLimitOffset as DataSourceConnectorsLimitOffset,
+    type DataSourceConnectorsCursor as DataSourceConnectorsCursor,
     type ConnectorCreateParams as ConnectorCreateParams,
     type ConnectorRetrieveParams as ConnectorRetrieveParams,
     type ConnectorUpdateParams as ConnectorUpdateParams,

package/src/resources/data-sources/index.ts

@@ -9,7 +9,7 @@ export {
   type ConnectorUpdateParams,
   type ConnectorListParams,
   type ConnectorDeleteParams,
-  type DataSourceConnectorsLimitOffset,
+  type DataSourceConnectorsCursor,
 } from './connectors';
 export {
   DataSources,
@@ -23,5 +23,5 @@ export {
   type DataSourceCreateParams,
   type DataSourceUpdateParams,
   type DataSourceListParams,
-  type DataSourcesLimitOffset,
+  type DataSourcesCursor,
 } from './data-sources';

package/src/resources/extractions/content.ts

@@ -21,7 +21,7 @@ export class Content extends APIResource {
  * The result of an extraction job.
  */
 export interface ExtractionResult {
-  data: Record<string, unknown>;
+  data: { [key: string]: unknown };
 
   warnings: Array<string>;
 }
@@ -85,7 +85,7 @@ export interface ContentCreateParams {
   /**
    * The JSON schema to use for extraction
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 
   /**
    * Additional instructions for the extraction

package/src/resources/extractions/jobs.ts

@@ -83,12 +83,12 @@ export interface ExtractionJob {
   /**
    * Error information if failed
    */
-  error: Record<string, unknown> | null;
+  error: { [key: string]: unknown } | null;
 
   /**
    * The JSON schema used for extraction
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 }
 
 export interface JobCreateParams {
@@ -100,7 +100,7 @@ export interface JobCreateParams {
   /**
    * The JSON schema to use for extraction
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 }
 
 export declare namespace Jobs {

package/src/resources/extractions/schema.ts

@@ -46,7 +46,7 @@ export interface CreatedJsonSchema {
   /**
    * The created JSON schema
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 }
 
 /**
@@ -56,7 +56,7 @@ export interface EnhancedJsonSchema {
   /**
    * The enhanced JSON schema
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 }
 
 /**
@@ -76,7 +76,7 @@ export interface ValidatedJsonSchema {
   /**
    * The validated JSON schema
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 }
 
 export interface SchemaCreateParams {
@@ -90,14 +90,14 @@ export interface SchemaEnhanceParams {
   /**
    * The JSON schema to enhance
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 }
 
 export interface SchemaValidateParams {
   /**
    * The JSON schema to validate
    */
-  json_schema: Record<string, unknown>;
+  json_schema: { [key: string]: unknown };
 }
 
 export declare namespace Schema {

package/src/resources/files.ts

@@ -2,7 +2,7 @@
 
 import { APIResource } from '../core/resource';
 import { APIPromise } from '../core/api-promise';
-import { LimitOffset, type LimitOffsetParams, PagePromise } from '../core/pagination';
+import { Cursor, type CursorParams, PagePromise } from '../core/pagination';
 import { type Uploadable } from '../core/uploads';
 import { buildHeaders } from '../internal/headers';
 import { RequestOptions } from '../internal/request-options';
@@ -56,8 +56,8 @@ export class Files extends APIResource {
   list(
     query: FileListParams | null | undefined = {},
     options?: RequestOptions,
-  ): PagePromise<FileObjectsLimitOffset, FileObject> {
-    return this._client.getAPIList('/v1/files', LimitOffset<FileObject>, { query, ...options });
+  ): PagePromise<FileObjectsCursor, FileObject> {
+    return this._client.getAPIList('/v1/files', Cursor<FileObject>, { query, ...options });
   }
 
   /**
@@ -87,7 +87,7 @@ export class Files extends APIResource {
   }
 }
 
-export type FileObjectsLimitOffset = LimitOffset<FileObject>;
+export type FileObjectsCursor = Cursor<FileObject>;
 
 /**
  * A model representing a file object in the system.
@@ -183,14 +183,14 @@ export interface FileUpdateParams {
   file: Uploadable;
 }
 
-export interface FileListParams extends LimitOffsetParams {}
+export interface FileListParams extends CursorParams {}
 
 export declare namespace Files {
   export {
     type FileObject as FileObject,
     type PaginationWithTotal as PaginationWithTotal,
     type FileDeleteResponse as FileDeleteResponse,
-    type FileObjectsLimitOffset as FileObjectsLimitOffset,
+    type FileObjectsCursor as FileObjectsCursor,
     type FileCreateParams as FileCreateParams,
     type FileUpdateParams as FileUpdateParams,
     type FileListParams as FileListParams,

package/src/resources/index.ts

@@ -23,7 +23,7 @@ export {
   type DataSourceCreateParams,
   type DataSourceUpdateParams,
   type DataSourceListParams,
-  type DataSourcesLimitOffset,
+  type DataSourcesCursor,
 } from './data-sources/data-sources';
 export { Embeddings, type EncodingFormat, type ObjectType, type EmbeddingCreateParams } from './embeddings';
 export { Extractions } from './extractions/extractions';
@@ -35,7 +35,7 @@ export {
   type FileCreateParams,
   type FileUpdateParams,
   type FileListParams,
-  type FileObjectsLimitOffset,
+  type FileObjectsCursor,
 } from './files';
 export { Parsing } from './parsing/parsing';
 export {
@@ -55,7 +55,7 @@ export {
   type VectorStoreListParams,
   type VectorStoreQuestionAnsweringParams,
   type VectorStoreSearchParams,
-  type VectorStoresLimitOffset,
+  type VectorStoresCursor,
 } from './vector-stores/vector-stores';
 export {
   type Embedding,

package/src/resources/parsing/index.ts

@@ -11,6 +11,6 @@ export {
   type JobDeleteResponse,
   type JobCreateParams,
   type JobListParams,
-  type JobListResponsesLimitOffset,
+  type JobListResponsesCursor,
 } from './jobs';
 export { Parsing } from './parsing';

package/src/resources/parsing/jobs.ts

@@ -3,7 +3,7 @@
 import { APIResource } from '../../core/resource';
 import * as JobsAPI from './jobs';
 import { APIPromise } from '../../core/api-promise';
-import { LimitOffset, type LimitOffsetParams, PagePromise } from '../../core/pagination';
+import { Cursor, type CursorParams, PagePromise } from '../../core/pagination';
 import { RequestOptions } from '../../internal/request-options';
 import { path } from '../../internal/utils/path';
 import * as polling from '../../lib/polling';
@@ -42,8 +42,8 @@ export class Jobs extends APIResource {
   list(
     query: JobListParams | null | undefined = {},
     options?: RequestOptions,
-  ): PagePromise<JobListResponsesLimitOffset, JobListResponse> {
-    return this._client.getAPIList('/v1/parsing/jobs', LimitOffset<JobListResponse>, { query, ...options });
+  ): PagePromise<JobListResponsesCursor, JobListResponse> {
+    return this._client.getAPIList('/v1/parsing/jobs', Cursor<JobListResponse>, { query, ...options });
   }
 
   /**
@@ -161,7 +161,7 @@ export class Jobs extends APIResource {
   }
 }
 
-export type JobListResponsesLimitOffset = LimitOffset<JobListResponse>;
+export type JobListResponsesCursor = Cursor<JobListResponse>;
 
 /**
  * Strategy used for chunking document content.
@@ -429,7 +429,7 @@ export interface JobCreateParams {
   mode?: 'fast' | 'high_quality';
 }
 
-export interface JobListParams extends LimitOffsetParams {}
+export interface JobListParams extends CursorParams {}
 
 export declare namespace Jobs {
   export {
@@ -440,7 +440,7 @@ export declare namespace Jobs {
     type ReturnFormat as ReturnFormat,
     type JobListResponse as JobListResponse,
     type JobDeleteResponse as JobDeleteResponse,
-    type JobListResponsesLimitOffset as JobListResponsesLimitOffset,
+    type JobListResponsesCursor as JobListResponsesCursor,
     type JobCreateParams as JobCreateParams,
     type JobListParams as JobListParams,
   };

package/src/resources/parsing/parsing.ts

@@ -9,7 +9,7 @@ import {
   JobDeleteResponse,
   JobListParams,
   JobListResponse,
-  JobListResponsesLimitOffset,
+  JobListResponsesCursor,
   Jobs,
   ParsingJob,
   ParsingJobStatus,
@@ -32,7 +32,7 @@ export declare namespace Parsing {
     type ReturnFormat as ReturnFormat,
     type JobListResponse as JobListResponse,
     type JobDeleteResponse as JobDeleteResponse,
-    type JobListResponsesLimitOffset as JobListResponsesLimitOffset,
+    type JobListResponsesCursor as JobListResponsesCursor,
     type JobCreateParams as JobCreateParams,
     type JobListParams as JobListParams,
   };