@xata.io/client 0.8.3 → 0.9.1

package/dist/index.cjs

@@ -14,17 +14,23 @@ function isObject(value) {
 function isString(value) {
   return value !== void 0 && value !== null && typeof value === "string";
 }
+function toBase64(value) {
+  try {
+    return btoa(value);
+  } catch (err) {
+    return Buffer.from(value).toString("base64");
+  }
+}
 
 function getEnvVariable(name) {
-  var _a, _b;
   try {
-    if (isObject(process) && isString((_a = process == null ? void 0 : process.env) == null ? void 0 : _a[name])) {
+    if (isObject(process) && isString(process?.env?.[name])) {
       return process.env[name];
     }
   } catch (err) {
   }
   try {
-    if (isObject(Deno) && isString((_b = Deno == null ? void 0 : Deno.env) == null ? void 0 : _b.get(name))) {
+    if (isObject(Deno) && isString(Deno?.env?.get(name))) {
       return Deno.env.get(name);
     }
   } catch (err) {
@@ -32,7 +38,10 @@ function getEnvVariable(name) {
 }
 async function getGitBranch() {
   try {
-    return require("child_process").execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    if (typeof require === "function") {
+      const req = require;
+      return req("child_process").execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    }
   } catch (err) {
   }
   try {
@@ -48,99 +57,51 @@ async function getGitBranch() {
   }
 }
 
+function getAPIKey() {
+  try {
+    return getEnvVariable("XATA_API_KEY") ?? XATA_API_KEY;
+  } catch (err) {
+    return void 0;
+  }
+}
+
 function getFetchImplementation(userFetch) {
   const globalFetch = typeof fetch !== "undefined" ? fetch : void 0;
-  const fetchImpl = userFetch != null ? userFetch : globalFetch;
+  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.`);
   }
   return fetchImpl;
 }
 
-const envBranchNames = [
-  "XATA_BRANCH",
-  "VERCEL_GIT_COMMIT_REF",
-  "CF_PAGES_BRANCH",
-  "BRANCH"
-];
-const defaultBranch = "main";
-async function getCurrentBranchName(options) {
-  const env = await getBranchByEnvVariable();
-  if (env)
-    return env;
-  const branch = await getGitBranch();
-  if (!branch)
-    return defaultBranch;
-  const details = await getDatabaseBranch(branch, options);
-  if (details)
-    return branch;
-  return defaultBranch;
-}
-async function getCurrentBranchDetails(options) {
-  const env = await getBranchByEnvVariable();
-  if (env)
-    return getDatabaseBranch(env, options);
-  const branch = await getGitBranch();
-  if (!branch)
-    return getDatabaseBranch(defaultBranch, options);
-  const details = await getDatabaseBranch(branch, options);
-  if (details)
-    return details;
-  return getDatabaseBranch(defaultBranch, options);
-}
-async function getDatabaseBranch(branch, options) {
-  const databaseURL = (options == null ? void 0 : options.databaseURL) || getDatabaseURL();
-  const apiKey = (options == null ? void 0 : 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");
-  if (!apiKey)
-    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}`;
-  try {
-    return await getBranchDetails({
-      apiKey,
-      apiUrl: databaseURL,
-      fetchImpl: getFetchImplementation(options == null ? void 0 : options.fetchImpl),
-      workspacesApiUrl: `${protocol}//${host}`,
-      pathParams: {
-        dbBranchName,
-        workspace
-      }
-    });
-  } catch (err) {
-    if (isObject(err) && err.status === 404)
-      return null;
-    throw err;
-  }
-}
-function getBranchByEnvVariable() {
-  for (const name of envBranchNames) {
-    const value = getEnvVariable(name);
-    if (value) {
-      return value;
+class FetcherError extends Error {
+  constructor(status, data) {
+    super(getMessage(data));
+    this.status = status;
+    this.errors = isBulkError(data) ? data.errors : void 0;
+    if (data instanceof Error) {
+      this.stack = data.stack;
+      this.cause = data.cause;
     }
   }
-  try {
-    return XATA_BRANCH;
-  } catch (err) {
-  }
 }
-function getDatabaseURL() {
-  var _a;
-  try {
-    return (_a = getEnvVariable("XATA_DATABASE_URL")) != null ? _a : XATA_DATABASE_URL;
-  } catch (err) {
-    return void 0;
-  }
+function isBulkError(error) {
+  return isObject(error) && Array.isArray(error.errors);
 }
-function getAPIKey() {
-  var _a;
-  try {
-    return (_a = getEnvVariable("XATA_API_KEY")) != null ? _a : XATA_API_KEY;
-  } catch (err) {
-    return void 0;
+function isErrorWithMessage(error) {
+  return isObject(error) && isString(error.message);
+}
+function getMessage(data) {
+  if (data instanceof Error) {
+    return data.message;
+  } else if (isString(data)) {
+    return data;
+  } else if (isErrorWithMessage(data)) {
+    return data.message;
+  } else if (isBulkError(data)) {
+    return "Bulk operation failed";
+  } else {
+    return "Unexpected error";
   }
 }
 
@@ -155,16 +116,15 @@ function buildBaseUrl({
   apiUrl,
   pathParams
 }) {
-  if (!(pathParams == null ? void 0 : pathParams.workspace))
+  if (!pathParams?.workspace)
     return `${apiUrl}${path}`;
   const url = typeof workspacesApiUrl === "string" ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
   return url.replace("{workspaceId}", pathParams.workspace);
 }
 function hostHeader(url) {
-  var _a;
   const pattern = /.*:\/\/(?<host>[^/]+).*/;
-  const { groups } = (_a = pattern.exec(url)) != null ? _a : {};
-  return (groups == null ? void 0 : groups.host) ? { Host: groups.host } : {};
+  const { groups } = pattern.exec(url) ?? {};
+  return groups?.host ? { Host: groups.host } : {};
 }
 async function fetch$1({
   url: path,
@@ -199,33 +159,20 @@ async function fetch$1({
     if (response.ok) {
       return jsonResponse;
     }
-    const { message = "Unknown error", errors } = jsonResponse;
-    throw new FetcherError({ message, status: response.status, errors });
+    throw new FetcherError(response.status, jsonResponse);
   } catch (error) {
-    const message = hasMessage(error) ? error.message : "Unknown network error";
-    const parent = error instanceof Error ? error : void 0;
-    throw new FetcherError({ message, status: response.status }, parent);
-  }
-}
-const hasMessage = (error) => {
-  return isObject(error) && isString(error.message);
-};
-class FetcherError extends Error {
-  constructor(data, parent) {
-    super(data.message);
-    this.status = data.status;
-    this.errors = data.errors;
-    if (parent) {
-      this.stack = parent.stack;
-      this.cause = parent.cause;
-    }
+    throw new FetcherError(response.status, error);
   }
 }
 
 const getUser = (variables) => fetch$1({ url: "/user", method: "get", ...variables });
 const updateUser = (variables) => fetch$1({ url: "/user", method: "put", ...variables });
 const deleteUser = (variables) => fetch$1({ url: "/user", method: "delete", ...variables });
-const getUserAPIKeys = (variables) => fetch$1({ url: "/user/keys", method: "get", ...variables });
+const getUserAPIKeys = (variables) => fetch$1({
+  url: "/user/keys",
+  method: "get",
+  ...variables
+});
 const createUserAPIKey = (variables) => fetch$1({
   url: "/user/keys/{keyName}",
   method: "post",
@@ -236,8 +183,16 @@ const deleteUserAPIKey = (variables) => fetch$1({
   method: "delete",
   ...variables
 });
-const createWorkspace = (variables) => fetch$1({ url: "/workspaces", method: "post", ...variables });
-const getWorkspacesList = (variables) => fetch$1({ url: "/workspaces", method: "get", ...variables });
+const createWorkspace = (variables) => fetch$1({
+  url: "/workspaces",
+  method: "post",
+  ...variables
+});
+const getWorkspacesList = (variables) => fetch$1({
+  url: "/workspaces",
+  method: "get",
+  ...variables
+});
 const getWorkspace = (variables) => fetch$1({
   url: "/workspaces/{workspaceId}",
   method: "get",
@@ -258,21 +213,13 @@ const getWorkspaceMembersList = (variables) => fetch$1({
   method: "get",
   ...variables
 });
-const updateWorkspaceMemberRole = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/members/{userId}",
-  method: "put",
-  ...variables
-});
+const updateWorkspaceMemberRole = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables });
 const removeWorkspaceMember = (variables) => fetch$1({
   url: "/workspaces/{workspaceId}/members/{userId}",
   method: "delete",
   ...variables
 });
-const inviteWorkspaceMember = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites",
-  method: "post",
-  ...variables
-});
+const inviteWorkspaceMember = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables });
 const cancelWorkspaceMemberInvite = (variables) => fetch$1({
   url: "/workspaces/{workspaceId}/invites/{inviteId}",
   method: "delete",
@@ -308,6 +255,14 @@ const deleteDatabase = (variables) => fetch$1({
   method: "delete",
   ...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 });
+const resolveBranch = (variables) => fetch$1({
+  url: "/dbs/{dbName}/resolveBranch",
+  method: "get",
+  ...variables
+});
 const getBranchDetails = (variables) => fetch$1({
   url: "/db/{dbBranchName}",
   method: "get",
@@ -334,16 +289,8 @@ const getBranchMetadata = (variables) => fetch$1({
   ...variables
 });
 const getBranchMigrationHistory = (variables) => fetch$1({ url: "/db/{dbBranchName}/migrations", method: "get", ...variables });
-const executeBranchMigrationPlan = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/migrations/execute",
-  method: "post",
-  ...variables
-});
-const getBranchMigrationPlan = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/migrations/plan",
-  method: "post",
-  ...variables
-});
+const executeBranchMigrationPlan = (variables) => fetch$1({ url: "/db/{dbBranchName}/migrations/execute", method: "post", ...variables });
+const getBranchMigrationPlan = (variables) => fetch$1({ url: "/db/{dbBranchName}/migrations/plan", method: "post", ...variables });
 const getBranchStats = (variables) => fetch$1({
   url: "/db/{dbBranchName}/stats",
   method: "get",
@@ -417,11 +364,7 @@ const getRecord = (variables) => fetch$1({
   method: "get",
   ...variables
 });
-const bulkInsertTableRecords = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/bulk",
-  method: "post",
-  ...variables
-});
+const bulkInsertTableRecords = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/bulk", method: "post", ...variables });
 const queryTable = (variables) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/query",
   method: "post",
@@ -448,7 +391,15 @@ const operationsByTag = {
     resendWorkspaceMemberInvite,
     acceptWorkspaceMemberInvite
   },
-  database: { getDatabaseList, createDatabase, deleteDatabase },
+  database: {
+    getDatabaseList,
+    createDatabase,
+    deleteDatabase,
+    getGitBranchesMapping,
+    addGitBranchesEntry,
+    removeGitBranchesEntry,
+    resolveBranch
+  },
   branch: {
     getBranchList,
     getBranchDetails,
@@ -511,36 +462,35 @@ function isValidBuilder(builder) {
   return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
 }
 
-var __accessCheck$6 = (obj, member, msg) => {
+var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$5 = (obj, member, getter) => {
-  __accessCheck$6(obj, member, "read from private field");
+var __privateGet$6 = (obj, member, getter) => {
+  __accessCheck$7(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$6 = (obj, member, value) => {
+var __privateAdd$7 = (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$4 = (obj, member, value, setter) => {
-  __accessCheck$6(obj, member, "write to private field");
+var __privateSet$5 = (obj, member, value, setter) => {
+  __accessCheck$7(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _extraProps, _namespaces;
 class XataApiClient {
-  constructor(options) {
-    __privateAdd$6(this, _extraProps, void 0);
-    __privateAdd$6(this, _namespaces, {});
-    var _a, _b;
-    const provider = (_a = options.host) != null ? _a : "production";
-    const apiKey = (_b = options == null ? void 0 : options.apiKey) != null ? _b : getAPIKey();
+  constructor(options = {}) {
+    __privateAdd$7(this, _extraProps, void 0);
+    __privateAdd$7(this, _namespaces, {});
+    const provider = options.host ?? "production";
+    const apiKey = options?.apiKey ?? getAPIKey();
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
-    __privateSet$4(this, _extraProps, {
+    __privateSet$5(this, _extraProps, {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
       fetchImpl: getFetchImplementation(options.fetch),
@@ -548,34 +498,34 @@ class XataApiClient {
     });
   }
   get user() {
-    if (!__privateGet$5(this, _namespaces).user)
-      __privateGet$5(this, _namespaces).user = new UserApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).user;
+    if (!__privateGet$6(this, _namespaces).user)
+      __privateGet$6(this, _namespaces).user = new UserApi(__privateGet$6(this, _extraProps));
+    return __privateGet$6(this, _namespaces).user;
   }
   get workspaces() {
-    if (!__privateGet$5(this, _namespaces).workspaces)
-      __privateGet$5(this, _namespaces).workspaces = new WorkspaceApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).workspaces;
+    if (!__privateGet$6(this, _namespaces).workspaces)
+      __privateGet$6(this, _namespaces).workspaces = new WorkspaceApi(__privateGet$6(this, _extraProps));
+    return __privateGet$6(this, _namespaces).workspaces;
   }
   get databases() {
-    if (!__privateGet$5(this, _namespaces).databases)
-      __privateGet$5(this, _namespaces).databases = new DatabaseApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).databases;
+    if (!__privateGet$6(this, _namespaces).databases)
+      __privateGet$6(this, _namespaces).databases = new DatabaseApi(__privateGet$6(this, _extraProps));
+    return __privateGet$6(this, _namespaces).databases;
   }
   get branches() {
-    if (!__privateGet$5(this, _namespaces).branches)
-      __privateGet$5(this, _namespaces).branches = new BranchApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).branches;
+    if (!__privateGet$6(this, _namespaces).branches)
+      __privateGet$6(this, _namespaces).branches = new BranchApi(__privateGet$6(this, _extraProps));
+    return __privateGet$6(this, _namespaces).branches;
   }
   get tables() {
-    if (!__privateGet$5(this, _namespaces).tables)
-      __privateGet$5(this, _namespaces).tables = new TableApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).tables;
+    if (!__privateGet$6(this, _namespaces).tables)
+      __privateGet$6(this, _namespaces).tables = new TableApi(__privateGet$6(this, _extraProps));
+    return __privateGet$6(this, _namespaces).tables;
   }
   get records() {
-    if (!__privateGet$5(this, _namespaces).records)
-      __privateGet$5(this, _namespaces).records = new RecordsApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).records;
+    if (!__privateGet$6(this, _namespaces).records)
+      __privateGet$6(this, _namespaces).records = new RecordsApi(__privateGet$6(this, _extraProps));
+    return __privateGet$6(this, _namespaces).records;
   }
 }
 _extraProps = new WeakMap();
@@ -709,6 +659,33 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
+  getGitBranchesMapping(workspace, dbName) {
+    return operationsByTag.database.getGitBranchesMapping({
+      pathParams: { workspace, dbName },
+      ...this.extraProps
+    });
+  }
+  addGitBranchesEntry(workspace, dbName, body) {
+    return operationsByTag.database.addGitBranchesEntry({
+      pathParams: { workspace, dbName },
+      body,
+      ...this.extraProps
+    });
+  }
+  removeGitBranchesEntry(workspace, dbName, gitBranch) {
+    return operationsByTag.database.removeGitBranchesEntry({
+      pathParams: { workspace, dbName },
+      queryParams: { gitBranch },
+      ...this.extraProps
+    });
+  }
+  resolveBranch(workspace, dbName, gitBranch) {
+    return operationsByTag.database.resolveBranch({
+      pathParams: { workspace, dbName },
+      queryParams: { gitBranch },
+      ...this.extraProps
+    });
+  }
 }
 class BranchApi {
   constructor(extraProps) {
@@ -930,43 +907,43 @@ class XataApiPlugin {
 class XataPlugin {
 }
 
-var __accessCheck$5 = (obj, member, msg) => {
+var __accessCheck$6 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$5(obj, member, "read from private field");
+var __privateGet$5 = (obj, member, getter) => {
+  __accessCheck$6(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$5 = (obj, member, value) => {
+var __privateAdd$6 = (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$3 = (obj, member, value, setter) => {
-  __accessCheck$5(obj, member, "write to private field");
+var __privateSet$4 = (obj, member, value, setter) => {
+  __accessCheck$6(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _query;
 class Page {
   constructor(query, meta, records = []) {
-    __privateAdd$5(this, _query, void 0);
-    __privateSet$3(this, _query, query);
+    __privateAdd$6(this, _query, void 0);
+    __privateSet$4(this, _query, query);
     this.meta = meta;
     this.records = records;
   }
   async nextPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, after: this.meta.page.cursor } });
+    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, after: this.meta.page.cursor } });
   }
   async previousPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, before: this.meta.page.cursor } });
+    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, before: this.meta.page.cursor } });
   }
   async firstPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, first: this.meta.page.cursor } });
+    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, first: this.meta.page.cursor } });
   }
   async lastPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, last: this.meta.page.cursor } });
+    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, last: this.meta.page.cursor } });
   }
   hasNextPage() {
     return this.meta.page.more;
@@ -978,47 +955,47 @@ const PAGINATION_DEFAULT_SIZE = 200;
 const PAGINATION_MAX_OFFSET = 800;
 const PAGINATION_DEFAULT_OFFSET = 0;
 
-var __accessCheck$4 = (obj, member, msg) => {
+var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$3 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$5(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$4 = (obj, member, value) => {
+var __privateAdd$5 = (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$2 = (obj, member, value, setter) => {
-  __accessCheck$4(obj, member, "write to private field");
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$5(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _table$1, _repository, _data;
 const _Query = class {
   constructor(repository, table, data, parent) {
-    __privateAdd$4(this, _table$1, void 0);
-    __privateAdd$4(this, _repository, void 0);
-    __privateAdd$4(this, _data, { filter: {} });
+    __privateAdd$5(this, _table$1, void 0);
+    __privateAdd$5(this, _repository, void 0);
+    __privateAdd$5(this, _data, { filter: {} });
     this.meta = { page: { cursor: "start", more: true } };
     this.records = [];
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
-    __privateSet$2(this, _table$1, table);
+    __privateSet$3(this, _table$1, table);
     if (repository) {
-      __privateSet$2(this, _repository, repository);
+      __privateSet$3(this, _repository, repository);
     } else {
-      __privateSet$2(this, _repository, this);
+      __privateSet$3(this, _repository, this);
     }
-    __privateGet$3(this, _data).filter = (_b = (_a = data.filter) != null ? _a : parent == null ? void 0 : parent.filter) != null ? _b : {};
-    __privateGet$3(this, _data).filter.$any = (_e = (_c = data.filter) == null ? void 0 : _c.$any) != null ? _e : (_d = parent == null ? void 0 : parent.filter) == null ? void 0 : _d.$any;
-    __privateGet$3(this, _data).filter.$all = (_h = (_f = data.filter) == null ? void 0 : _f.$all) != null ? _h : (_g = parent == null ? void 0 : parent.filter) == null ? void 0 : _g.$all;
-    __privateGet$3(this, _data).filter.$not = (_k = (_i = data.filter) == null ? void 0 : _i.$not) != null ? _k : (_j = parent == null ? void 0 : parent.filter) == null ? void 0 : _j.$not;
-    __privateGet$3(this, _data).filter.$none = (_n = (_l = data.filter) == null ? void 0 : _l.$none) != null ? _n : (_m = parent == null ? void 0 : parent.filter) == null ? void 0 : _m.$none;
-    __privateGet$3(this, _data).sort = (_o = data.sort) != null ? _o : parent == null ? void 0 : parent.sort;
-    __privateGet$3(this, _data).columns = (_q = (_p = data.columns) != null ? _p : parent == null ? void 0 : parent.columns) != null ? _q : ["*"];
-    __privateGet$3(this, _data).page = (_r = data.page) != null ? _r : parent == null ? void 0 : parent.page;
+    __privateGet$4(this, _data).filter = data.filter ?? parent?.filter ?? {};
+    __privateGet$4(this, _data).filter.$any = data.filter?.$any ?? parent?.filter?.$any;
+    __privateGet$4(this, _data).filter.$all = data.filter?.$all ?? parent?.filter?.$all;
+    __privateGet$4(this, _data).filter.$not = data.filter?.$not ?? parent?.filter?.$not;
+    __privateGet$4(this, _data).filter.$none = data.filter?.$none ?? parent?.filter?.$none;
+    __privateGet$4(this, _data).sort = data.sort ?? parent?.sort;
+    __privateGet$4(this, _data).columns = data.columns ?? parent?.columns ?? ["*"];
+    __privateGet$4(this, _data).page = data.page ?? parent?.page;
+    __privateGet$4(this, _data).cache = data.cache ?? parent?.cache;
     this.any = this.any.bind(this);
     this.all = this.all.bind(this);
     this.not = this.not.bind(this);
@@ -1029,59 +1006,50 @@ const _Query = class {
     Object.defineProperty(this, "repository", { enumerable: false });
   }
   getQueryOptions() {
-    return __privateGet$3(this, _data);
+    return __privateGet$4(this, _data);
+  }
+  key() {
+    const { columns = [], filter = {}, sort = [], page = {} } = __privateGet$4(this, _data);
+    const key = JSON.stringify({ columns, filter, sort, page });
+    return toBase64(key);
   }
   any(...queries) {
-    const $any = queries.map((query) => {
-      var _a;
-      return (_a = query.getQueryOptions().filter) != null ? _a : {};
-    });
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $any } }, __privateGet$3(this, _data));
+    const $any = queries.map((query) => query.getQueryOptions().filter ?? {});
+    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { filter: { $any } }, __privateGet$4(this, _data));
   }
   all(...queries) {
-    const $all = queries.map((query) => {
-      var _a;
-      return (_a = query.getQueryOptions().filter) != null ? _a : {};
-    });
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(this, _data));
+    const $all = queries.map((query) => query.getQueryOptions().filter ?? {});
+    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { filter: { $all } }, __privateGet$4(this, _data));
   }
   not(...queries) {
-    const $not = queries.map((query) => {
-      var _a;
-      return (_a = query.getQueryOptions().filter) != null ? _a : {};
-    });
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $not } }, __privateGet$3(this, _data));
+    const $not = queries.map((query) => query.getQueryOptions().filter ?? {});
+    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { filter: { $not } }, __privateGet$4(this, _data));
   }
   none(...queries) {
-    const $none = queries.map((query) => {
-      var _a;
-      return (_a = query.getQueryOptions().filter) != null ? _a : {};
-    });
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $none } }, __privateGet$3(this, _data));
+    const $none = queries.map((query) => query.getQueryOptions().filter ?? {});
+    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { filter: { $none } }, __privateGet$4(this, _data));
   }
   filter(a, b) {
-    var _a, _b;
     if (arguments.length === 1) {
       const constraints = Object.entries(a).map(([column, constraint]) => ({ [column]: constraint }));
-      const $all = compact([(_a = __privateGet$3(this, _data).filter) == null ? void 0 : _a.$all].flat().concat(constraints));
-      return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(this, _data));
+      const $all = compact([__privateGet$4(this, _data).filter?.$all].flat().concat(constraints));
+      return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { filter: { $all } }, __privateGet$4(this, _data));
     } else {
-      const $all = compact([(_b = __privateGet$3(this, _data).filter) == null ? void 0 : _b.$all].flat().concat([{ [a]: b }]));
-      return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(this, _data));
+      const $all = compact([__privateGet$4(this, _data).filter?.$all].flat().concat([{ [a]: b }]));
+      return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { filter: { $all } }, __privateGet$4(this, _data));
     }
   }
   sort(column, direction) {
-    var _a;
-    const originalSort = [(_a = __privateGet$3(this, _data).sort) != null ? _a : []].flat();
+    const originalSort = [__privateGet$4(this, _data).sort ?? []].flat();
     const sort = [...originalSort, { column, direction }];
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { sort }, __privateGet$3(this, _data));
+    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { sort }, __privateGet$4(this, _data));
   }
   select(columns) {
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { columns }, __privateGet$3(this, _data));
+    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { columns }, __privateGet$4(this, _data));
   }
   getPaginated(options = {}) {
-    const query = new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), options, __privateGet$3(this, _data));
-    return __privateGet$3(this, _repository).query(query);
+    const query = new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), options, __privateGet$4(this, _data));
+    return __privateGet$4(this, _repository).query(query);
   }
   async *[Symbol.asyncIterator]() {
     for await (const [record] of this.getIterator(1)) {
@@ -1109,10 +1077,13 @@ const _Query = class {
     }
     return results;
   }
-  async getOne(options = {}) {
+  async getFirst(options = {}) {
     const records = await this.getMany({ ...options, page: { size: 1 } });
     return records[0] || null;
   }
+  cache(ttl) {
+    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { cache: ttl }, __privateGet$4(this, _data));
+  }
   nextPage(size, offset) {
     return this.firstPage(size, offset);
   }
@@ -1135,11 +1106,10 @@ _repository = new WeakMap();
 _data = new WeakMap();
 
 function isIdentifiable(x) {
-  return isObject(x) && isString(x == null ? void 0 : x.id);
+  return isObject(x) && isString(x?.id);
 }
 function isXataRecord(x) {
-  var _a;
-  return isIdentifiable(x) && typeof (x == null ? void 0 : x.xata) === "object" && typeof ((_a = x == null ? void 0 : x.xata) == null ? void 0 : _a.version) === "number";
+  return isIdentifiable(x) && typeof x?.xata === "object" && typeof x?.xata?.version === "number";
 }
 
 function isSortFilterString(value) {
@@ -1152,7 +1122,6 @@ function isSortFilterObject(filter) {
   return isObject(filter) && !isSortFilterBase(filter) && filter.column !== void 0;
 }
 function buildSortFilter(filter) {
-  var _a;
   if (isSortFilterString(filter)) {
     return { [filter]: "asc" };
   } else if (Array.isArray(filter)) {
@@ -1160,83 +1129,99 @@ function buildSortFilter(filter) {
   } else if (isSortFilterBase(filter)) {
     return filter;
   } else if (isSortFilterObject(filter)) {
-    return { [filter.column]: (_a = filter.direction) != null ? _a : "asc" };
+    return { [filter.column]: filter.direction ?? "asc" };
   } else {
     throw new Error(`Invalid sort filter: ${filter}`);
   }
 }
 
-var __accessCheck$3 = (obj, member, msg) => {
+var __accessCheck$4 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$2 = (obj, member, getter) => {
-  __accessCheck$3(obj, member, "read from private field");
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$3 = (obj, member, value) => {
+var __privateAdd$4 = (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$1 = (obj, member, value, setter) => {
-  __accessCheck$3(obj, member, "write to private field");
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var __privateMethod$2 = (obj, member, method) => {
-  __accessCheck$3(obj, member, "access private method");
+  __accessCheck$4(obj, member, "access private method");
   return method;
 };
-var _table, _links, _getFetchProps, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _initObject, initObject_fn;
+var _table, _links, _getFetchProps, _cache, _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;
 class Repository extends Query {
 }
 class RestRepository extends Query {
   constructor(options) {
     super(null, options.table, {});
-    __privateAdd$3(this, _insertRecordWithoutId);
-    __privateAdd$3(this, _insertRecordWithId);
-    __privateAdd$3(this, _bulkInsertTableRecords);
-    __privateAdd$3(this, _updateRecordWithID);
-    __privateAdd$3(this, _upsertRecordWithID);
-    __privateAdd$3(this, _deleteRecord);
-    __privateAdd$3(this, _initObject);
-    __privateAdd$3(this, _table, void 0);
-    __privateAdd$3(this, _links, void 0);
-    __privateAdd$3(this, _getFetchProps, void 0);
-    var _a;
-    __privateSet$1(this, _table, options.table);
-    __privateSet$1(this, _links, (_a = options.links) != null ? _a : {});
-    __privateSet$1(this, _getFetchProps, options.getFetchProps);
+    __privateAdd$4(this, _insertRecordWithoutId);
+    __privateAdd$4(this, _insertRecordWithId);
+    __privateAdd$4(this, _bulkInsertTableRecords);
+    __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, _table, void 0);
+    __privateAdd$4(this, _links, void 0);
+    __privateAdd$4(this, _getFetchProps, void 0);
+    __privateAdd$4(this, _cache, void 0);
+    __privateSet$2(this, _table, options.table);
+    __privateSet$2(this, _links, options.links ?? {});
+    __privateSet$2(this, _getFetchProps, options.pluginOptions.getFetchProps);
     this.db = options.db;
+    __privateSet$2(this, _cache, options.pluginOptions.cache);
   }
   async create(a, b) {
     if (Array.isArray(a)) {
-      return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a);
+      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;
     }
     if (isString(a) && isObject(b)) {
       if (a === "")
         throw new Error("The id can't be empty");
-      return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b);
+      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;
     }
     if (isObject(a) && isString(a.id)) {
       if (a.id === "")
         throw new Error("The id can't be empty");
-      return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 });
+      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;
     }
     if (isObject(a)) {
-      return __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, 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;
     }
     throw new Error("Invalid arguments for create method");
   }
   async read(recordId) {
-    const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+    const cacheRecord = await __privateMethod$2(this, _getCacheRecord, getCacheRecord_fn).call(this, recordId);
+    if (cacheRecord)
+      return cacheRecord;
+    const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
     try {
       const response = await getRecord({
-        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table), recordId },
         ...fetchProps
       });
-      return __privateMethod$2(this, _initObject, initObject_fn).call(this, __privateGet$2(this, _table), response);
+      return initObject(this.db, __privateGet$3(this, _links), __privateGet$3(this, _table), response);
     } catch (e) {
       if (isObject(e) && e.status === 404) {
         return null;
@@ -1252,10 +1237,16 @@ class RestRepository extends Query {
       return Promise.all(a.map((object) => this.update(object)));
     }
     if (isString(a) && isObject(b)) {
-      return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, 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;
     }
     if (isObject(a) && isString(a.id)) {
-      return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
+      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;
     }
     throw new Error("Invalid arguments for update method");
   }
@@ -1267,71 +1258,83 @@ class RestRepository extends Query {
       return Promise.all(a.map((object) => this.createOrUpdate(object)));
     }
     if (isString(a) && isObject(b)) {
-      return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, 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;
     }
     if (isObject(a) && isString(a.id)) {
-      return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
+      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;
     }
     throw new Error("Invalid arguments for createOrUpdate method");
   }
-  async delete(recordId) {
-    if (Array.isArray(recordId)) {
-      if (recordId.length > 100) {
+  async delete(a) {
+    if (Array.isArray(a)) {
+      if (a.length > 100) {
         console.warn("Bulk delete operation is not optimized in the Xata API yet, this request might be slow");
       }
-      await Promise.all(recordId.map((id) => this.delete(id)));
+      await Promise.all(a.map((id) => this.delete(id)));
       return;
     }
-    if (isString(recordId)) {
-      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, recordId);
+    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(recordId) && isString(recordId.id)) {
-      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, recordId.id);
+    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");
   }
   async search(query, options = {}) {
-    const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+    const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
     const { records } = await searchBranch({
       pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-      body: { tables: [__privateGet$2(this, _table)], query, fuzziness: options.fuzziness },
+      body: { tables: [__privateGet$3(this, _table)], query, fuzziness: options.fuzziness },
       ...fetchProps
     });
-    return records.map((item) => __privateMethod$2(this, _initObject, initObject_fn).call(this, __privateGet$2(this, _table), item));
+    return records.map((item) => initObject(this.db, __privateGet$3(this, _links), __privateGet$3(this, _table), item));
   }
   async query(query) {
-    var _a;
+    const cacheQuery = await __privateMethod$2(this, _getCacheQuery, getCacheQuery_fn).call(this, query);
+    if (cacheQuery)
+      return new Page(query, cacheQuery.meta, cacheQuery.records);
     const data = query.getQueryOptions();
     const body = {
-      filter: Object.values((_a = data.filter) != null ? _a : {}).some(Boolean) ? data.filter : void 0,
+      filter: Object.values(data.filter ?? {}).some(Boolean) ? data.filter : void 0,
       sort: data.sort ? buildSortFilter(data.sort) : void 0,
       page: data.page,
       columns: data.columns
     };
-    const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+    const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
     const { meta, records: objects } = await queryTable({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table) },
+      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table) },
       body,
       ...fetchProps
     });
-    const records = objects.map((record) => __privateMethod$2(this, _initObject, initObject_fn).call(this, __privateGet$2(this, _table), record));
+    const records = objects.map((record) => initObject(this.db, __privateGet$3(this, _links), __privateGet$3(this, _table), record));
+    await __privateMethod$2(this, _setCacheQuery, setCacheQuery_fn).call(this, query, meta, records);
     return new Page(query, meta, records);
   }
 }
 _table = new WeakMap();
 _links = new WeakMap();
 _getFetchProps = new WeakMap();
+_cache = new WeakMap();
 _insertRecordWithoutId = new WeakSet();
 insertRecordWithoutId_fn = async function(object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecord({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
-      tableName: __privateGet$2(this, _table)
+      tableName: __privateGet$3(this, _table)
     },
     body: record,
     ...fetchProps
@@ -1344,13 +1347,13 @@ insertRecordWithoutId_fn = async function(object) {
 };
 _insertRecordWithId = new WeakSet();
 insertRecordWithId_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
-      tableName: __privateGet$2(this, _table),
+      tableName: __privateGet$3(this, _table),
       recordId
     },
     body: record,
@@ -1365,10 +1368,10 @@ insertRecordWithId_fn = async function(recordId, object) {
 };
 _bulkInsertTableRecords = new WeakSet();
 bulkInsertTableRecords_fn = async function(objects) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
   const records = objects.map((object) => transformObjectLinks(object));
   const response = await bulkInsertTableRecords({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table) },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table) },
     body: { records },
     ...fetchProps
   });
@@ -1380,10 +1383,10 @@ bulkInsertTableRecords_fn = async function(objects) {
 };
 _updateRecordWithID = new WeakSet();
 updateRecordWithID_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await updateRecordWithID({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table), recordId },
     body: record,
     ...fetchProps
   });
@@ -1394,9 +1397,9 @@ updateRecordWithID_fn = async function(recordId, object) {
 };
 _upsertRecordWithID = new WeakSet();
 upsertRecordWithID_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
   const response = await upsertRecordWithID({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table), recordId },
     body: object,
     ...fetchProps
   });
@@ -1407,25 +1410,69 @@ upsertRecordWithID_fn = async function(recordId, object) {
 };
 _deleteRecord = new WeakSet();
 deleteRecord_fn = async function(recordId) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
   await deleteRecord({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table), recordId },
     ...fetchProps
   });
 };
-_initObject = new WeakSet();
-initObject_fn = function(table, object) {
+_invalidateCache = new WeakSet();
+invalidateCache_fn = async function(recordId) {
+  await __privateGet$3(this, _cache).delete(`rec_${__privateGet$3(this, _table)}:${recordId}`);
+  const cacheItems = await __privateGet$3(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$3(this, _cache).delete(key);
+  }
+};
+_setCacheRecord = new WeakSet();
+setCacheRecord_fn = async function(record) {
+  if (!__privateGet$3(this, _cache).cacheRecords)
+    return;
+  await __privateGet$3(this, _cache).set(`rec_${__privateGet$3(this, _table)}:${record.id}`, record);
+};
+_getCacheRecord = new WeakSet();
+getCacheRecord_fn = async function(recordId) {
+  if (!__privateGet$3(this, _cache).cacheRecords)
+    return null;
+  return __privateGet$3(this, _cache).get(`rec_${__privateGet$3(this, _table)}:${recordId}`);
+};
+_setCacheQuery = new WeakSet();
+setCacheQuery_fn = async function(query, meta, records) {
+  await __privateGet$3(this, _cache).set(`query_${__privateGet$3(this, _table)}:${query.key()}`, { date: new Date(), meta, records });
+};
+_getCacheQuery = new WeakSet();
+getCacheQuery_fn = async function(query) {
+  const key = `query_${__privateGet$3(this, _table)}:${query.key()}`;
+  const result = await __privateGet$3(this, _cache).get(key);
+  if (!result)
+    return null;
+  const { cache: ttl = __privateGet$3(this, _cache).defaultQueryTTL } = query.getQueryOptions();
+  if (!ttl || ttl < 0)
+    return result;
+  const hasExpired = result.date.getTime() + ttl < Date.now();
+  return hasExpired ? null : result;
+};
+const transformObjectLinks = (object) => {
+  return Object.entries(object).reduce((acc, [key, value]) => {
+    if (key === "xata")
+      return acc;
+    return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
+  }, {});
+};
+const initObject = (db, links, table, object) => {
   const result = {};
   Object.assign(result, object);
-  const tableLinks = __privateGet$2(this, _links)[table] || [];
+  const tableLinks = links[table] || [];
   for (const link of tableLinks) {
     const [field, linkTable] = link;
     const value = result[field];
     if (value && isObject(value)) {
-      result[field] = __privateMethod$2(this, _initObject, initObject_fn).call(this, linkTable, value);
+      result[field] = initObject(db, links, linkTable, value);
     }
   }
-  const db = this.db;
   result.read = function() {
     return db[table].read(result["id"]);
   };
@@ -1441,13 +1488,65 @@ initObject_fn = function(table, object) {
   Object.freeze(result);
   return result;
 };
-const transformObjectLinks = (object) => {
-  return Object.entries(object).reduce((acc, [key, value]) => {
-    if (key === "xata")
-      return acc;
-    return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
-  }, {});
+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;
+}
+
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
 };
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (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$1 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _map;
+class SimpleCache {
+  constructor(options = {}) {
+    __privateAdd$3(this, _map, void 0);
+    __privateSet$1(this, _map, /* @__PURE__ */ new Map());
+    this.capacity = options.max ?? 500;
+    this.cacheRecords = options.cacheRecords ?? true;
+    this.defaultQueryTTL = options.defaultQueryTTL ?? 60 * 1e3;
+  }
+  async getAll() {
+    return Object.fromEntries(__privateGet$2(this, _map));
+  }
+  async get(key) {
+    return __privateGet$2(this, _map).get(key) ?? null;
+  }
+  async set(key, value) {
+    await this.delete(key);
+    __privateGet$2(this, _map).set(key, value);
+    if (__privateGet$2(this, _map).size > this.capacity) {
+      const leastRecentlyUsed = __privateGet$2(this, _map).keys().next().value;
+      await this.delete(leastRecentlyUsed);
+    }
+  }
+  async delete(key) {
+    __privateGet$2(this, _map).delete(key);
+  }
+  async clear() {
+    return __privateGet$2(this, _map).clear();
+  }
+}
+_map = new WeakMap();
 
 const gt = (value) => ({ $gt: value });
 const ge = (value) => ({ $ge: value });
@@ -1483,23 +1582,27 @@ var __privateAdd$2 = (obj, member, value) => {
 };
 var _tables;
 class SchemaPlugin extends XataPlugin {
-  constructor(links) {
+  constructor(links, tableNames) {
     super();
     this.links = links;
+    this.tableNames = tableNames;
     __privateAdd$2(this, _tables, {});
   }
-  build(options) {
-    const { getFetchProps } = options;
+  build(pluginOptions) {
     const links = this.links;
     const db = new Proxy({}, {
       get: (_target, table) => {
         if (!isString(table))
           throw new Error("Invalid table name");
-        if (!__privateGet$1(this, _tables)[table])
-          __privateGet$1(this, _tables)[table] = new RestRepository({ db, getFetchProps, table, links });
+        if (!__privateGet$1(this, _tables)[table]) {
+          __privateGet$1(this, _tables)[table] = new RestRepository({ db, pluginOptions, table, links });
+        }
         return __privateGet$1(this, _tables)[table];
       }
     });
+    for (const table of this.tableNames ?? []) {
+      db[table] = new RestRepository({ db, pluginOptions, table, links });
+    }
     return db;
   }
 }
@@ -1520,8 +1623,10 @@ var __privateMethod$1 = (obj, member, method) => {
 };
 var _search, search_fn;
 class SearchPlugin extends XataPlugin {
-  constructor() {
-    super(...arguments);
+  constructor(db, links) {
+    super();
+    this.db = db;
+    this.links = links;
     __privateAdd$1(this, _search);
   }
   build({ getFetchProps }) {
@@ -1530,16 +1635,16 @@ class SearchPlugin extends XataPlugin {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
         return records.map((record) => {
           const { table = "orphan" } = record.xata;
-          return { table, record };
+          return { table, record: initObject(this.db, this.links, table, record) };
         });
       },
       byTable: async (query, options = {}) => {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
         return records.reduce((acc, record) => {
-          var _a;
           const { table = "orphan" } = record.xata;
-          const items = (_a = acc[table]) != null ? _a : [];
-          return { ...acc, [table]: [...items, record] };
+          const items = acc[table] ?? [];
+          const item = initObject(this.db, this.links, table, record);
+          return { ...acc, [table]: [...items, item] };
         }, {});
       }
     };
@@ -1548,7 +1653,7 @@ class SearchPlugin extends XataPlugin {
 _search = new WeakSet();
 search_fn = async function(query, options, getFetchProps) {
   const fetchProps = await getFetchProps();
-  const { tables, fuzziness } = options != null ? options : {};
+  const { tables, fuzziness } = options ?? {};
   const { records } = await searchBranch({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
     body: { tables, query, fuzziness },
@@ -1561,6 +1666,84 @@ const isBranchStrategyBuilder = (strategy) => {
   return typeof strategy === "function";
 };
 
+const envBranchNames = [
+  "XATA_BRANCH",
+  "VERCEL_GIT_COMMIT_REF",
+  "CF_PAGES_BRANCH",
+  "BRANCH"
+];
+const defaultBranch = "main";
+async function getCurrentBranchName(options) {
+  const env = await getBranchByEnvVariable();
+  if (env)
+    return env;
+  const branch = await getGitBranch();
+  if (!branch)
+    return defaultBranch;
+  const details = await getDatabaseBranch(branch, options);
+  if (details)
+    return branch;
+  return defaultBranch;
+}
+async function getCurrentBranchDetails(options) {
+  const env = await getBranchByEnvVariable();
+  if (env)
+    return getDatabaseBranch(env, options);
+  const branch = await getGitBranch();
+  if (!branch)
+    return getDatabaseBranch(defaultBranch, options);
+  const details = await getDatabaseBranch(branch, options);
+  if (details)
+    return details;
+  return getDatabaseBranch(defaultBranch, options);
+}
+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");
+  if (!apiKey)
+    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}`;
+  try {
+    return await getBranchDetails({
+      apiKey,
+      apiUrl: databaseURL,
+      fetchImpl: getFetchImplementation(options?.fetchImpl),
+      workspacesApiUrl: `${protocol}//${host}`,
+      pathParams: {
+        dbBranchName,
+        workspace
+      }
+    });
+  } catch (err) {
+    if (isObject(err) && err.status === 404)
+      return null;
+    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;
+  } catch (err) {
+    return void 0;
+  }
+}
+
 var __accessCheck = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
@@ -1586,21 +1769,24 @@ var __privateMethod = (obj, member, method) => {
 const buildClient = (plugins) => {
   var _branch, _parseOptions, parseOptions_fn, _getFetchProps, getFetchProps_fn, _evaluateBranch, evaluateBranch_fn, _a;
   return _a = class {
-    constructor(options = {}, links) {
+    constructor(options = {}, links, tables) {
       __privateAdd(this, _parseOptions);
       __privateAdd(this, _getFetchProps);
       __privateAdd(this, _evaluateBranch);
       __privateAdd(this, _branch, void 0);
       const safeOptions = __privateMethod(this, _parseOptions, parseOptions_fn).call(this, options);
-      const namespaces = {
-        db: new SchemaPlugin(links),
-        search: new SearchPlugin(),
-        ...plugins
+      const pluginOptions = {
+        getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions),
+        cache: safeOptions.cache
       };
-      for (const [key, namespace] of Object.entries(namespaces)) {
+      const db = new SchemaPlugin(links, tables).build(pluginOptions);
+      const search = new SearchPlugin(db, links ?? {}).build(pluginOptions);
+      this.db = db;
+      this.search = search;
+      for (const [key, namespace] of Object.entries(plugins ?? {})) {
         if (!namespace)
           continue;
-        const result = namespace.build({ getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions) });
+        const result = namespace.build(pluginOptions);
         if (result instanceof Promise) {
           void result.then((namespace2) => {
             this[key] = namespace2;
@@ -1611,14 +1797,15 @@ const buildClient = (plugins) => {
       }
     }
   }, _branch = new WeakMap(), _parseOptions = new WeakSet(), parseOptions_fn = function(options) {
-    const fetch = getFetchImplementation(options == null ? void 0 : options.fetch);
-    const databaseURL = (options == null ? void 0 : options.databaseURL) || getDatabaseURL();
-    const apiKey = (options == null ? void 0 : options.apiKey) || getAPIKey();
-    const branch = async () => (options == null ? void 0 : options.branch) ? await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, options.branch) : await getCurrentBranchName({ apiKey, databaseURL, fetchImpl: options == null ? void 0 : options.fetch });
+    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 branch = async () => options?.branch ? 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 };
+    return { fetch, databaseURL, apiKey, branch, cache };
   }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({
     fetch,
     apiKey,
@@ -1633,8 +1820,7 @@ const buildClient = (plugins) => {
       apiKey,
       apiUrl: "",
       workspacesApiUrl: (path, params) => {
-        var _a2;
-        const hasBranch = (_a2 = params.dbBranchName) != null ? _a2 : params.branch;
+        const hasBranch = params.dbBranchName ?? params.branch;
         const newPath = path.replace(/^\/db\/[^/]+/, hasBranch ? `:${branchValue}` : "");
         return databaseURL + newPath;
       }
@@ -1679,11 +1865,13 @@ exports.Repository = Repository;
 exports.RestRepository = RestRepository;
 exports.SchemaPlugin = SchemaPlugin;
 exports.SearchPlugin = SearchPlugin;
+exports.SimpleCache = SimpleCache;
 exports.XataApiClient = XataApiClient;
 exports.XataApiPlugin = XataApiPlugin;
 exports.XataError = XataError;
 exports.XataPlugin = XataPlugin;
 exports.acceptWorkspaceMemberInvite = acceptWorkspaceMemberInvite;
+exports.addGitBranchesEntry = addGitBranchesEntry;
 exports.addTableColumn = addTableColumn;
 exports.buildClient = buildClient;
 exports.bulkInsertTableRecords = bulkInsertTableRecords;
@@ -1718,6 +1906,7 @@ exports.getCurrentBranchDetails = getCurrentBranchDetails;
 exports.getCurrentBranchName = getCurrentBranchName;
 exports.getDatabaseList = getDatabaseList;
 exports.getDatabaseURL = getDatabaseURL;
+exports.getGitBranchesMapping = getGitBranchesMapping;
 exports.getRecord = getRecord;
 exports.getTableColumns = getTableColumns;
 exports.getTableSchema = getTableSchema;
@@ -1746,8 +1935,10 @@ exports.notExists = notExists;
 exports.operationsByTag = operationsByTag;
 exports.pattern = pattern;
 exports.queryTable = queryTable;
+exports.removeGitBranchesEntry = removeGitBranchesEntry;
 exports.removeWorkspaceMember = removeWorkspaceMember;
 exports.resendWorkspaceMemberInvite = resendWorkspaceMemberInvite;
+exports.resolveBranch = resolveBranch;
 exports.searchBranch = searchBranch;
 exports.setTableSchema = setTableSchema;
 exports.startsWith = startsWith;