@xata.io/client 0.0.0-alpha.vfd68d20 → 0.0.0-alpha.vfda8f2e

package/dist/index.mjs

@@ -41,6 +41,18 @@ function isStringArray(value) {
 function isNumber(value) {
   return isDefined(value) && typeof value === "number";
 }
+function parseNumber(value) {
+  if (isNumber(value)) {
+    return value;
+  }
+  if (isString(value)) {
+    const parsed = Number(value);
+    if (!Number.isNaN(parsed)) {
+      return parsed;
+    }
+  }
+  return void 0;
+}
 function toBase64(value) {
   try {
     return btoa(value);
@@ -60,6 +72,16 @@ function deepMerge(a, b) {
   }
   return result;
 }
+function chunk(array, chunkSize) {
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+}
+async function timeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 
 function getEnvironment() {
   try {
@@ -172,6 +194,29 @@ function getAPIKey() {
   }
 }
 
+var __accessCheck$8 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$8 = (obj, member, getter) => {
+  __accessCheck$8(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$8 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$8 = (obj, member, value, setter) => {
+  __accessCheck$8(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateMethod$4 = (obj, member, method) => {
+  __accessCheck$8(obj, member, "access private method");
+  return method;
+};
+var _fetch, _queue, _concurrency, _enqueue, enqueue_fn;
 function getFetchImplementation(userFetch) {
   const globalFetch = typeof fetch !== "undefined" ? fetch : void 0;
   const fetchImpl = userFetch ?? globalFetch;
@@ -182,8 +227,70 @@ function getFetchImplementation(userFetch) {
   }
   return fetchImpl;
 }
+class ApiRequestPool {
+  constructor(concurrency = 10) {
+    __privateAdd$8(this, _enqueue);
+    __privateAdd$8(this, _fetch, void 0);
+    __privateAdd$8(this, _queue, void 0);
+    __privateAdd$8(this, _concurrency, void 0);
+    __privateSet$8(this, _queue, []);
+    __privateSet$8(this, _concurrency, concurrency);
+    this.running = 0;
+    this.started = 0;
+  }
+  setFetch(fetch2) {
+    __privateSet$8(this, _fetch, fetch2);
+  }
+  getFetch() {
+    if (!__privateGet$8(this, _fetch)) {
+      throw new Error("Fetch not set");
+    }
+    return __privateGet$8(this, _fetch);
+  }
+  request(url, options, context = { start: new Date(), stalled: false }) {
+    const fetch2 = this.getFetch();
+    return __privateMethod$4(this, _enqueue, enqueue_fn).call(this, async () => {
+      const response = await fetch2(url, options);
+      if (response.status === 429) {
+        const rateLimitReset = parseNumber(response.headers?.get("x-ratelimit-reset")) ?? 1;
+        await timeout(rateLimitReset * 1e3);
+        return await this.request(url, options, { ...context, stalled: true });
+      }
+      if (context.stalled) {
+        const stalledTime = new Date().getTime() - context.start.getTime();
+        console.warn(`A request to Xata hit your workspace limits, was retried and stalled for ${stalledTime}ms`);
+      }
+      return response;
+    });
+  }
+}
+_fetch = new WeakMap();
+_queue = new WeakMap();
+_concurrency = new WeakMap();
+_enqueue = new WeakSet();
+enqueue_fn = function(task) {
+  const promise = new Promise((resolve) => __privateGet$8(this, _queue).push(resolve)).finally(() => {
+    this.started--;
+    this.running++;
+  }).then(() => task()).finally(() => {
+    this.running--;
+    const next = __privateGet$8(this, _queue).shift();
+    if (next !== void 0) {
+      this.started++;
+      next();
+    }
+  });
+  if (this.running + this.started < __privateGet$8(this, _concurrency)) {
+    const next = __privateGet$8(this, _queue).shift();
+    if (next !== void 0) {
+      this.started++;
+      next();
+    }
+  }
+  return promise;
+};
 
-const VERSION = "0.0.0-alpha.vfd68d20";
+const VERSION = "0.0.0-alpha.vfda8f2e";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -226,6 +333,7 @@ function getMessage(data) {
   }
 }
 
+const pool = new ApiRequestPool();
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
   const cleanQueryParams = Object.entries(queryParams).reduce((acc, [key, value]) => {
     if (value === void 0 || value === null)
@@ -276,7 +384,8 @@ async function fetch$1({
   sessionID,
   fetchOptions = {}
 }) {
-  return trace(
+  pool.setFetch(fetchImpl);
+  return await trace(
     `${method.toUpperCase()} ${path}`,
     async ({ setAttributes }) => {
       const baseUrl = buildBaseUrl({ endpoint, path, workspacesApiUrl, pathParams, apiUrl });
@@ -286,7 +395,7 @@ async function fetch$1({
         [TraceAttributes.HTTP_URL]: url,
         [TraceAttributes.HTTP_TARGET]: resolveUrl(path, queryParams, pathParams)
       });
-      const response = await fetchImpl(url, {
+      const response = await pool.request(url, {
         ...fetchOptions,
         method: method.toUpperCase(),
         body: body ? JSON.stringify(body) : void 0,
@@ -301,9 +410,6 @@ async function fetch$1({
         },
         signal
       });
-      if (response.status === 204) {
-        return {};
-      }
       const { host, protocol } = parseUrl(response.url);
       const requestId = response.headers?.get("x-request-id") ?? void 0;
       setAttributes({
@@ -313,6 +419,12 @@ async function fetch$1({
         [TraceAttributes.HTTP_HOST]: host,
         [TraceAttributes.HTTP_SCHEME]: protocol?.replace(":", "")
       });
+      if (response.status === 204) {
+        return {};
+      }
+      if (response.status === 429) {
+        throw new FetcherError(response.status, "Rate limit exceeded", requestId);
+      }
       try {
         const jsonResponse = await response.json();
         if (response.ok) {
@@ -1366,6 +1478,19 @@ class RecordsApi {
       ...this.extraProps
     });
   }
+  branchTransaction({
+    workspace,
+    region,
+    database,
+    branch,
+    operations
+  }) {
+    return operationsByTag.records.branchTransaction({
+      pathParams: { workspace, region, dbBranchName: `${database}:${branch}` },
+      body: { operations },
+      ...this.extraProps
+    });
+  }
 }
 class SearchAndFilterApi {
   constructor(extraProps) {
@@ -2131,7 +2256,8 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$4(obj, member, "access private method");
   return method;
 };
-var _table, _getFetchProps, _db, _cache, _schemaTables$2, _trace, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchemaTables$1, getSchemaTables_fn$1;
+var _table, _getFetchProps, _db, _cache, _schemaTables$2, _trace, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _insertRecords, insertRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _updateRecords, updateRecords_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _deleteRecords, deleteRecords_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchemaTables$1, getSchemaTables_fn$1;
+const BULK_OPERATION_MAX_SIZE = 1e3;
 class Repository extends Query {
 }
 class RestRepository extends Query {
@@ -2143,10 +2269,12 @@ class RestRepository extends Query {
     );
     __privateAdd$4(this, _insertRecordWithoutId);
     __privateAdd$4(this, _insertRecordWithId);
-    __privateAdd$4(this, _bulkInsertTableRecords);
+    __privateAdd$4(this, _insertRecords);
     __privateAdd$4(this, _updateRecordWithID);
+    __privateAdd$4(this, _updateRecords);
     __privateAdd$4(this, _upsertRecordWithID);
     __privateAdd$4(this, _deleteRecord);
+    __privateAdd$4(this, _deleteRecords);
     __privateAdd$4(this, _setCacheQuery);
     __privateAdd$4(this, _getCacheQuery);
     __privateAdd$4(this, _getSchemaTables$1);
@@ -2180,20 +2308,22 @@ class RestRepository extends Query {
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
-        const columns = isStringArray(b) ? b : void 0;
-        return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a, columns);
+        const ids = await __privateMethod$2(this, _insertRecords, insertRecords_fn).call(this, a, { ifVersion, createOnly: true });
+        const columns = isStringArray(b) ? b : ["*"];
+        const result = await this.read(ids, columns);
+        return result;
       }
       if (isString(a) && isObject(b)) {
         if (a === "")
           throw new Error("The id can't be empty");
         const columns = isStringArray(c) ? c : void 0;
-        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b, columns, { createOnly: true, ifVersion });
+        return await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b, columns, { createOnly: true, ifVersion });
       }
       if (isObject(a) && isString(a.id)) {
         if (a.id === "")
           throw new Error("The id can't be empty");
         const columns = isStringArray(b) ? b : void 0;
-        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns, { createOnly: true, ifVersion });
+        return await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns, { createOnly: true, ifVersion });
       }
       if (isObject(a)) {
         const columns = isStringArray(b) ? b : void 0;
@@ -2268,11 +2398,15 @@ class RestRepository extends Query {
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
-        if (a.length > 100) {
-          console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
-        }
+        const existing = await this.read(a, ["id"]);
+        const updates = a.filter((_item, index) => existing[index] !== null);
+        await __privateMethod$2(this, _updateRecords, updateRecords_fn).call(this, updates, {
+          ifVersion,
+          upsert: false
+        });
         const columns = isStringArray(b) ? b : ["*"];
-        return Promise.all(a.map((object) => this.update(object, columns)));
+        const result = await this.read(a, columns);
+        return result;
       }
       if (isString(a) && isObject(b)) {
         const columns = isStringArray(c) ? c : void 0;
@@ -2310,11 +2444,13 @@ class RestRepository extends Query {
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
-        if (a.length > 100) {
-          console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
-        }
+        await __privateMethod$2(this, _updateRecords, updateRecords_fn).call(this, a, {
+          ifVersion,
+          upsert: true
+        });
         const columns = isStringArray(b) ? b : ["*"];
-        return Promise.all(a.map((object) => this.createOrUpdate(object, columns)));
+        const result = await this.read(a, columns);
+        return result;
       }
       if (isString(a) && isObject(b)) {
         const columns = isStringArray(c) ? c : void 0;
@@ -2333,8 +2469,10 @@ class RestRepository extends Query {
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
+        const ids = await __privateMethod$2(this, _insertRecords, insertRecords_fn).call(this, a, { ifVersion, createOnly: false });
         const columns = isStringArray(b) ? b : ["*"];
-        return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a, columns);
+        const result = await this.read(ids, columns);
+        return result;
       }
       if (isString(a) && isObject(b)) {
         const columns = isStringArray(c) ? c : void 0;
@@ -2352,10 +2490,17 @@ class RestRepository extends Query {
       if (Array.isArray(a)) {
         if (a.length === 0)
           return [];
-        if (a.length > 100) {
-          console.warn("Bulk delete operation is not optimized in the Xata API yet, this request might be slow");
-        }
-        return Promise.all(a.map((id) => this.delete(id, b)));
+        const ids = a.map((o) => {
+          if (isString(o))
+            return o;
+          if (isString(o.id))
+            return o.id;
+          throw new Error("Invalid arguments for delete method");
+        });
+        const columns = isStringArray(b) ? b : ["*"];
+        const result = await this.read(a, columns);
+        await __privateMethod$2(this, _deleteRecords, deleteRecords_fn).call(this, ids);
+        return result;
       }
       if (isString(a)) {
         return __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a, b);
@@ -2523,31 +2668,40 @@ insertRecordWithId_fn = async function(recordId, object, columns = ["*"], { crea
   const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
   return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
 };
-_bulkInsertTableRecords = new WeakSet();
-bulkInsertTableRecords_fn = async function(objects, columns = ["*"]) {
+_insertRecords = new WeakSet();
+insertRecords_fn = async function(objects, { createOnly, ifVersion }) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  const records = objects.map((object) => transformObjectLinks(object));
-  const response = await bulkInsertTableRecords({
-    pathParams: {
-      workspace: "{workspaceId}",
-      dbBranchName: "{dbBranch}",
-      region: "{region}",
-      tableName: __privateGet$4(this, _table)
-    },
-    queryParams: { columns },
-    body: { records },
-    ...fetchProps
-  });
-  if (!isResponseWithRecords(response)) {
-    throw new Error("Request included columns but server didn't include them");
+  const chunkedOperations = chunk(
+    objects.map((object) => ({
+      insert: { table: __privateGet$4(this, _table), record: transformObjectLinks(object), createOnly, ifVersion }
+    })),
+    BULK_OPERATION_MAX_SIZE
+  );
+  const ids = [];
+  for (const operations of chunkedOperations) {
+    const { results } = await branchTransaction({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}"
+      },
+      body: { operations },
+      ...fetchProps
+    });
+    for (const result of results) {
+      if (result.operation === "insert") {
+        ids.push(result.id);
+      } else {
+        ids.push(null);
+      }
+    }
   }
-  const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
-  return response.records?.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item, columns));
+  return ids;
 };
 _updateRecordWithID = new WeakSet();
 updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-  const record = transformObjectLinks(object);
+  const { id: _id, ...record } = transformObjectLinks(object);
   try {
     const response = await updateRecordWithID({
       pathParams: {
@@ -2570,6 +2724,36 @@ updateRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVe
     throw e;
   }
 };
+_updateRecords = new WeakSet();
+updateRecords_fn = async function(objects, { ifVersion, upsert }) {
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+  const chunkedOperations = chunk(
+    objects.map(({ id, ...object }) => ({
+      update: { table: __privateGet$4(this, _table), id, ifVersion, upsert, fields: transformObjectLinks(object) }
+    })),
+    BULK_OPERATION_MAX_SIZE
+  );
+  const ids = [];
+  for (const operations of chunkedOperations) {
+    const { results } = await branchTransaction({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}"
+      },
+      body: { operations },
+      ...fetchProps
+    });
+    for (const result of results) {
+      if (result.operation === "update") {
+        ids.push(result.id);
+      } else {
+        ids.push(null);
+      }
+    }
+  }
+  return ids;
+};
 _upsertRecordWithID = new WeakSet();
 upsertRecordWithID_fn = async function(recordId, object, columns = ["*"], { ifVersion }) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
@@ -2612,6 +2796,25 @@ deleteRecord_fn = async function(recordId, columns = ["*"]) {
     throw e;
   }
 };
+_deleteRecords = new WeakSet();
+deleteRecords_fn = async function(recordIds) {
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+  const chunkedOperations = chunk(
+    recordIds.map((id) => ({ delete: { table: __privateGet$4(this, _table), id } })),
+    BULK_OPERATION_MAX_SIZE
+  );
+  for (const operations of chunkedOperations) {
+    await branchTransaction({
+      pathParams: {
+        workspace: "{workspaceId}",
+        dbBranchName: "{dbBranch}",
+        region: "{region}"
+      },
+      body: { operations },
+      ...fetchProps
+    });
+  }
+};
 _setCacheQuery = new WeakSet();
 setCacheQuery_fn = async function(query, meta, records) {
   await __privateGet$4(this, _cache).set(`query_${__privateGet$4(this, _table)}:${query.key()}`, { date: new Date(), meta, records });
@@ -2722,9 +2925,6 @@ const initObject = (db, schemaTables, table, object, selectedColumns) => {
   Object.freeze(result);
   return result;
 };
-function isResponseWithRecords(value) {
-  return isObject(value) && Array.isArray(value.records);
-}
 function extractId(value) {
   if (isString(value))
     return value;