@xata.io/client 0.0.0-alpha.vf3081bb → 0.0.0-alpha.vf38b6da

package/dist/index.mjs

@@ -13,43 +13,95 @@ function isDefined(value) {
 function isString(value) {
   return isDefined(value) && typeof value === "string";
 }
+function isStringArray(value) {
+  return isDefined(value) && Array.isArray(value) && value.every(isString);
+}
 function toBase64(value) {
   try {
     return btoa(value);
   } catch (err) {
-    return Buffer.from(value).toString("base64");
+    const buf = Buffer;
+    return buf.from(value).toString("base64");
   }
 }
 
-function getEnvVariable(name) {
+function getEnvironment() {
   try {
-    if (isObject(process) && isString(process?.env?.[name])) {
-      return process.env[name];
+    if (isObject(process) && isObject(process.env)) {
+      return {
+        apiKey: process.env.XATA_API_KEY ?? getGlobalApiKey(),
+        databaseURL: process.env.XATA_DATABASE_URL ?? getGlobalDatabaseURL(),
+        branch: process.env.XATA_BRANCH ?? getGlobalBranch(),
+        envBranch: process.env.VERCEL_GIT_COMMIT_REF ?? process.env.CF_PAGES_BRANCH ?? process.env.BRANCH,
+        fallbackBranch: process.env.XATA_FALLBACK_BRANCH ?? getGlobalFallbackBranch()
+      };
     }
   } catch (err) {
   }
   try {
-    if (isObject(Deno) && isString(Deno?.env?.get(name))) {
-      return Deno.env.get(name);
+    if (isObject(Deno) && isObject(Deno.env)) {
+      return {
+        apiKey: Deno.env.get("XATA_API_KEY") ?? getGlobalApiKey(),
+        databaseURL: Deno.env.get("XATA_DATABASE_URL") ?? getGlobalDatabaseURL(),
+        branch: Deno.env.get("XATA_BRANCH") ?? getGlobalBranch(),
+        envBranch: Deno.env.get("VERCEL_GIT_COMMIT_REF") ?? Deno.env.get("CF_PAGES_BRANCH") ?? Deno.env.get("BRANCH"),
+        fallbackBranch: Deno.env.get("XATA_FALLBACK_BRANCH") ?? getGlobalFallbackBranch()
+      };
     }
   } catch (err) {
   }
+  return {
+    apiKey: getGlobalApiKey(),
+    databaseURL: getGlobalDatabaseURL(),
+    branch: getGlobalBranch(),
+    envBranch: void 0,
+    fallbackBranch: getGlobalFallbackBranch()
+  };
+}
+function getGlobalApiKey() {
+  try {
+    return XATA_API_KEY;
+  } catch (err) {
+    return void 0;
+  }
+}
+function getGlobalDatabaseURL() {
+  try {
+    return XATA_DATABASE_URL;
+  } catch (err) {
+    return void 0;
+  }
+}
+function getGlobalBranch() {
+  try {
+    return XATA_BRANCH;
+  } catch (err) {
+    return void 0;
+  }
+}
+function getGlobalFallbackBranch() {
+  try {
+    return XATA_FALLBACK_BRANCH;
+  } catch (err) {
+    return void 0;
+  }
 }
 async function getGitBranch() {
+  const cmd = ["git", "branch", "--show-current"];
+  const fullCmd = cmd.join(" ");
+  const nodeModule = ["child", "process"].join("_");
+  const execOptions = { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] };
   try {
     if (typeof require === "function") {
-      const req = require;
-      return req("child_process").execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+      return require(nodeModule).execSync(fullCmd, execOptions).trim();
     }
+    const { execSync } = await import(nodeModule);
+    return execSync(fullCmd, execOptions).toString().trim();
   } catch (err) {
   }
   try {
     if (isObject(Deno)) {
-      const process2 = Deno.run({
-        cmd: ["git", "branch", "--show-current"],
-        stdout: "piped",
-        stderr: "piped"
-      });
+      const process2 = Deno.run({ cmd, stdout: "piped", stderr: "null" });
       return new TextDecoder().decode(await process2.output()).trim();
     }
   } catch (err) {
@@ -58,7 +110,8 @@ async function getGitBranch() {
 
 function getAPIKey() {
   try {
-    return getEnvVariable("XATA_API_KEY") ?? XATA_API_KEY;
+    const { apiKey } = getEnvironment();
+    return apiKey;
   } catch (err) {
     return void 0;
   }
@@ -68,26 +121,35 @@ function getFetchImplementation(userFetch) {
   const globalFetch = typeof fetch !== "undefined" ? fetch : void 0;
   const fetchImpl = userFetch ?? globalFetch;
   if (!fetchImpl) {
-    throw new Error(`The \`fetch\` option passed to the Xata client is resolving to a falsy value and may not be correctly imported.`);
+    throw new Error(
+      `The \`fetch\` option passed to the Xata client is resolving to a falsy value and may not be correctly imported.`
+    );
   }
   return fetchImpl;
 }
 
+const VERSION = "0.0.0-alpha.vf38b6da";
+
 class ErrorWithCause extends Error {
   constructor(message, options) {
     super(message, options);
   }
 }
 class FetcherError extends ErrorWithCause {
-  constructor(status, data) {
+  constructor(status, data, requestId) {
     super(getMessage(data));
     this.status = status;
     this.errors = isBulkError(data) ? data.errors : void 0;
+    this.requestId = requestId;
     if (data instanceof Error) {
       this.stack = data.stack;
       this.cause = data.cause;
     }
   }
+  toString() {
+    const error = super.toString();
+    return `[${this.status}] (${this.requestId ?? "Unknown"}): ${error}`;
+  }
 }
 function isBulkError(error) {
   return isObject(error) && Array.isArray(error.errors);
@@ -110,7 +172,12 @@ function getMessage(data) {
 }
 
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
-  const query = new URLSearchParams(queryParams).toString();
+  const cleanQueryParams = Object.entries(queryParams).reduce((acc, [key, value]) => {
+    if (value === void 0 || value === null)
+      return acc;
+    return { ...acc, [key]: value };
+  }, {});
+  const query = new URLSearchParams(cleanQueryParams).toString();
   const queryString = query.length > 0 ? `?${query}` : "";
   return url.replace(/\{\w*\}/g, (key) => pathParams[key.slice(1, -1)]) + queryString;
 };
@@ -150,6 +217,7 @@ async function fetch$1({
     body: body ? JSON.stringify(body) : void 0,
     headers: {
       "Content-Type": "application/json",
+      "User-Agent": `Xata client-ts/${VERSION}`,
       ...headers,
       ...hostHeader(fullUrl),
       Authorization: `Bearer ${apiKey}`
@@ -158,14 +226,15 @@ async function fetch$1({
   if (response.status === 204) {
     return {};
   }
+  const requestId = response.headers?.get("x-request-id") ?? void 0;
   try {
     const jsonResponse = await response.json();
     if (response.ok) {
       return jsonResponse;
     }
-    throw new FetcherError(response.status, jsonResponse);
+    throw new FetcherError(response.status, jsonResponse, requestId);
   } catch (error) {
-    throw new FetcherError(response.status, error);
+    throw new FetcherError(response.status, error, requestId);
   }
 }
 
@@ -224,6 +293,7 @@ const removeWorkspaceMember = (variables) => fetch$1({
   ...variables
 });
 const inviteWorkspaceMember = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables });
+const updateWorkspaceMemberInvite = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables });
 const cancelWorkspaceMemberInvite = (variables) => fetch$1({
   url: "/workspaces/{workspaceId}/invites/{inviteId}",
   method: "delete",
@@ -259,6 +329,11 @@ const deleteDatabase = (variables) => fetch$1({
   method: "delete",
   ...variables
 });
+const getDatabaseMetadata = (variables) => fetch$1({
+  url: "/dbs/{dbName}/metadata",
+  method: "get",
+  ...variables
+});
 const getGitBranchesMapping = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables });
 const addGitBranchesEntry = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables });
 const removeGitBranchesEntry = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "delete", ...variables });
@@ -272,11 +347,7 @@ const getBranchDetails = (variables) => fetch$1({
   method: "get",
   ...variables
 });
-const createBranch = (variables) => fetch$1({
-  url: "/db/{dbBranchName}",
-  method: "put",
-  ...variables
-});
+const createBranch = (variables) => fetch$1({ url: "/db/{dbBranchName}", method: "put", ...variables });
 const deleteBranch = (variables) => fetch$1({
   url: "/db/{dbBranchName}",
   method: "delete",
@@ -350,11 +421,7 @@ const updateColumn = (variables) => fetch$1({
   method: "patch",
   ...variables
 });
-const insertRecord = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/data",
-  method: "post",
-  ...variables
-});
+const insertRecord = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data", method: "post", ...variables });
 const insertRecordWithID = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "put", ...variables });
 const updateRecordWithID = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "patch", ...variables });
 const upsertRecordWithID = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "post", ...variables });
@@ -396,6 +463,7 @@ const operationsByTag = {
     updateWorkspaceMemberRole,
     removeWorkspaceMember,
     inviteWorkspaceMember,
+    updateWorkspaceMemberInvite,
     cancelWorkspaceMemberInvite,
     resendWorkspaceMemberInvite,
     acceptWorkspaceMemberInvite
@@ -404,6 +472,7 @@ const operationsByTag = {
     getDatabaseList,
     createDatabase,
     deleteDatabase,
+    getDatabaseMetadata,
     getGitBranchesMapping,
     addGitBranchesEntry,
     removeGitBranchesEntry,
@@ -485,7 +554,7 @@ var __privateAdd$7 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$6 = (obj, member, value, setter) => {
+var __privateSet$7 = (obj, member, value, setter) => {
   __accessCheck$7(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -500,7 +569,7 @@ class XataApiClient {
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
-    __privateSet$6(this, _extraProps, {
+    __privateSet$7(this, _extraProps, {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
       fetchImpl: getFetchImplementation(options.fetch),
@@ -627,6 +696,13 @@ class WorkspaceApi {
       ...this.extraProps
     });
   }
+  updateWorkspaceMemberInvite(workspaceId, inviteId, role) {
+    return operationsByTag.workspaces.updateWorkspaceMemberInvite({
+      pathParams: { workspaceId, inviteId },
+      body: { role },
+      ...this.extraProps
+    });
+  }
   cancelWorkspaceMemberInvite(workspaceId, inviteId) {
     return operationsByTag.workspaces.cancelWorkspaceMemberInvite({
       pathParams: { workspaceId, inviteId },
@@ -669,6 +745,12 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
+  getDatabaseMetadata(workspace, dbName) {
+    return operationsByTag.database.getDatabaseMetadata({
+      pathParams: { workspace, dbName },
+      ...this.extraProps
+    });
+  }
   getGitBranchesMapping(workspace, dbName) {
     return operationsByTag.database.getGitBranchesMapping({
       pathParams: { workspace, dbName },
@@ -689,10 +771,10 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
-  resolveBranch(workspace, dbName, gitBranch) {
+  resolveBranch(workspace, dbName, gitBranch, fallbackBranch) {
     return operationsByTag.database.resolveBranch({
       pathParams: { workspace, dbName },
-      queryParams: { gitBranch },
+      queryParams: { gitBranch, fallbackBranch },
       ...this.extraProps
     });
   }
@@ -841,9 +923,10 @@ class RecordsApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
-  insertRecord(workspace, database, branch, tableName, record) {
+  insertRecord(workspace, database, branch, tableName, record, options = {}) {
     return operationsByTag.records.insertRecord({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      queryParams: options,
       body: record,
       ...this.extraProps
     });
@@ -872,21 +955,24 @@ class RecordsApi {
       ...this.extraProps
     });
   }
-  deleteRecord(workspace, database, branch, tableName, recordId) {
+  deleteRecord(workspace, database, branch, tableName, recordId, options = {}) {
     return operationsByTag.records.deleteRecord({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
+      queryParams: options,
       ...this.extraProps
     });
   }
   getRecord(workspace, database, branch, tableName, recordId, options = {}) {
     return operationsByTag.records.getRecord({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
+      queryParams: options,
       ...this.extraProps
     });
   }
-  bulkInsertTableRecords(workspace, database, branch, tableName, records) {
+  bulkInsertTableRecords(workspace, database, branch, tableName, records, options = {}) {
     return operationsByTag.records.bulkInsertTableRecords({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      queryParams: options,
       body: { records },
       ...this.extraProps
     });
@@ -937,7 +1023,7 @@ var __privateAdd$6 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$5 = (obj, member, value, setter) => {
+var __privateSet$6 = (obj, member, value, setter) => {
   __accessCheck$6(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -946,7 +1032,7 @@ var _query, _page;
 class Page {
   constructor(query, meta, records = []) {
     __privateAdd$6(this, _query, void 0);
-    __privateSet$5(this, _query, query);
+    __privateSet$6(this, _query, query);
     this.meta = meta;
     this.records = new RecordArray(this, records);
   }
@@ -975,10 +1061,26 @@ function isCursorPaginationOptions(options) {
   return isDefined(options) && (isDefined(options.first) || isDefined(options.last) || isDefined(options.after) || isDefined(options.before));
 }
 const _RecordArray = class extends Array {
-  constructor(page, overrideRecords) {
-    super(...overrideRecords ?? page.records);
+  constructor(...args) {
+    super(..._RecordArray.parseConstructorParams(...args));
     __privateAdd$6(this, _page, void 0);
-    __privateSet$5(this, _page, page);
+    __privateSet$6(this, _page, isObject(args[0]?.meta) ? args[0] : { meta: { page: { cursor: "", more: false } }, records: [] });
+  }
+  static parseConstructorParams(...args) {
+    if (args.length === 1 && typeof args[0] === "number") {
+      return new Array(args[0]);
+    }
+    if (args.length <= 2 && isObject(args[0]?.meta) && Array.isArray(args[1] ?? [])) {
+      const result = args[1] ?? args[0].records ?? [];
+      return new Array(...result);
+    }
+    return new Array(...args);
+  }
+  toArray() {
+    return new Array(...this);
+  }
+  map(callbackfn, thisArg) {
+    return this.toArray().map(callbackfn, thisArg);
   }
   async nextPage(size, offset) {
     const newPage = await __privateGet$6(this, _page).nextPage(size, offset);
@@ -1016,7 +1118,7 @@ var __privateAdd$5 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$4 = (obj, member, value, setter) => {
+var __privateSet$5 = (obj, member, value, setter) => {
   __accessCheck$5(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -1029,11 +1131,11 @@ const _Query = class {
     __privateAdd$5(this, _data, { filter: {} });
     this.meta = { page: { cursor: "start", more: true } };
     this.records = new RecordArray(this, []);
-    __privateSet$4(this, _table$1, table);
+    __privateSet$5(this, _table$1, table);
     if (repository) {
-      __privateSet$4(this, _repository, repository);
+      __privateSet$5(this, _repository, repository);
     } else {
-      __privateSet$4(this, _repository, this);
+      __privateSet$5(this, _repository, this);
     }
     const parent = cleanParent(data, rawParent);
     __privateGet$5(this, _data).filter = data.filter ?? parent?.filter ?? {};
@@ -1088,13 +1190,18 @@ const _Query = class {
       return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
     }
   }
-  sort(column, direction) {
+  sort(column, direction = "asc") {
     const originalSort = [__privateGet$5(this, _data).sort ?? []].flat();
     const sort = [...originalSort, { column, direction }];
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { sort }, __privateGet$5(this, _data));
   }
   select(columns) {
-    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { columns }, __privateGet$5(this, _data));
+    return new _Query(
+      __privateGet$5(this, _repository),
+      __privateGet$5(this, _table$1),
+      { columns },
+      __privateGet$5(this, _data)
+    );
   }
   getPaginated(options = {}) {
     const query = new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), options, __privateGet$5(this, _data));
@@ -1210,7 +1317,7 @@ var __privateAdd$4 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$3 = (obj, member, value, setter) => {
+var __privateSet$4 = (obj, member, value, setter) => {
   __accessCheck$4(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -1219,7 +1326,7 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$4(obj, member, "access private method");
   return method;
 };
-var _table, _getFetchProps, _cache, _schema$1, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _invalidateCache, invalidateCache_fn, _setCacheRecord, setCacheRecord_fn, _getCacheRecord, getCacheRecord_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchema$1, getSchema_fn$1;
+var _table, _getFetchProps, _db, _cache, _schemaTables$2, _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;
 class Repository extends Query {
 }
 class RestRepository extends Query {
@@ -1231,68 +1338,69 @@ class RestRepository extends Query {
     __privateAdd$4(this, _updateRecordWithID);
     __privateAdd$4(this, _upsertRecordWithID);
     __privateAdd$4(this, _deleteRecord);
-    __privateAdd$4(this, _invalidateCache);
-    __privateAdd$4(this, _setCacheRecord);
-    __privateAdd$4(this, _getCacheRecord);
     __privateAdd$4(this, _setCacheQuery);
     __privateAdd$4(this, _getCacheQuery);
-    __privateAdd$4(this, _getSchema$1);
+    __privateAdd$4(this, _getSchemaTables$1);
     __privateAdd$4(this, _table, void 0);
     __privateAdd$4(this, _getFetchProps, void 0);
+    __privateAdd$4(this, _db, void 0);
     __privateAdd$4(this, _cache, void 0);
-    __privateAdd$4(this, _schema$1, void 0);
-    __privateSet$3(this, _table, options.table);
-    __privateSet$3(this, _getFetchProps, options.pluginOptions.getFetchProps);
-    this.db = options.db;
-    __privateSet$3(this, _cache, options.pluginOptions.cache);
-  }
-  async create(a, b) {
+    __privateAdd$4(this, _schemaTables$2, void 0);
+    __privateSet$4(this, _table, options.table);
+    __privateSet$4(this, _getFetchProps, options.pluginOptions.getFetchProps);
+    __privateSet$4(this, _db, options.db);
+    __privateSet$4(this, _cache, options.pluginOptions.cache);
+    __privateSet$4(this, _schemaTables$2, options.schemaTables);
+  }
+  async create(a, b, c) {
     if (Array.isArray(a)) {
       if (a.length === 0)
         return [];
-      const records = await __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a);
-      await Promise.all(records.map((record) => __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record)));
-      return records;
+      const columns = isStringArray(b) ? b : void 0;
+      return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a, columns);
     }
     if (isString(a) && isObject(b)) {
       if (a === "")
         throw new Error("The id can't be empty");
-      const record = await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b);
-      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
-      return record;
+      const columns = isStringArray(c) ? c : void 0;
+      return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b, columns);
     }
     if (isObject(a) && isString(a.id)) {
       if (a.id === "")
         throw new Error("The id can't be empty");
-      const record = await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 });
-      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
-      return record;
+      const columns = isStringArray(b) ? b : void 0;
+      return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns);
     }
     if (isObject(a)) {
-      const record = await __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a);
-      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
-      return record;
+      const columns = isStringArray(b) ? b : void 0;
+      return __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a, columns);
     }
     throw new Error("Invalid arguments for create method");
   }
-  async read(a) {
+  async read(a, b) {
+    const columns = isStringArray(b) ? b : ["*"];
     if (Array.isArray(a)) {
       if (a.length === 0)
         return [];
-      return this.getAll({ filter: { id: { $any: a } } });
+      const ids = a.map((item) => isString(item) ? item : item.id).filter((id2) => isString(id2));
+      const finalObjects = await this.getAll({ filter: { id: { $any: ids } }, columns });
+      const dictionary = finalObjects.reduce((acc, object) => {
+        acc[object.id] = object;
+        return acc;
+      }, {});
+      return ids.map((id2) => dictionary[id2] ?? null);
     }
-    if (isString(a)) {
-      const cacheRecord = await __privateMethod$2(this, _getCacheRecord, getCacheRecord_fn).call(this, a);
-      if (cacheRecord)
-        return cacheRecord;
+    const id = isString(a) ? a : a.id;
+    if (isString(id)) {
       const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
       try {
         const response = await getRecord({
-          pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId: a },
+          pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId: id },
+          queryParams: { columns },
           ...fetchProps
         });
-        const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
-        return initObject(this.db, schema, __privateGet$4(this, _table), response);
+        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);
       } catch (e) {
         if (isObject(e) && e.status === 404) {
           return null;
@@ -1300,50 +1408,45 @@ class RestRepository extends Query {
         throw e;
       }
     }
+    return null;
   }
-  async update(a, b) {
+  async update(a, b, c) {
     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");
       }
-      return Promise.all(a.map((object) => this.update(object)));
+      const columns = isStringArray(b) ? b : ["*"];
+      return Promise.all(a.map((object) => this.update(object, columns)));
     }
     if (isString(a) && isObject(b)) {
-      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a);
-      const record = await __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b);
-      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
-      return record;
+      const columns = isStringArray(c) ? c : void 0;
+      return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b, columns);
     }
     if (isObject(a) && isString(a.id)) {
-      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a.id);
-      const record = await __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
-      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
-      return record;
+      const columns = isStringArray(b) ? b : void 0;
+      return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns);
     }
     throw new Error("Invalid arguments for update method");
   }
-  async createOrUpdate(a, b) {
+  async createOrUpdate(a, b, c) {
     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");
       }
-      return Promise.all(a.map((object) => this.createOrUpdate(object)));
+      const columns = isStringArray(b) ? b : ["*"];
+      return Promise.all(a.map((object) => this.createOrUpdate(object, columns)));
     }
     if (isString(a) && isObject(b)) {
-      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a);
-      const record = await __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b);
-      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
-      return record;
+      const columns = isStringArray(c) ? c : void 0;
+      return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b, columns);
     }
     if (isObject(a) && isString(a.id)) {
-      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a.id);
-      const record = await __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
-      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
-      return record;
+      const columns = isStringArray(c) ? c : void 0;
+      return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 }, columns);
     }
     throw new Error("Invalid arguments for createOrUpdate method");
   }
@@ -1359,12 +1462,10 @@ class RestRepository extends Query {
     }
     if (isString(a)) {
       await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a);
-      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a);
       return;
     }
     if (isObject(a) && isString(a.id)) {
       await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a.id);
-      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a.id);
       return;
     }
     throw new Error("Invalid arguments for delete method");
@@ -1376,13 +1477,15 @@ class RestRepository extends Query {
       body: {
         query,
         fuzziness: options.fuzziness,
+        prefix: options.prefix,
         highlight: options.highlight,
-        filter: options.filter
+        filter: options.filter,
+        boosters: options.boosters
       },
       ...fetchProps
     });
-    const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
-    return records.map((item) => initObject(this.db, schema, __privateGet$4(this, _table), item));
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    return records.map((item) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), item));
   }
   async query(query) {
     const cacheQuery = await __privateMethod$2(this, _getCacheQuery, getCacheQuery_fn).call(this, query);
@@ -1401,18 +1504,19 @@ class RestRepository extends Query {
       body,
       ...fetchProps
     });
-    const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
-    const records = objects.map((record) => initObject(this.db, schema, __privateGet$4(this, _table), record));
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    const records = objects.map((record) => initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), record));
     await __privateMethod$2(this, _setCacheQuery, setCacheQuery_fn).call(this, query, meta, records);
     return new Page(query, meta, records);
   }
 }
 _table = new WeakMap();
 _getFetchProps = new WeakMap();
+_db = new WeakMap();
 _cache = new WeakMap();
-_schema$1 = new WeakMap();
+_schemaTables$2 = new WeakMap();
 _insertRecordWithoutId = new WeakSet();
-insertRecordWithoutId_fn = async function(object) {
+insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecord({
@@ -1421,17 +1525,15 @@ insertRecordWithoutId_fn = async function(object) {
       dbBranchName: "{dbBranch}",
       tableName: __privateGet$4(this, _table)
     },
+    queryParams: { columns },
     body: record,
     ...fetchProps
   });
-  const finalObject = await this.read(response.id);
-  if (!finalObject) {
-    throw new Error("The server failed to save the record");
-  }
-  return finalObject;
+  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);
 };
 _insertRecordWithId = new WeakSet();
-insertRecordWithId_fn = async function(recordId, object) {
+insertRecordWithId_fn = async function(recordId, object, columns = ["*"]) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecordWithID({
@@ -1442,56 +1544,52 @@ insertRecordWithId_fn = async function(recordId, object) {
       recordId
     },
     body: record,
-    queryParams: { createOnly: true },
+    queryParams: { createOnly: true, columns },
     ...fetchProps
   });
-  const finalObject = await this.read(response.id);
-  if (!finalObject) {
-    throw new Error("The server failed to save the record");
-  }
-  return finalObject;
+  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);
 };
 _bulkInsertTableRecords = new WeakSet();
-bulkInsertTableRecords_fn = async function(objects) {
+bulkInsertTableRecords_fn = async function(objects, columns = ["*"]) {
   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}", tableName: __privateGet$4(this, _table) },
+    queryParams: { columns },
     body: { records },
     ...fetchProps
   });
-  const finalObjects = await this.any(...response.recordIDs.map((id) => this.filter("id", id))).getAll();
-  if (finalObjects.length !== objects.length) {
-    throw new Error("The server failed to save some records");
+  if (!isResponseWithRecords(response)) {
+    throw new Error("Request included columns but server didn't include them");
   }
-  return finalObjects;
+  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));
 };
 _updateRecordWithID = new WeakSet();
-updateRecordWithID_fn = async function(recordId, object) {
+updateRecordWithID_fn = async function(recordId, object, columns = ["*"]) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await updateRecordWithID({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
+    queryParams: { columns },
     body: record,
     ...fetchProps
   });
-  const item = await this.read(response.id);
-  if (!item)
-    throw new Error("The server failed to save the record");
-  return item;
+  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);
 };
 _upsertRecordWithID = new WeakSet();
-upsertRecordWithID_fn = async function(recordId, object) {
+upsertRecordWithID_fn = async function(recordId, object, columns = ["*"]) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const response = await upsertRecordWithID({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
+    queryParams: { columns },
     body: object,
     ...fetchProps
   });
-  const item = await this.read(response.id);
-  if (!item)
-    throw new Error("The server failed to save the record");
-  return item;
+  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);
 };
 _deleteRecord = new WeakSet();
 deleteRecord_fn = async function(recordId) {
@@ -1501,29 +1599,6 @@ deleteRecord_fn = async function(recordId) {
     ...fetchProps
   });
 };
-_invalidateCache = new WeakSet();
-invalidateCache_fn = async function(recordId) {
-  await __privateGet$4(this, _cache).delete(`rec_${__privateGet$4(this, _table)}:${recordId}`);
-  const cacheItems = await __privateGet$4(this, _cache).getAll();
-  const queries = Object.entries(cacheItems).filter(([key]) => key.startsWith("query_"));
-  for (const [key, value] of queries) {
-    const ids = getIds(value);
-    if (ids.includes(recordId))
-      await __privateGet$4(this, _cache).delete(key);
-  }
-};
-_setCacheRecord = new WeakSet();
-setCacheRecord_fn = async function(record) {
-  if (!__privateGet$4(this, _cache).cacheRecords)
-    return;
-  await __privateGet$4(this, _cache).set(`rec_${__privateGet$4(this, _table)}:${record.id}`, record);
-};
-_getCacheRecord = new WeakSet();
-getCacheRecord_fn = async function(recordId) {
-  if (!__privateGet$4(this, _cache).cacheRecords)
-    return null;
-  return __privateGet$4(this, _cache).get(`rec_${__privateGet$4(this, _table)}:${recordId}`);
-};
 _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 });
@@ -1540,17 +1615,17 @@ getCacheQuery_fn = async function(query) {
   const hasExpired = result.date.getTime() + ttl < Date.now();
   return hasExpired ? null : result;
 };
-_getSchema$1 = new WeakSet();
-getSchema_fn$1 = async function() {
-  if (__privateGet$4(this, _schema$1))
-    return __privateGet$4(this, _schema$1);
+_getSchemaTables$1 = new WeakSet();
+getSchemaTables_fn$1 = async function() {
+  if (__privateGet$4(this, _schemaTables$2))
+    return __privateGet$4(this, _schemaTables$2);
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const { schema } = await getBranchDetails({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
     ...fetchProps
   });
-  __privateSet$3(this, _schema$1, schema);
-  return schema;
+  __privateSet$4(this, _schemaTables$2, schema.tables);
+  return schema.tables;
 };
 const transformObjectLinks = (object) => {
   return Object.entries(object).reduce((acc, [key, value]) => {
@@ -1559,11 +1634,11 @@ const transformObjectLinks = (object) => {
     return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
   }, {});
 };
-const initObject = (db, schema, table, object) => {
+const initObject = (db, schemaTables, table, object) => {
   const result = {};
   const { xata, ...rest } = object ?? {};
   Object.assign(result, rest);
-  const { columns } = schema.tables.find(({ name }) => name === table) ?? {};
+  const { columns } = schemaTables.find(({ name }) => name === table) ?? {};
   if (!columns)
     console.error(`Table ${table} not found in schema`);
   for (const column of columns ?? []) {
@@ -1583,17 +1658,17 @@ const initObject = (db, schema, table, object) => {
         if (!linkTable) {
           console.error(`Failed to parse link for field ${column.name}`);
         } else if (isObject(value)) {
-          result[column.name] = initObject(db, schema, linkTable, value);
+          result[column.name] = initObject(db, schemaTables, linkTable, value);
         }
         break;
       }
     }
   }
-  result.read = function() {
-    return db[table].read(result["id"]);
+  result.read = function(columns2) {
+    return db[table].read(result["id"], columns2);
   };
-  result.update = function(data) {
-    return db[table].update(result["id"], data);
+  result.update = function(data, columns2) {
+    return db[table].update(result["id"], data, columns2);
   };
   result.delete = function() {
     return db[table].delete(result["id"]);
@@ -1607,14 +1682,8 @@ const initObject = (db, schema, table, object) => {
   Object.freeze(result);
   return result;
 };
-function getIds(value) {
-  if (Array.isArray(value)) {
-    return value.map((item) => getIds(item)).flat();
-  }
-  if (!isObject(value))
-    return [];
-  const nestedIds = Object.values(value).map((item) => getIds(item)).flat();
-  return isString(value.id) ? [value.id, ...nestedIds] : nestedIds;
+function isResponseWithRecords(value) {
+  return isObject(value) && Array.isArray(value.records);
 }
 
 var __accessCheck$3 = (obj, member, msg) => {
@@ -1630,7 +1699,7 @@ var __privateAdd$3 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$2 = (obj, member, value, setter) => {
+var __privateSet$3 = (obj, member, value, setter) => {
   __accessCheck$3(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -1639,9 +1708,8 @@ var _map;
 class SimpleCache {
   constructor(options = {}) {
     __privateAdd$3(this, _map, void 0);
-    __privateSet$2(this, _map, /* @__PURE__ */ new Map());
+    __privateSet$3(this, _map, /* @__PURE__ */ new Map());
     this.capacity = options.max ?? 500;
-    this.cacheRecords = options.cacheRecords ?? true;
     this.defaultQueryTTL = options.defaultQueryTTL ?? 60 * 1e3;
   }
   async getAll() {
@@ -1699,31 +1767,42 @@ var __privateAdd$2 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var _tables;
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _tables, _schemaTables$1;
 class SchemaPlugin extends XataPlugin {
-  constructor(tableNames) {
+  constructor(schemaTables) {
     super();
-    this.tableNames = tableNames;
     __privateAdd$2(this, _tables, {});
+    __privateAdd$2(this, _schemaTables$1, void 0);
+    __privateSet$2(this, _schemaTables$1, schemaTables);
   }
   build(pluginOptions) {
-    const db = new Proxy({}, {
-      get: (_target, table) => {
-        if (!isString(table))
-          throw new Error("Invalid table name");
-        if (__privateGet$2(this, _tables)[table] === void 0) {
-          __privateGet$2(this, _tables)[table] = new RestRepository({ db, pluginOptions, table });
+    const db = new Proxy(
+      {},
+      {
+        get: (_target, table) => {
+          if (!isString(table))
+            throw new Error("Invalid table name");
+          if (__privateGet$2(this, _tables)[table] === void 0) {
+            __privateGet$2(this, _tables)[table] = new RestRepository({ db, pluginOptions, table, schemaTables: __privateGet$2(this, _schemaTables$1) });
+          }
+          return __privateGet$2(this, _tables)[table];
         }
-        return __privateGet$2(this, _tables)[table];
       }
-    });
-    for (const table of this.tableNames ?? []) {
-      db[table] = new RestRepository({ db, pluginOptions, table });
+    );
+    const tableNames = __privateGet$2(this, _schemaTables$1)?.map(({ name }) => name) ?? [];
+    for (const table of tableNames) {
+      db[table] = new RestRepository({ db, pluginOptions, table, schemaTables: __privateGet$2(this, _schemaTables$1) });
     }
     return db;
   }
 }
 _tables = new WeakMap();
+_schemaTables$1 = new WeakMap();
 
 var __accessCheck$1 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -1747,82 +1826,77 @@ var __privateMethod$1 = (obj, member, method) => {
   __accessCheck$1(obj, member, "access private method");
   return method;
 };
-var _schema, _search, search_fn, _getSchema, getSchema_fn;
+var _schemaTables, _search, search_fn, _getSchemaTables, getSchemaTables_fn;
 class SearchPlugin extends XataPlugin {
-  constructor(db) {
+  constructor(db, schemaTables) {
     super();
     this.db = db;
     __privateAdd$1(this, _search);
-    __privateAdd$1(this, _getSchema);
-    __privateAdd$1(this, _schema, void 0);
+    __privateAdd$1(this, _getSchemaTables);
+    __privateAdd$1(this, _schemaTables, void 0);
+    __privateSet$1(this, _schemaTables, schemaTables);
   }
   build({ getFetchProps }) {
     return {
       all: async (query, options = {}) => {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
-        const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, getFetchProps);
         return records.map((record) => {
           const { table = "orphan" } = record.xata;
-          return { table, record: initObject(this.db, schema, table, record) };
+          return { table, record: initObject(this.db, schemaTables, table, record) };
         });
       },
       byTable: async (query, options = {}) => {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
-        const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, getFetchProps);
         return records.reduce((acc, record) => {
           const { table = "orphan" } = record.xata;
           const items = acc[table] ?? [];
-          const item = initObject(this.db, schema, table, record);
+          const item = initObject(this.db, schemaTables, table, record);
           return { ...acc, [table]: [...items, item] };
         }, {});
       }
     };
   }
 }
-_schema = new WeakMap();
+_schemaTables = new WeakMap();
 _search = new WeakSet();
 search_fn = async function(query, options, getFetchProps) {
   const fetchProps = await getFetchProps();
-  const { tables, fuzziness, highlight } = options ?? {};
+  const { tables, fuzziness, highlight, prefix } = options ?? {};
   const { records } = await searchBranch({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-    body: { tables, query, fuzziness, highlight },
+    body: { tables, query, fuzziness, prefix, highlight },
     ...fetchProps
   });
   return records;
 };
-_getSchema = new WeakSet();
-getSchema_fn = async function(getFetchProps) {
-  if (__privateGet$1(this, _schema))
-    return __privateGet$1(this, _schema);
+_getSchemaTables = new WeakSet();
+getSchemaTables_fn = async function(getFetchProps) {
+  if (__privateGet$1(this, _schemaTables))
+    return __privateGet$1(this, _schemaTables);
   const fetchProps = await getFetchProps();
   const { schema } = await getBranchDetails({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
     ...fetchProps
   });
-  __privateSet$1(this, _schema, schema);
-  return schema;
+  __privateSet$1(this, _schemaTables, schema.tables);
+  return schema.tables;
 };
 
 const isBranchStrategyBuilder = (strategy) => {
   return typeof strategy === "function";
 };
 
-const envBranchNames = [
-  "XATA_BRANCH",
-  "VERCEL_GIT_COMMIT_REF",
-  "CF_PAGES_BRANCH",
-  "BRANCH"
-];
 async function getCurrentBranchName(options) {
-  const env = getBranchByEnvVariable();
-  if (env) {
-    const details = await getDatabaseBranch(env, options);
+  const { branch, envBranch } = getEnvironment();
+  if (branch) {
+    const details = await getDatabaseBranch(branch, options);
     if (details)
-      return env;
-    console.warn(`Branch ${env} not found in Xata. Ignoring...`);
+      return branch;
+    console.warn(`Branch ${branch} not found in Xata. Ignoring...`);
   }
-  const gitBranch = await getGitBranch();
+  const gitBranch = envBranch || await getGitBranch();
   return resolveXataBranch(gitBranch, options);
 }
 async function getCurrentBranchDetails(options) {
@@ -1833,18 +1907,23 @@ async function resolveXataBranch(gitBranch, options) {
   const databaseURL = options?.databaseURL || getDatabaseURL();
   const apiKey = options?.apiKey || getAPIKey();
   if (!databaseURL)
-    throw new Error("A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely");
+    throw new Error(
+      "A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely"
+    );
   if (!apiKey)
-    throw new Error("An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely");
+    throw new Error(
+      "An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely"
+    );
   const [protocol, , host, , dbName] = databaseURL.split("/");
   const [workspace] = host.split(".");
+  const { fallbackBranch } = getEnvironment();
   const { branch } = await resolveBranch({
     apiKey,
     apiUrl: databaseURL,
     fetchImpl: getFetchImplementation(options?.fetchImpl),
     workspacesApiUrl: `${protocol}//${host}`,
     pathParams: { dbName, workspace },
-    queryParams: { gitBranch, fallbackBranch: getEnvVariable("XATA_FALLBACK_BRANCH") }
+    queryParams: { gitBranch, fallbackBranch }
   });
   return branch;
 }
@@ -1852,9 +1931,13 @@ async function getDatabaseBranch(branch, options) {
   const databaseURL = options?.databaseURL || getDatabaseURL();
   const apiKey = options?.apiKey || getAPIKey();
   if (!databaseURL)
-    throw new Error("A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely");
+    throw new Error(
+      "A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely"
+    );
   if (!apiKey)
-    throw new Error("An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely");
+    throw new Error(
+      "An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely"
+    );
   const [protocol, , host, , database] = databaseURL.split("/");
   const [workspace] = host.split(".");
   const dbBranchName = `${database}:${branch}`;
@@ -1864,10 +1947,7 @@ async function getDatabaseBranch(branch, options) {
       apiUrl: databaseURL,
       fetchImpl: getFetchImplementation(options?.fetchImpl),
       workspacesApiUrl: `${protocol}//${host}`,
-      pathParams: {
-        dbBranchName,
-        workspace
-      }
+      pathParams: { dbBranchName, workspace }
     });
   } catch (err) {
     if (isObject(err) && err.status === 404)
@@ -1875,21 +1955,10 @@ async function getDatabaseBranch(branch, options) {
     throw err;
   }
 }
-function getBranchByEnvVariable() {
-  for (const name of envBranchNames) {
-    const value = getEnvVariable(name);
-    if (value) {
-      return value;
-    }
-  }
-  try {
-    return XATA_BRANCH;
-  } catch (err) {
-  }
-}
 function getDatabaseURL() {
   try {
-    return getEnvVariable("XATA_DATABASE_URL") ?? XATA_DATABASE_URL;
+    const { databaseURL } = getEnvironment();
+    return databaseURL;
   } catch (err) {
     return void 0;
   }
@@ -1918,20 +1987,22 @@ var __privateMethod = (obj, member, method) => {
   return method;
 };
 const buildClient = (plugins) => {
-  var _branch, _parseOptions, parseOptions_fn, _getFetchProps, getFetchProps_fn, _evaluateBranch, evaluateBranch_fn, _a;
+  var _branch, _options, _parseOptions, parseOptions_fn, _getFetchProps, getFetchProps_fn, _evaluateBranch, evaluateBranch_fn, _a;
   return _a = class {
-    constructor(options = {}, tables) {
+    constructor(options = {}, schemaTables) {
       __privateAdd(this, _parseOptions);
       __privateAdd(this, _getFetchProps);
       __privateAdd(this, _evaluateBranch);
       __privateAdd(this, _branch, void 0);
+      __privateAdd(this, _options, void 0);
       const safeOptions = __privateMethod(this, _parseOptions, parseOptions_fn).call(this, options);
+      __privateSet(this, _options, safeOptions);
       const pluginOptions = {
         getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions),
         cache: safeOptions.cache
       };
-      const db = new SchemaPlugin(tables).build(pluginOptions);
-      const search = new SearchPlugin(db).build(pluginOptions);
+      const db = new SchemaPlugin(schemaTables).build(pluginOptions);
+      const search = new SearchPlugin(db, schemaTables).build(pluginOptions);
       this.db = db;
       this.search = search;
       for (const [key, namespace] of Object.entries(plugins ?? {})) {
@@ -1947,22 +2018,22 @@ const buildClient = (plugins) => {
         }
       }
     }
-  }, _branch = new WeakMap(), _parseOptions = new WeakSet(), parseOptions_fn = function(options) {
+    async getConfig() {
+      const databaseURL = __privateGet(this, _options).databaseURL;
+      const branch = await __privateGet(this, _options).branch();
+      return { databaseURL, branch };
+    }
+  }, _branch = new WeakMap(), _options = new WeakMap(), _parseOptions = new WeakSet(), parseOptions_fn = function(options) {
     const fetch = getFetchImplementation(options?.fetch);
     const databaseURL = options?.databaseURL || getDatabaseURL();
     const apiKey = options?.apiKey || getAPIKey();
-    const cache = options?.cache ?? new SimpleCache({ cacheRecords: false, defaultQueryTTL: 0 });
+    const cache = options?.cache ?? new SimpleCache({ defaultQueryTTL: 0 });
     const branch = async () => options?.branch !== void 0 ? await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, options.branch) : await getCurrentBranchName({ apiKey, databaseURL, fetchImpl: options?.fetch });
     if (!databaseURL || !apiKey) {
       throw new Error("Options databaseURL and apiKey are required");
     }
     return { fetch, databaseURL, apiKey, branch, cache };
-  }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({
-    fetch,
-    apiKey,
-    databaseURL,
-    branch
-  }) {
+  }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({ fetch, apiKey, databaseURL, branch }) {
     const branchValue = await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, branch);
     if (!branchValue)
       throw new Error("Unable to resolve branch value");
@@ -1997,6 +2068,88 @@ const buildClient = (plugins) => {
 class BaseClient extends buildClient() {
 }
 
+const META = "__";
+const VALUE = "___";
+class Serializer {
+  constructor() {
+    this.classes = {};
+  }
+  add(clazz) {
+    this.classes[clazz.name] = clazz;
+  }
+  toJSON(data) {
+    function visit(obj) {
+      if (Array.isArray(obj))
+        return obj.map(visit);
+      const type = typeof obj;
+      if (type === "undefined")
+        return { [META]: "undefined" };
+      if (type === "bigint")
+        return { [META]: "bigint", [VALUE]: obj.toString() };
+      if (obj === null || type !== "object")
+        return obj;
+      const constructor = obj.constructor;
+      const o = { [META]: constructor.name };
+      for (const [key, value] of Object.entries(obj)) {
+        o[key] = visit(value);
+      }
+      if (constructor === Date)
+        o[VALUE] = obj.toISOString();
+      if (constructor === Map)
+        o[VALUE] = Object.fromEntries(obj);
+      if (constructor === Set)
+        o[VALUE] = [...obj];
+      return o;
+    }
+    return JSON.stringify(visit(data));
+  }
+  fromJSON(json) {
+    return JSON.parse(json, (key, value) => {
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const { [META]: clazz, [VALUE]: val, ...rest } = value;
+        const constructor = this.classes[clazz];
+        if (constructor) {
+          return Object.assign(Object.create(constructor.prototype), rest);
+        }
+        if (clazz === "Date")
+          return new Date(val);
+        if (clazz === "Set")
+          return new Set(val);
+        if (clazz === "Map")
+          return new Map(Object.entries(val));
+        if (clazz === "bigint")
+          return BigInt(val);
+        if (clazz === "undefined")
+          return void 0;
+        return rest;
+      }
+      return value;
+    });
+  }
+}
+const defaultSerializer = new Serializer();
+const serialize = (data) => {
+  return defaultSerializer.toJSON(data);
+};
+const deserialize = (json) => {
+  return defaultSerializer.fromJSON(json);
+};
+
+function buildWorkerRunner(config) {
+  return function xataWorker(name, _worker) {
+    return async (...args) => {
+      const url = process.env.NODE_ENV === "development" ? `http://localhost:64749/${name}` : `https://dispatcher.xata.workers.dev/${config.workspace}/${config.worker}/${name}`;
+      const result = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: serialize({ args })
+      });
+      const text = await result.text();
+      return deserialize(text);
+    };
+  };
+}
+
 class XataError extends Error {
   constructor(message, status) {
     super(message);
@@ -2004,5 +2157,5 @@ class XataError extends Error {
   }
 }
 
-export { BaseClient, operationsByTag as Operations, PAGINATION_DEFAULT_OFFSET, PAGINATION_DEFAULT_SIZE, PAGINATION_MAX_OFFSET, PAGINATION_MAX_SIZE, Page, Query, RecordArray, Repository, RestRepository, SchemaPlugin, SearchPlugin, SimpleCache, XataApiClient, XataApiPlugin, XataError, XataPlugin, acceptWorkspaceMemberInvite, addGitBranchesEntry, addTableColumn, buildClient, bulkInsertTableRecords, cancelWorkspaceMemberInvite, contains, createBranch, createDatabase, createTable, createUserAPIKey, createWorkspace, deleteBranch, deleteColumn, deleteDatabase, deleteRecord, deleteTable, deleteUser, deleteUserAPIKey, deleteWorkspace, endsWith, executeBranchMigrationPlan, exists, ge, getAPIKey, getBranchDetails, getBranchList, getBranchMetadata, getBranchMigrationHistory, getBranchMigrationPlan, getBranchStats, getColumn, getCurrentBranchDetails, getCurrentBranchName, getDatabaseList, getDatabaseURL, getGitBranchesMapping, getRecord, getTableColumns, getTableSchema, getUser, getUserAPIKeys, getWorkspace, getWorkspaceMembersList, getWorkspacesList, gt, gte, includes, includesAll, includesAny, includesNone, insertRecord, insertRecordWithID, inviteWorkspaceMember, is, isCursorPaginationOptions, isIdentifiable, isNot, isXataRecord, le, lt, lte, notExists, operationsByTag, pattern, queryTable, removeGitBranchesEntry, removeWorkspaceMember, resendWorkspaceMemberInvite, resolveBranch, searchBranch, searchTable, setTableSchema, startsWith, updateBranchMetadata, updateColumn, updateRecordWithID, updateTable, updateUser, updateWorkspace, updateWorkspaceMemberRole, upsertRecordWithID };
+export { BaseClient, operationsByTag as Operations, PAGINATION_DEFAULT_OFFSET, PAGINATION_DEFAULT_SIZE, PAGINATION_MAX_OFFSET, PAGINATION_MAX_SIZE, Page, Query, RecordArray, Repository, RestRepository, SchemaPlugin, SearchPlugin, Serializer, SimpleCache, XataApiClient, XataApiPlugin, XataError, XataPlugin, acceptWorkspaceMemberInvite, addGitBranchesEntry, addTableColumn, buildClient, buildWorkerRunner, bulkInsertTableRecords, cancelWorkspaceMemberInvite, contains, createBranch, createDatabase, createTable, createUserAPIKey, createWorkspace, deleteBranch, deleteColumn, deleteDatabase, deleteRecord, deleteTable, deleteUser, deleteUserAPIKey, deleteWorkspace, deserialize, endsWith, executeBranchMigrationPlan, exists, ge, getAPIKey, getBranchDetails, getBranchList, getBranchMetadata, getBranchMigrationHistory, getBranchMigrationPlan, getBranchStats, getColumn, getCurrentBranchDetails, getCurrentBranchName, getDatabaseList, getDatabaseMetadata, getDatabaseURL, getGitBranchesMapping, getRecord, getTableColumns, getTableSchema, getUser, getUserAPIKeys, getWorkspace, getWorkspaceMembersList, getWorkspacesList, gt, gte, includes, includesAll, includesAny, includesNone, insertRecord, insertRecordWithID, inviteWorkspaceMember, is, isCursorPaginationOptions, isIdentifiable, isNot, isXataRecord, le, lt, lte, notExists, operationsByTag, pattern, queryTable, removeGitBranchesEntry, removeWorkspaceMember, resendWorkspaceMemberInvite, resolveBranch, searchBranch, searchTable, serialize, setTableSchema, startsWith, updateBranchMetadata, updateColumn, updateRecordWithID, updateTable, updateUser, updateWorkspace, updateWorkspaceMemberInvite, updateWorkspaceMemberRole, upsertRecordWithID };
 //# sourceMappingURL=index.mjs.map