@xata.io/client 0.0.0-alpha.vf4b92f1 → 0.0.0-alpha.vf5a6674

package/dist/index.mjs

@@ -1,3 +1,25 @@
+const defaultTrace = async (_name, fn, _options) => {
+  return await fn({
+    setAttributes: () => {
+      return;
+    }
+  });
+};
+const TraceAttributes = {
+  KIND: "xata.trace.kind",
+  VERSION: "xata.sdk.version",
+  TABLE: "xata.table",
+  HTTP_REQUEST_ID: "http.request_id",
+  HTTP_STATUS_CODE: "http.status_code",
+  HTTP_HOST: "http.host",
+  HTTP_SCHEME: "http.scheme",
+  HTTP_USER_AGENT: "http.user_agent",
+  HTTP_METHOD: "http.method",
+  HTTP_URL: "http.url",
+  HTTP_ROUTE: "http.route",
+  HTTP_TARGET: "http.target"
+};
+
 function notEmpty(value) {
   return value !== null && value !== void 0;
 }
@@ -7,43 +29,101 @@ function compact(arr) {
 function isObject(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function isDefined(value) {
+  return value !== null && value !== void 0;
+}
 function isString(value) {
-  return value !== void 0 && value !== null && typeof value === "string";
+  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 {
-    return require("child_process").execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    if (typeof require === "function") {
+      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) {
@@ -52,7 +132,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;
   }
@@ -62,21 +143,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(
+      `Couldn't find \`fetch\`. Install a fetch implementation such as \`node-fetch\` and pass it explicitly.`
+    );
   }
   return fetchImpl;
 }
 
-class FetcherError extends Error {
-  constructor(status, data) {
+const VERSION = "0.0.0-alpha.vf5a6674";
+
+class ErrorWithCause extends Error {
+  constructor(message, options) {
+    super(message, options);
+  }
+}
+class FetcherError extends ErrorWithCause {
+  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);
@@ -99,9 +194,17 @@ 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;
+  const cleanPathParams = Object.entries(pathParams).reduce((acc, [key, value]) => {
+    return { ...acc, [key]: encodeURIComponent(String(value ?? "")).replace("%3A", ":") };
+  }, {});
+  return url.replace(/\{\w*\}/g, (key) => cleanPathParams[key.slice(1, -1)]) + queryString;
 };
 function buildBaseUrl({
   path,
@@ -109,10 +212,10 @@ function buildBaseUrl({
   apiUrl,
   pathParams
 }) {
-  if (!pathParams?.workspace)
+  if (pathParams?.workspace === void 0 || !path.startsWith("/db"))
     return `${apiUrl}${path}`;
   const url = typeof workspacesApiUrl === "string" ? `${workspacesApiUrl}${path}` : workspacesApiUrl(path, pathParams);
-  return url.replace("{workspaceId}", pathParams.workspace);
+  return url.replace("{workspaceId}", String(pathParams.workspace));
 }
 function hostHeader(url) {
   const pattern = /.*:\/\/(?<host>[^/]+).*/;
@@ -129,254 +232,413 @@ async function fetch$1({
   fetchImpl,
   apiKey,
   apiUrl,
-  workspacesApiUrl
+  workspacesApiUrl,
+  trace,
+  signal,
+  clientID,
+  sessionID
 }) {
-  const baseUrl = buildBaseUrl({ path, workspacesApiUrl, pathParams, apiUrl });
-  const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
-  const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
-  const response = await fetchImpl(url, {
-    method: method.toUpperCase(),
-    body: body ? JSON.stringify(body) : void 0,
-    headers: {
-      "Content-Type": "application/json",
-      ...headers,
-      ...hostHeader(fullUrl),
-      Authorization: `Bearer ${apiKey}`
-    }
-  });
-  if (response.status === 204) {
-    return {};
-  }
+  return trace(
+    `${method.toUpperCase()} ${path}`,
+    async ({ setAttributes }) => {
+      const baseUrl = buildBaseUrl({ path, workspacesApiUrl, pathParams, apiUrl });
+      const fullUrl = resolveUrl(baseUrl, queryParams, pathParams);
+      const url = fullUrl.includes("localhost") ? fullUrl.replace(/^[^.]+\./, "http://") : fullUrl;
+      setAttributes({
+        [TraceAttributes.HTTP_URL]: url,
+        [TraceAttributes.HTTP_TARGET]: resolveUrl(path, queryParams, pathParams)
+      });
+      const response = await fetchImpl(url, {
+        method: method.toUpperCase(),
+        body: body ? JSON.stringify(body) : void 0,
+        headers: {
+          "Content-Type": "application/json",
+          "User-Agent": `Xata client-ts/${VERSION}`,
+          "X-Xata-Client-ID": clientID ?? "",
+          "X-Xata-Session-ID": sessionID ?? "",
+          ...headers,
+          ...hostHeader(fullUrl),
+          Authorization: `Bearer ${apiKey}`
+        },
+        signal
+      });
+      if (response.status === 204) {
+        return {};
+      }
+      const { host, protocol } = parseUrl(response.url);
+      const requestId = response.headers?.get("x-request-id") ?? void 0;
+      setAttributes({
+        [TraceAttributes.KIND]: "http",
+        [TraceAttributes.HTTP_REQUEST_ID]: requestId,
+        [TraceAttributes.HTTP_STATUS_CODE]: response.status,
+        [TraceAttributes.HTTP_HOST]: host,
+        [TraceAttributes.HTTP_SCHEME]: protocol?.replace(":", "")
+      });
+      try {
+        const jsonResponse = await response.json();
+        if (response.ok) {
+          return jsonResponse;
+        }
+        throw new FetcherError(response.status, jsonResponse, requestId);
+      } catch (error) {
+        throw new FetcherError(response.status, error, requestId);
+      }
+    },
+    { [TraceAttributes.HTTP_METHOD]: method.toUpperCase(), [TraceAttributes.HTTP_ROUTE]: path }
+  );
+}
+function parseUrl(url) {
   try {
-    const jsonResponse = await response.json();
-    if (response.ok) {
-      return jsonResponse;
-    }
-    throw new FetcherError(response.status, jsonResponse);
+    const { host, protocol } = new URL(url);
+    return { host, protocol };
   } catch (error) {
-    throw new FetcherError(response.status, error);
+    return {};
   }
 }
 
-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({
+const getUser = (variables, signal) => fetch$1({ url: "/user", method: "get", ...variables, signal });
+const updateUser = (variables, signal) => fetch$1({
+  url: "/user",
+  method: "put",
+  ...variables,
+  signal
+});
+const deleteUser = (variables, signal) => fetch$1({ url: "/user", method: "delete", ...variables, signal });
+const getUserAPIKeys = (variables, signal) => fetch$1({
   url: "/user/keys",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const createUserAPIKey = (variables) => fetch$1({
+const createUserAPIKey = (variables, signal) => fetch$1({
   url: "/user/keys/{keyName}",
   method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const deleteUserAPIKey = (variables) => fetch$1({
+const deleteUserAPIKey = (variables, signal) => fetch$1({
   url: "/user/keys/{keyName}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const createWorkspace = (variables) => fetch$1({
+const getWorkspacesList = (variables, signal) => fetch$1({
   url: "/workspaces",
-  method: "post",
-  ...variables
+  method: "get",
+  ...variables,
+  signal
 });
-const getWorkspacesList = (variables) => fetch$1({
+const createWorkspace = (variables, signal) => fetch$1({
   url: "/workspaces",
-  method: "get",
-  ...variables
+  method: "post",
+  ...variables,
+  signal
 });
-const getWorkspace = (variables) => fetch$1({
+const getWorkspace = (variables, signal) => fetch$1({
   url: "/workspaces/{workspaceId}",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const updateWorkspace = (variables) => fetch$1({
+const updateWorkspace = (variables, signal) => fetch$1({
   url: "/workspaces/{workspaceId}",
   method: "put",
-  ...variables
+  ...variables,
+  signal
 });
-const deleteWorkspace = (variables) => fetch$1({
+const deleteWorkspace = (variables, signal) => fetch$1({
   url: "/workspaces/{workspaceId}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const getWorkspaceMembersList = (variables) => fetch$1({
+const getWorkspaceMembersList = (variables, signal) => fetch$1({
   url: "/workspaces/{workspaceId}/members",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const updateWorkspaceMemberRole = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables });
-const removeWorkspaceMember = (variables) => fetch$1({
+const updateWorkspaceMemberRole = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/members/{userId}", method: "put", ...variables, signal });
+const removeWorkspaceMember = (variables, signal) => fetch$1({
   url: "/workspaces/{workspaceId}/members/{userId}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const inviteWorkspaceMember = (variables) => fetch$1({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables });
-const cancelWorkspaceMemberInvite = (variables) => fetch$1({
+const inviteWorkspaceMember = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/invites", method: "post", ...variables, signal });
+const updateWorkspaceMemberInvite = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/invites/{inviteId}", method: "patch", ...variables, signal });
+const cancelWorkspaceMemberInvite = (variables, signal) => fetch$1({
   url: "/workspaces/{workspaceId}/invites/{inviteId}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const resendWorkspaceMemberInvite = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteId}/resend",
+const acceptWorkspaceMemberInvite = (variables, signal) => fetch$1({
+  url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept",
   method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const acceptWorkspaceMemberInvite = (variables) => fetch$1({
-  url: "/workspaces/{workspaceId}/invites/{inviteKey}/accept",
+const resendWorkspaceMemberInvite = (variables, signal) => fetch$1({
+  url: "/workspaces/{workspaceId}/invites/{inviteId}/resend",
   method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const getDatabaseList = (variables) => fetch$1({
+const getDatabaseList = (variables, signal) => fetch$1({
   url: "/dbs",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const getBranchList = (variables) => fetch$1({
+const getBranchList = (variables, signal) => fetch$1({
   url: "/dbs/{dbName}",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const createDatabase = (variables) => fetch$1({
+const createDatabase = (variables, signal) => fetch$1({
   url: "/dbs/{dbName}",
   method: "put",
-  ...variables
+  ...variables,
+  signal
 });
-const deleteDatabase = (variables) => fetch$1({
+const deleteDatabase = (variables, signal) => fetch$1({
   url: "/dbs/{dbName}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const getBranchDetails = (variables) => fetch$1({
-  url: "/db/{dbBranchName}",
+const getDatabaseMetadata = (variables, signal) => fetch$1({
+  url: "/dbs/{dbName}/metadata",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const createBranch = (variables) => fetch$1({
+const updateDatabaseMetadata = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/metadata", method: "patch", ...variables, signal });
+const getBranchDetails = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}",
-  method: "put",
-  ...variables
+  method: "get",
+  ...variables,
+  signal
 });
-const deleteBranch = (variables) => fetch$1({
+const createBranch = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}", method: "put", ...variables, signal });
+const deleteBranch = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const updateBranchMetadata = (variables) => fetch$1({
+const updateBranchMetadata = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/metadata",
   method: "put",
-  ...variables
+  ...variables,
+  signal
 });
-const getBranchMetadata = (variables) => fetch$1({
+const getBranchMetadata = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/metadata",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-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 getBranchStats = (variables) => fetch$1({
+const getBranchStats = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/stats",
   method: "get",
-  ...variables
+  ...variables,
+  signal
+});
+const getGitBranchesMapping = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables, signal });
+const addGitBranchesEntry = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables, signal });
+const removeGitBranchesEntry = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "delete", ...variables, signal });
+const resolveBranch = (variables, signal) => fetch$1({
+  url: "/dbs/{dbName}/resolveBranch",
+  method: "get",
+  ...variables,
+  signal
 });
-const createTable = (variables) => fetch$1({
+const getBranchMigrationHistory = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/migrations", method: "get", ...variables, signal });
+const getBranchMigrationPlan = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/migrations/plan", method: "post", ...variables, signal });
+const executeBranchMigrationPlan = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/migrations/execute", method: "post", ...variables, signal });
+const queryMigrationRequests = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/query", method: "post", ...variables, signal });
+const createMigrationRequest = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations", method: "post", ...variables, signal });
+const getMigrationRequest = (variables, signal) => fetch$1({
+  url: "/dbs/{dbName}/migrations/{mrNumber}",
+  method: "get",
+  ...variables,
+  signal
+});
+const updateMigrationRequest = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}", method: "patch", ...variables, signal });
+const listMigrationRequestsCommits = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}/commits", method: "post", ...variables, signal });
+const compareMigrationRequest = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}/compare", method: "post", ...variables, signal });
+const getMigrationRequestIsMerged = (variables, signal) => fetch$1({ url: "/dbs/{dbName}/migrations/{mrNumber}/merge", method: "get", ...variables, signal });
+const mergeMigrationRequest = (variables, signal) => fetch$1({
+  url: "/dbs/{dbName}/migrations/{mrNumber}/merge",
+  method: "post",
+  ...variables,
+  signal
+});
+const getBranchSchemaHistory = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/history", method: "post", ...variables, signal });
+const compareBranchWithUserSchema = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/compare", method: "post", ...variables, signal });
+const compareBranchSchemas = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/compare/{branchName}", method: "post", ...variables, signal });
+const updateBranchSchema = (variables, signal) => fetch$1({
+  url: "/db/{dbBranchName}/schema/update",
+  method: "post",
+  ...variables,
+  signal
+});
+const previewBranchSchemaEdit = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/preview", method: "post", ...variables, signal });
+const applyBranchSchemaEdit = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/schema/apply", method: "post", ...variables, signal });
+const createTable = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}",
   method: "put",
-  ...variables
+  ...variables,
+  signal
 });
-const deleteTable = (variables) => fetch$1({
+const deleteTable = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const updateTable = (variables) => fetch$1({
+const updateTable = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}",
   method: "patch",
-  ...variables
+  ...variables,
+  signal
 });
-const getTableSchema = (variables) => fetch$1({
+const getTableSchema = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/schema",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const setTableSchema = (variables) => fetch$1({
+const setTableSchema = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/schema",
   method: "put",
-  ...variables
+  ...variables,
+  signal
 });
-const getTableColumns = (variables) => fetch$1({
+const getTableColumns = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/columns",
   method: "get",
-  ...variables
+  ...variables,
+  signal
 });
-const addTableColumn = (variables) => fetch$1({
+const addTableColumn = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/columns",
   method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const getColumn = (variables) => fetch$1({
+const getColumn = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
   method: "get",
-  ...variables
-});
-const deleteColumn = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
-  method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const updateColumn = (variables) => fetch$1({
+const updateColumn = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
   method: "patch",
-  ...variables
-});
-const insertRecord = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/data",
-  method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-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 });
-const deleteRecord = (variables) => fetch$1({
-  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+const deleteColumn = (variables, signal) => fetch$1({
+  url: "/db/{dbBranchName}/tables/{tableName}/columns/{columnName}",
   method: "delete",
-  ...variables
+  ...variables,
+  signal
 });
-const getRecord = (variables) => fetch$1({
+const insertRecord = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data", method: "post", ...variables, signal });
+const getRecord = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
   method: "get",
-  ...variables
+  ...variables,
+  signal
+});
+const insertRecordWithID = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "put", ...variables, signal });
+const updateRecordWithID = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "patch", ...variables, signal });
+const upsertRecordWithID = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}", method: "post", ...variables, signal });
+const deleteRecord = (variables, signal) => fetch$1({
+  url: "/db/{dbBranchName}/tables/{tableName}/data/{recordId}",
+  method: "delete",
+  ...variables,
+  signal
 });
-const bulkInsertTableRecords = (variables) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/bulk", method: "post", ...variables });
-const queryTable = (variables) => fetch$1({
+const bulkInsertTableRecords = (variables, signal) => fetch$1({ url: "/db/{dbBranchName}/tables/{tableName}/bulk", method: "post", ...variables, signal });
+const queryTable = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/tables/{tableName}/query",
   method: "post",
-  ...variables
+  ...variables,
+  signal
 });
-const searchBranch = (variables) => fetch$1({
+const searchBranch = (variables, signal) => fetch$1({
   url: "/db/{dbBranchName}/search",
   method: "post",
-  ...variables
+  ...variables,
+  signal
+});
+const searchTable = (variables, signal) => fetch$1({
+  url: "/db/{dbBranchName}/tables/{tableName}/search",
+  method: "post",
+  ...variables,
+  signal
+});
+const summarizeTable = (variables, signal) => fetch$1({
+  url: "/db/{dbBranchName}/tables/{tableName}/summarize",
+  method: "post",
+  ...variables,
+  signal
+});
+const aggregateTable = (variables, signal) => fetch$1({
+  url: "/db/{dbBranchName}/tables/{tableName}/aggregate",
+  method: "post",
+  ...variables,
+  signal
+});
+const cPGetDatabaseList = (variables, signal) => fetch$1({
+  url: "/workspaces/{workspaceId}/dbs",
+  method: "get",
+  ...variables,
+  signal
+});
+const cPCreateDatabase = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/dbs/{dbName}", method: "put", ...variables, signal });
+const cPDeleteDatabase = (variables, signal) => fetch$1({
+  url: "/workspaces/{workspaceId}/dbs/{dbName}",
+  method: "delete",
+  ...variables,
+  signal
+});
+const cPGetCPDatabaseMetadata = (variables, signal) => fetch$1(
+  { url: "/workspaces/{workspaceId}/dbs/{dbName}/metadata", method: "get", ...variables, signal }
+);
+const cPUpdateCPDatabaseMetadata = (variables, signal) => fetch$1({ url: "/workspaces/{workspaceId}/dbs/{dbName}/metadata", method: "patch", ...variables, signal });
+const listRegions = (variables, signal) => fetch$1({
+  url: "/workspaces/{workspaceId}/regions",
+  method: "get",
+  ...variables,
+  signal
 });
 const operationsByTag = {
-  users: { getUser, updateUser, deleteUser, getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
+  users: { getUser, updateUser, deleteUser },
+  authentication: { getUserAPIKeys, createUserAPIKey, deleteUserAPIKey },
   workspaces: {
-    createWorkspace,
     getWorkspacesList,
+    createWorkspace,
     getWorkspace,
     updateWorkspace,
     deleteWorkspace,
     getWorkspaceMembersList,
     updateWorkspaceMemberRole,
-    removeWorkspaceMember,
+    removeWorkspaceMember
+  },
+  invites: {
     inviteWorkspaceMember,
+    updateWorkspaceMemberInvite,
     cancelWorkspaceMemberInvite,
-    resendWorkspaceMemberInvite,
-    acceptWorkspaceMemberInvite
+    acceptWorkspaceMemberInvite,
+    resendWorkspaceMemberInvite
   },
-  database: { getDatabaseList, createDatabase, deleteDatabase },
+  database: { getDatabaseList, createDatabase, deleteDatabase, getDatabaseMetadata, updateDatabaseMetadata },
   branch: {
     getBranchList,
     getBranchDetails,
@@ -384,10 +646,32 @@ const operationsByTag = {
     deleteBranch,
     updateBranchMetadata,
     getBranchMetadata,
+    getBranchStats,
+    getGitBranchesMapping,
+    addGitBranchesEntry,
+    removeGitBranchesEntry,
+    resolveBranch
+  },
+  migrations: {
     getBranchMigrationHistory,
-    executeBranchMigrationPlan,
     getBranchMigrationPlan,
-    getBranchStats
+    executeBranchMigrationPlan,
+    getBranchSchemaHistory,
+    compareBranchWithUserSchema,
+    compareBranchSchemas,
+    updateBranchSchema,
+    previewBranchSchemaEdit,
+    applyBranchSchemaEdit
+  },
+  migrationRequests: {
+    queryMigrationRequests,
+    createMigrationRequest,
+    getMigrationRequest,
+    updateMigrationRequest,
+    listMigrationRequestsCommits,
+    compareMigrationRequest,
+    getMigrationRequestIsMerged,
+    mergeMigrationRequest
   },
   table: {
     createTable,
@@ -398,26 +682,33 @@ const operationsByTag = {
     getTableColumns,
     addTableColumn,
     getColumn,
-    deleteColumn,
-    updateColumn
+    updateColumn,
+    deleteColumn
   },
   records: {
     insertRecord,
+    getRecord,
     insertRecordWithID,
     updateRecordWithID,
     upsertRecordWithID,
     deleteRecord,
-    getRecord,
-    bulkInsertTableRecords,
-    queryTable,
-    searchBranch
+    bulkInsertTableRecords
+  },
+  searchAndFilter: { queryTable, searchBranch, searchTable, summarizeTable, aggregateTable },
+  databases: {
+    cPGetDatabaseList,
+    cPCreateDatabase,
+    cPDeleteDatabase,
+    cPGetCPDatabaseMetadata,
+    cPUpdateCPDatabaseMetadata,
+    listRegions
   }
 };
 
 function getHostUrl(provider, type) {
-  if (isValidAlias(provider)) {
+  if (isHostProviderAlias(provider)) {
     return providers[provider][type];
-  } else if (isValidBuilder(provider)) {
+  } else if (isHostProviderBuilder(provider)) {
     return provider[type];
   }
   throw new Error("Invalid API provider");
@@ -432,18 +723,27 @@ const providers = {
     workspaces: "https://{workspaceId}.staging.xatabase.co"
   }
 };
-function isValidAlias(alias) {
+function isHostProviderAlias(alias) {
   return isString(alias) && Object.keys(providers).includes(alias);
 }
-function isValidBuilder(builder) {
+function isHostProviderBuilder(builder) {
   return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
 }
+function parseProviderString(provider = "production") {
+  if (isHostProviderAlias(provider)) {
+    return provider;
+  }
+  const [main, workspaces] = provider.split(",");
+  if (!main || !workspaces)
+    return null;
+  return { main, workspaces };
+}
 
 var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$6 = (obj, member, getter) => {
+var __privateGet$7 = (obj, member, getter) => {
   __accessCheck$7(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
@@ -452,7 +752,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$5 = (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;
@@ -463,46 +763,78 @@ class XataApiClient {
     __privateAdd$7(this, _extraProps, void 0);
     __privateAdd$7(this, _namespaces, {});
     const provider = options.host ?? "production";
-    const apiKey = options?.apiKey ?? getAPIKey();
+    const apiKey = options.apiKey ?? getAPIKey();
+    const trace = options.trace ?? defaultTrace;
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
-    __privateSet$5(this, _extraProps, {
+    __privateSet$7(this, _extraProps, {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
       fetchImpl: getFetchImplementation(options.fetch),
-      apiKey
+      apiKey,
+      trace
     });
   }
   get user() {
-    if (!__privateGet$6(this, _namespaces).user)
-      __privateGet$6(this, _namespaces).user = new UserApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).user;
+    if (!__privateGet$7(this, _namespaces).user)
+      __privateGet$7(this, _namespaces).user = new UserApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).user;
+  }
+  get authentication() {
+    if (!__privateGet$7(this, _namespaces).authentication)
+      __privateGet$7(this, _namespaces).authentication = new AuthenticationApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).authentication;
   }
   get workspaces() {
-    if (!__privateGet$6(this, _namespaces).workspaces)
-      __privateGet$6(this, _namespaces).workspaces = new WorkspaceApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).workspaces;
+    if (!__privateGet$7(this, _namespaces).workspaces)
+      __privateGet$7(this, _namespaces).workspaces = new WorkspaceApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).workspaces;
   }
-  get 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 invites() {
+    if (!__privateGet$7(this, _namespaces).invites)
+      __privateGet$7(this, _namespaces).invites = new InvitesApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).invites;
+  }
+  get database() {
+    if (!__privateGet$7(this, _namespaces).database)
+      __privateGet$7(this, _namespaces).database = new DatabaseApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).database;
   }
   get branches() {
-    if (!__privateGet$6(this, _namespaces).branches)
-      __privateGet$6(this, _namespaces).branches = new BranchApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).branches;
+    if (!__privateGet$7(this, _namespaces).branches)
+      __privateGet$7(this, _namespaces).branches = new BranchApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).branches;
+  }
+  get migrations() {
+    if (!__privateGet$7(this, _namespaces).migrations)
+      __privateGet$7(this, _namespaces).migrations = new MigrationsApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).migrations;
+  }
+  get migrationRequests() {
+    if (!__privateGet$7(this, _namespaces).migrationRequests)
+      __privateGet$7(this, _namespaces).migrationRequests = new MigrationRequestsApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).migrationRequests;
   }
   get tables() {
-    if (!__privateGet$6(this, _namespaces).tables)
-      __privateGet$6(this, _namespaces).tables = new TableApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).tables;
+    if (!__privateGet$7(this, _namespaces).tables)
+      __privateGet$7(this, _namespaces).tables = new TableApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).tables;
   }
   get records() {
-    if (!__privateGet$6(this, _namespaces).records)
-      __privateGet$6(this, _namespaces).records = new RecordsApi(__privateGet$6(this, _extraProps));
-    return __privateGet$6(this, _namespaces).records;
+    if (!__privateGet$7(this, _namespaces).records)
+      __privateGet$7(this, _namespaces).records = new RecordsApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).records;
+  }
+  get searchAndFilter() {
+    if (!__privateGet$7(this, _namespaces).searchAndFilter)
+      __privateGet$7(this, _namespaces).searchAndFilter = new SearchAndFilterApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).searchAndFilter;
+  }
+  get databases() {
+    if (!__privateGet$7(this, _namespaces).databases)
+      __privateGet$7(this, _namespaces).databases = new DatabasesApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).databases;
   }
 }
 _extraProps = new WeakMap();
@@ -520,17 +852,22 @@ class UserApi {
   deleteUser() {
     return operationsByTag.users.deleteUser({ ...this.extraProps });
   }
+}
+class AuthenticationApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
   getUserAPIKeys() {
-    return operationsByTag.users.getUserAPIKeys({ ...this.extraProps });
+    return operationsByTag.authentication.getUserAPIKeys({ ...this.extraProps });
   }
   createUserAPIKey(keyName) {
-    return operationsByTag.users.createUserAPIKey({
+    return operationsByTag.authentication.createUserAPIKey({
       pathParams: { keyName },
       ...this.extraProps
     });
   }
   deleteUserAPIKey(keyName) {
-    return operationsByTag.users.deleteUserAPIKey({
+    return operationsByTag.authentication.deleteUserAPIKey({
       pathParams: { keyName },
       ...this.extraProps
     });
@@ -540,15 +877,15 @@ class WorkspaceApi {
   constructor(extraProps) {
     this.extraProps = extraProps;
   }
+  getWorkspacesList() {
+    return operationsByTag.workspaces.getWorkspacesList({ ...this.extraProps });
+  }
   createWorkspace(workspaceMeta) {
     return operationsByTag.workspaces.createWorkspace({
       body: workspaceMeta,
       ...this.extraProps
     });
   }
-  getWorkspacesList() {
-    return operationsByTag.workspaces.getWorkspacesList({ ...this.extraProps });
-  }
   getWorkspace(workspaceId) {
     return operationsByTag.workspaces.getWorkspace({
       pathParams: { workspaceId },
@@ -587,31 +924,43 @@ class WorkspaceApi {
       ...this.extraProps
     });
   }
+}
+class InvitesApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
   inviteWorkspaceMember(workspaceId, email, role) {
-    return operationsByTag.workspaces.inviteWorkspaceMember({
+    return operationsByTag.invites.inviteWorkspaceMember({
       pathParams: { workspaceId },
       body: { email, role },
       ...this.extraProps
     });
   }
-  cancelWorkspaceMemberInvite(workspaceId, inviteId) {
-    return operationsByTag.workspaces.cancelWorkspaceMemberInvite({
+  updateWorkspaceMemberInvite(workspaceId, inviteId, role) {
+    return operationsByTag.invites.updateWorkspaceMemberInvite({
       pathParams: { workspaceId, inviteId },
+      body: { role },
       ...this.extraProps
     });
   }
-  resendWorkspaceMemberInvite(workspaceId, inviteId) {
-    return operationsByTag.workspaces.resendWorkspaceMemberInvite({
+  cancelWorkspaceMemberInvite(workspaceId, inviteId) {
+    return operationsByTag.invites.cancelWorkspaceMemberInvite({
       pathParams: { workspaceId, inviteId },
       ...this.extraProps
     });
   }
   acceptWorkspaceMemberInvite(workspaceId, inviteKey) {
-    return operationsByTag.workspaces.acceptWorkspaceMemberInvite({
+    return operationsByTag.invites.acceptWorkspaceMemberInvite({
       pathParams: { workspaceId, inviteKey },
       ...this.extraProps
     });
   }
+  resendWorkspaceMemberInvite(workspaceId, inviteId) {
+    return operationsByTag.invites.resendWorkspaceMemberInvite({
+      pathParams: { workspaceId, inviteId },
+      ...this.extraProps
+    });
+  }
 }
 class DatabaseApi {
   constructor(extraProps) {
@@ -636,6 +985,19 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
+  getDatabaseMetadata(workspace, dbName) {
+    return operationsByTag.database.getDatabaseMetadata({
+      pathParams: { workspace, dbName },
+      ...this.extraProps
+    });
+  }
+  updateDatabaseMetadata(workspace, dbName, options = {}) {
+    return operationsByTag.database.updateDatabaseMetadata({
+      pathParams: { workspace, dbName },
+      body: options,
+      ...this.extraProps
+    });
+  }
 }
 class BranchApi {
   constructor(extraProps) {
@@ -653,10 +1015,10 @@ class BranchApi {
       ...this.extraProps
     });
   }
-  createBranch(workspace, database, branch, from = "", options = {}) {
+  createBranch(workspace, database, branch, from, options = {}) {
     return operationsByTag.branch.createBranch({
       pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      queryParams: { from },
+      queryParams: isString(from) ? { from } : void 0,
       body: options,
       ...this.extraProps
     });
@@ -680,30 +1042,36 @@ class BranchApi {
       ...this.extraProps
     });
   }
-  getBranchMigrationHistory(workspace, database, branch, options = {}) {
-    return operationsByTag.branch.getBranchMigrationHistory({
+  getBranchStats(workspace, database, branch) {
+    return operationsByTag.branch.getBranchStats({
       pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: options,
       ...this.extraProps
     });
   }
-  executeBranchMigrationPlan(workspace, database, branch, migrationPlan) {
-    return operationsByTag.branch.executeBranchMigrationPlan({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: migrationPlan,
+  getGitBranchesMapping(workspace, dbName) {
+    return operationsByTag.branch.getGitBranchesMapping({
+      pathParams: { workspace, dbName },
       ...this.extraProps
     });
   }
-  getBranchMigrationPlan(workspace, database, branch, schema) {
-    return operationsByTag.branch.getBranchMigrationPlan({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
-      body: schema,
+  addGitBranchesEntry(workspace, dbName, body) {
+    return operationsByTag.branch.addGitBranchesEntry({
+      pathParams: { workspace, dbName },
+      body,
       ...this.extraProps
     });
   }
-  getBranchStats(workspace, database, branch) {
-    return operationsByTag.branch.getBranchStats({
-      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+  removeGitBranchesEntry(workspace, dbName, gitBranch) {
+    return operationsByTag.branch.removeGitBranchesEntry({
+      pathParams: { workspace, dbName },
+      queryParams: { gitBranch },
+      ...this.extraProps
+    });
+  }
+  resolveBranch(workspace, dbName, gitBranch, fallbackBranch) {
+    return operationsByTag.branch.resolveBranch({
+      pathParams: { workspace, dbName },
+      queryParams: { gitBranch, fallbackBranch },
       ...this.extraProps
     });
   }
@@ -763,16 +1131,16 @@ class TableApi {
       ...this.extraProps
     });
   }
-  deleteColumn(workspace, database, branch, tableName, columnName) {
-    return operationsByTag.table.deleteColumn({
+  updateColumn(workspace, database, branch, tableName, columnName, options) {
+    return operationsByTag.table.updateColumn({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
+      body: options,
       ...this.extraProps
     });
   }
-  updateColumn(workspace, database, branch, tableName, columnName, options) {
-    return operationsByTag.table.updateColumn({
+  deleteColumn(workspace, database, branch, tableName, columnName) {
+    return operationsByTag.table.deleteColumn({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, columnName },
-      body: options,
       ...this.extraProps
     });
   }
@@ -781,13 +1149,21 @@ 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
     });
   }
+  getRecord(workspace, database, branch, tableName, recordId, options = {}) {
+    return operationsByTag.records.getRecord({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
+      queryParams: options,
+      ...this.extraProps
+    });
+  }
   insertRecordWithID(workspace, database, branch, tableName, recordId, record, options = {}) {
     return operationsByTag.records.insertRecordWithID({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId },
@@ -812,88 +1188,292 @@ 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 },
-      ...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
     });
   }
+}
+class SearchAndFilterApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
   queryTable(workspace, database, branch, tableName, query) {
-    return operationsByTag.records.queryTable({
+    return operationsByTag.searchAndFilter.queryTable({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      body: query,
+      ...this.extraProps
+    });
+  }
+  searchTable(workspace, database, branch, tableName, query) {
+    return operationsByTag.searchAndFilter.searchTable({
       pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
       body: query,
       ...this.extraProps
     });
   }
   searchBranch(workspace, database, branch, query) {
-    return operationsByTag.records.searchBranch({
+    return operationsByTag.searchAndFilter.searchBranch({
       pathParams: { workspace, dbBranchName: `${database}:${branch}` },
       body: query,
       ...this.extraProps
     });
   }
-}
-
-class XataApiPlugin {
-  async build(options) {
-    const { fetchImpl, apiKey } = await options.getFetchProps();
-    return new XataApiClient({ fetch: fetchImpl, apiKey });
+  summarizeTable(workspace, database, branch, tableName, query) {
+    return operationsByTag.searchAndFilter.summarizeTable({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      body: query,
+      ...this.extraProps
+    });
+  }
+  aggregateTable(workspace, database, branch, tableName, query) {
+    return operationsByTag.searchAndFilter.aggregateTable({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      body: query,
+      ...this.extraProps
+    });
   }
 }
-
-class XataPlugin {
-}
-
-var __accessCheck$6 = (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");
-  return getter ? getter.call(obj) : member.get(obj);
-};
-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$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$6(this, _query, void 0);
-    __privateSet$4(this, _query, query);
-    this.meta = meta;
-    this.records = records;
+class MigrationRequestsApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
   }
-  async nextPage(size, offset) {
-    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, after: this.meta.page.cursor } });
+  queryMigrationRequests(workspace, database, options = {}) {
+    return operationsByTag.migrationRequests.queryMigrationRequests({
+      pathParams: { workspace, dbName: database },
+      body: options,
+      ...this.extraProps
+    });
+  }
+  createMigrationRequest(workspace, database, options) {
+    return operationsByTag.migrationRequests.createMigrationRequest({
+      pathParams: { workspace, dbName: database },
+      body: options,
+      ...this.extraProps
+    });
+  }
+  getMigrationRequest(workspace, database, migrationRequest) {
+    return operationsByTag.migrationRequests.getMigrationRequest({
+      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      ...this.extraProps
+    });
+  }
+  updateMigrationRequest(workspace, database, migrationRequest, options) {
+    return operationsByTag.migrationRequests.updateMigrationRequest({
+      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      body: options,
+      ...this.extraProps
+    });
+  }
+  listMigrationRequestsCommits(workspace, database, migrationRequest, options = {}) {
+    return operationsByTag.migrationRequests.listMigrationRequestsCommits({
+      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      body: options,
+      ...this.extraProps
+    });
+  }
+  compareMigrationRequest(workspace, database, migrationRequest) {
+    return operationsByTag.migrationRequests.compareMigrationRequest({
+      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      ...this.extraProps
+    });
+  }
+  getMigrationRequestIsMerged(workspace, database, migrationRequest) {
+    return operationsByTag.migrationRequests.getMigrationRequestIsMerged({
+      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      ...this.extraProps
+    });
+  }
+  mergeMigrationRequest(workspace, database, migrationRequest) {
+    return operationsByTag.migrationRequests.mergeMigrationRequest({
+      pathParams: { workspace, dbName: database, mrNumber: migrationRequest },
+      ...this.extraProps
+    });
+  }
+}
+class MigrationsApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
+  getBranchMigrationHistory(workspace, database, branch, options = {}) {
+    return operationsByTag.migrations.getBranchMigrationHistory({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: options,
+      ...this.extraProps
+    });
+  }
+  getBranchMigrationPlan(workspace, database, branch, schema) {
+    return operationsByTag.migrations.getBranchMigrationPlan({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: schema,
+      ...this.extraProps
+    });
+  }
+  executeBranchMigrationPlan(workspace, database, branch, migrationPlan) {
+    return operationsByTag.migrations.executeBranchMigrationPlan({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: migrationPlan,
+      ...this.extraProps
+    });
+  }
+  getBranchSchemaHistory(workspace, database, branch, options = {}) {
+    return operationsByTag.migrations.getBranchSchemaHistory({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: options,
+      ...this.extraProps
+    });
+  }
+  compareBranchWithUserSchema(workspace, database, branch, schema) {
+    return operationsByTag.migrations.compareBranchWithUserSchema({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: { schema },
+      ...this.extraProps
+    });
+  }
+  compareBranchSchemas(workspace, database, branch, branchName, schema) {
+    return operationsByTag.migrations.compareBranchSchemas({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}`, branchName },
+      body: { schema },
+      ...this.extraProps
+    });
+  }
+  updateBranchSchema(workspace, database, branch, migration) {
+    return operationsByTag.migrations.updateBranchSchema({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: migration,
+      ...this.extraProps
+    });
+  }
+  previewBranchSchemaEdit(workspace, database, branch, migration) {
+    return operationsByTag.migrations.previewBranchSchemaEdit({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: migration,
+      ...this.extraProps
+    });
+  }
+  applyBranchSchemaEdit(workspace, database, branch, edits) {
+    return operationsByTag.migrations.applyBranchSchemaEdit({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}` },
+      body: { edits },
+      ...this.extraProps
+    });
+  }
+}
+class DatabasesApi {
+  constructor(extraProps) {
+    this.extraProps = extraProps;
+  }
+  getDatabaseList(workspaceId) {
+    return operationsByTag.databases.cPGetDatabaseList({
+      pathParams: { workspaceId },
+      ...this.extraProps
+    });
+  }
+  createDatabase(workspaceId, dbName, options) {
+    return operationsByTag.databases.cPCreateDatabase({
+      pathParams: { workspaceId, dbName },
+      body: options,
+      ...this.extraProps
+    });
+  }
+  deleteDatabase(workspaceId, dbName) {
+    return operationsByTag.databases.cPDeleteDatabase({
+      pathParams: { workspaceId, dbName },
+      ...this.extraProps
+    });
+  }
+  getDatabaseMetadata(workspaceId, dbName) {
+    return operationsByTag.databases.cPGetCPDatabaseMetadata({
+      pathParams: { workspaceId, dbName },
+      ...this.extraProps
+    });
+  }
+  updateDatabaseMetadata(workspaceId, dbName, metadata) {
+    return operationsByTag.databases.cPUpdateCPDatabaseMetadata({
+      pathParams: { workspaceId, dbName },
+      body: metadata,
+      ...this.extraProps
+    });
+  }
+  listRegions(workspaceId) {
+    return operationsByTag.databases.listRegions({
+      pathParams: { workspaceId },
+      ...this.extraProps
+    });
+  }
+}
+
+class XataApiPlugin {
+  async build(options) {
+    const { fetchImpl, apiKey } = await options.getFetchProps();
+    return new XataApiClient({ fetch: fetchImpl, apiKey });
+  }
+}
+
+class XataPlugin {
+}
+
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+function cleanFilter(filter) {
+  if (!filter)
+    return void 0;
+  const values = Object.values(filter).filter(Boolean).filter((value) => Array.isArray(value) ? value.length > 0 : true);
+  return values.length > 0 ? filter : void 0;
+}
+
+var __accessCheck$6 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$6 = (obj, member, getter) => {
+  __accessCheck$6(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+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$6 = (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, _page;
+class Page {
+  constructor(query, meta, records = []) {
+    __privateAdd$6(this, _query, void 0);
+    __privateSet$6(this, _query, query);
+    this.meta = meta;
+    this.records = new RecordArray(this, records);
+  }
+  async nextPage(size, offset) {
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, after: this.meta.page.cursor } });
   }
   async previousPage(size, offset) {
-    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, before: this.meta.page.cursor } });
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, before: this.meta.page.cursor } });
   }
   async firstPage(size, offset) {
-    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, first: this.meta.page.cursor } });
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, first: this.meta.page.cursor } });
   }
   async lastPage(size, offset) {
-    return __privateGet$5(this, _query).getPaginated({ page: { size, offset, last: this.meta.page.cursor } });
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, last: this.meta.page.cursor } });
   }
   hasNextPage() {
     return this.meta.page.more;
@@ -901,15 +1481,62 @@ class Page {
 }
 _query = new WeakMap();
 const PAGINATION_MAX_SIZE = 200;
-const PAGINATION_DEFAULT_SIZE = 200;
+const PAGINATION_DEFAULT_SIZE = 20;
 const PAGINATION_MAX_OFFSET = 800;
 const PAGINATION_DEFAULT_OFFSET = 0;
+function isCursorPaginationOptions(options) {
+  return isDefined(options) && (isDefined(options.first) || isDefined(options.last) || isDefined(options.after) || isDefined(options.before));
+}
+const _RecordArray = class extends Array {
+  constructor(...args) {
+    super(..._RecordArray.parseConstructorParams(...args));
+    __privateAdd$6(this, _page, void 0);
+    __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);
+    return new _RecordArray(newPage);
+  }
+  async previousPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).previousPage(size, offset);
+    return new _RecordArray(newPage);
+  }
+  async firstPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).firstPage(size, offset);
+    return new _RecordArray(newPage);
+  }
+  async lastPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).lastPage(size, offset);
+    return new _RecordArray(newPage);
+  }
+  hasNextPage() {
+    return __privateGet$6(this, _page).meta.page.more;
+  }
+};
+let RecordArray = _RecordArray;
+_page = new WeakMap();
 
 var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$4 = (obj, member, getter) => {
+var __privateGet$5 = (obj, member, getter) => {
   __accessCheck$5(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
@@ -918,34 +1545,40 @@ 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$3 = (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;
 };
-var _table$1, _repository, _data;
+var __privateMethod$3 = (obj, member, method) => {
+  __accessCheck$5(obj, member, "access private method");
+  return method;
+};
+var _table$1, _repository, _data, _cleanFilterConstraint, cleanFilterConstraint_fn;
 const _Query = class {
-  constructor(repository, table, data, parent) {
+  constructor(repository, table, data, rawParent) {
+    __privateAdd$5(this, _cleanFilterConstraint);
     __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 = [];
-    __privateSet$3(this, _table$1, table);
+    this.records = new RecordArray(this, []);
+    __privateSet$5(this, _table$1, table);
     if (repository) {
-      __privateSet$3(this, _repository, repository);
+      __privateSet$5(this, _repository, repository);
     } else {
-      __privateSet$3(this, _repository, this);
+      __privateSet$5(this, _repository, this);
     }
-    __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;
+    const parent = cleanParent(data, rawParent);
+    __privateGet$5(this, _data).filter = data.filter ?? parent?.filter ?? {};
+    __privateGet$5(this, _data).filter.$any = data.filter?.$any ?? parent?.filter?.$any;
+    __privateGet$5(this, _data).filter.$all = data.filter?.$all ?? parent?.filter?.$all;
+    __privateGet$5(this, _data).filter.$not = data.filter?.$not ?? parent?.filter?.$not;
+    __privateGet$5(this, _data).filter.$none = data.filter?.$none ?? parent?.filter?.$none;
+    __privateGet$5(this, _data).sort = data.sort ?? parent?.sort;
+    __privateGet$5(this, _data).columns = data.columns ?? parent?.columns;
+    __privateGet$5(this, _data).pagination = data.pagination ?? parent?.pagination;
+    __privateGet$5(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);
@@ -956,83 +1589,121 @@ const _Query = class {
     Object.defineProperty(this, "repository", { enumerable: false });
   }
   getQueryOptions() {
-    return __privateGet$4(this, _data);
+    return __privateGet$5(this, _data);
   }
   key() {
-    const { columns = [], filter = {}, sort = [], page = {} } = __privateGet$4(this, _data);
-    const key = JSON.stringify({ columns, filter, sort, page });
+    const { columns = [], filter = {}, sort = [], pagination = {} } = __privateGet$5(this, _data);
+    const key = JSON.stringify({ columns, filter, sort, pagination });
     return toBase64(key);
   }
   any(...queries) {
     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));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $any } }, __privateGet$5(this, _data));
   }
   all(...queries) {
     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));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
   }
   not(...queries) {
     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));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $not } }, __privateGet$5(this, _data));
   }
   none(...queries) {
     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));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $none } }, __privateGet$5(this, _data));
   }
   filter(a, b) {
     if (arguments.length === 1) {
-      const constraints = Object.entries(a).map(([column, constraint]) => ({ [column]: constraint }));
-      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));
+      const constraints = Object.entries(a ?? {}).map(([column, constraint]) => ({
+        [column]: __privateMethod$3(this, _cleanFilterConstraint, cleanFilterConstraint_fn).call(this, column, constraint)
+      }));
+      const $all = compact([__privateGet$5(this, _data).filter?.$all].flat().concat(constraints));
+      return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
     } else {
-      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));
+      const constraints = isDefined(a) && isDefined(b) ? [{ [a]: __privateMethod$3(this, _cleanFilterConstraint, cleanFilterConstraint_fn).call(this, a, b) }] : void 0;
+      const $all = compact([__privateGet$5(this, _data).filter?.$all].flat().concat(constraints));
+      return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
     }
   }
-  sort(column, direction) {
-    const originalSort = [__privateGet$4(this, _data).sort ?? []].flat();
+  sort(column, direction = "asc") {
+    const originalSort = [__privateGet$5(this, _data).sort ?? []].flat();
     const sort = [...originalSort, { column, direction }];
-    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { sort }, __privateGet$4(this, _data));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { sort }, __privateGet$5(this, _data));
   }
   select(columns) {
-    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { columns }, __privateGet$4(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$4(this, _repository), __privateGet$4(this, _table$1), options, __privateGet$4(this, _data));
-    return __privateGet$4(this, _repository).query(query);
+    const query = new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), options, __privateGet$5(this, _data));
+    return __privateGet$5(this, _repository).query(query);
   }
   async *[Symbol.asyncIterator]() {
-    for await (const [record] of this.getIterator(1)) {
+    for await (const [record] of this.getIterator({ batchSize: 1 })) {
       yield record;
     }
   }
-  async *getIterator(chunk, options = {}) {
-    let offset = 0;
-    let end = false;
-    while (!end) {
-      const { records, meta } = await this.getPaginated({ ...options, page: { size: chunk, offset } });
-      yield records;
-      offset += chunk;
-      end = !meta.page.more;
+  async *getIterator(options = {}) {
+    const { batchSize = 1 } = options;
+    let page = await this.getPaginated({ ...options, pagination: { size: batchSize, offset: 0 } });
+    let more = page.hasNextPage();
+    yield page.records;
+    while (more) {
+      page = await page.nextPage();
+      more = page.hasNextPage();
+      yield page.records;
     }
   }
   async getMany(options = {}) {
-    const { records } = await this.getPaginated(options);
-    return records;
+    const { pagination = {}, ...rest } = options;
+    const { size = PAGINATION_DEFAULT_SIZE, offset } = pagination;
+    const batchSize = size <= PAGINATION_MAX_SIZE ? size : PAGINATION_MAX_SIZE;
+    let page = await this.getPaginated({ ...rest, pagination: { size: batchSize, offset } });
+    const results = [...page.records];
+    while (page.hasNextPage() && results.length < size) {
+      page = await page.nextPage();
+      results.push(...page.records);
+    }
+    if (page.hasNextPage() && options.pagination?.size === void 0) {
+      console.trace("Calling getMany does not return all results. Paginate to get all results or call getAll.");
+    }
+    const array = new RecordArray(page, results.slice(0, size));
+    return array;
   }
-  async getAll(chunk = PAGINATION_MAX_SIZE, options = {}) {
+  async getAll(options = {}) {
+    const { batchSize = PAGINATION_MAX_SIZE, ...rest } = options;
     const results = [];
-    for await (const page of this.getIterator(chunk, options)) {
+    for await (const page of this.getIterator({ ...rest, batchSize })) {
       results.push(...page);
     }
     return results;
   }
   async getFirst(options = {}) {
-    const records = await this.getMany({ ...options, page: { size: 1 } });
-    return records[0] || null;
+    const records = await this.getMany({ ...options, pagination: { size: 1 } });
+    return records[0] ?? null;
+  }
+  async getFirstOrThrow(options = {}) {
+    const records = await this.getMany({ ...options, pagination: { size: 1 } });
+    if (records[0] === void 0)
+      throw new Error("No results found.");
+    return records[0];
+  }
+  async summarize(params = {}) {
+    const { summaries, summariesFilter, ...options } = params;
+    const query = new _Query(
+      __privateGet$5(this, _repository),
+      __privateGet$5(this, _table$1),
+      options,
+      __privateGet$5(this, _data)
+    );
+    return __privateGet$5(this, _repository).summarizeTable(query, summaries, summariesFilter);
   }
   cache(ttl) {
-    return new _Query(__privateGet$4(this, _repository), __privateGet$4(this, _table$1), { cache: ttl }, __privateGet$4(this, _data));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { cache: ttl }, __privateGet$5(this, _data));
   }
   nextPage(size, offset) {
     return this.firstPage(size, offset);
@@ -1041,10 +1712,10 @@ const _Query = class {
     return this.firstPage(size, offset);
   }
   firstPage(size, offset) {
-    return this.getPaginated({ page: { size, offset } });
+    return this.getPaginated({ pagination: { size, offset } });
   }
   lastPage(size, offset) {
-    return this.getPaginated({ page: { size, offset, before: "end" } });
+    return this.getPaginated({ pagination: { size, offset, before: "end" } });
   }
   hasNextPage() {
     return this.meta.page.more;
@@ -1054,12 +1725,31 @@ let Query = _Query;
 _table$1 = new WeakMap();
 _repository = new WeakMap();
 _data = new WeakMap();
+_cleanFilterConstraint = new WeakSet();
+cleanFilterConstraint_fn = function(column, value) {
+  const columnType = __privateGet$5(this, _table$1).schema?.columns.find(({ name }) => name === column)?.type;
+  if (columnType === "multiple" && (isString(value) || isStringArray(value))) {
+    return { $includes: value };
+  }
+  if (columnType === "link" && isObject(value) && isString(value.id)) {
+    return value.id;
+  }
+  return value;
+};
+function cleanParent(data, parent) {
+  if (isCursorPaginationOptions(data.pagination)) {
+    return { ...parent, sorting: void 0, filter: void 0 };
+  }
+  return parent;
+}
 
 function isIdentifiable(x) {
   return isObject(x) && isString(x?.id);
 }
 function isXataRecord(x) {
-  return isIdentifiable(x) && typeof x?.xata === "object" && typeof x?.xata?.version === "number";
+  const record = x;
+  const metadata = record?.getMetadata();
+  return isIdentifiable(x) && isObject(metadata) && typeof metadata.version === "number";
 }
 
 function isSortFilterString(value) {
@@ -1089,7 +1779,7 @@ var __accessCheck$4 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$3 = (obj, member, getter) => {
+var __privateGet$4 = (obj, member, getter) => {
   __accessCheck$4(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
@@ -1098,7 +1788,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$2 = (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;
@@ -1107,304 +1797,444 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$4(obj, member, "access private method");
   return method;
 };
-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;
+var _table, _getFetchProps, _db, _cache, _schemaTables$2, _trace, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchemaTables$1, getSchemaTables_fn$1;
 class Repository extends Query {
 }
 class RestRepository extends Query {
   constructor(options) {
-    super(null, options.table, {});
+    super(
+      null,
+      { name: options.table, schema: options.schemaTables?.find((table) => table.name === options.table) },
+      {}
+    );
     __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, _getSchemaTables$1);
     __privateAdd$4(this, _table, void 0);
-    __privateAdd$4(this, _links, void 0);
     __privateAdd$4(this, _getFetchProps, void 0);
+    __privateAdd$4(this, _db, 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)) {
-      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");
-      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");
-      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)) {
-      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 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$3(this, _table), recordId },
-        ...fetchProps
+    __privateAdd$4(this, _schemaTables$2, void 0);
+    __privateAdd$4(this, _trace, void 0);
+    __privateSet$4(this, _table, options.table);
+    __privateSet$4(this, _db, options.db);
+    __privateSet$4(this, _cache, options.pluginOptions.cache);
+    __privateSet$4(this, _schemaTables$2, options.schemaTables);
+    __privateSet$4(this, _getFetchProps, async () => {
+      const props = await options.pluginOptions.getFetchProps();
+      return { ...props, sessionID: generateUUID() };
+    });
+    const trace = options.pluginOptions.trace ?? defaultTrace;
+    __privateSet$4(this, _trace, async (name, fn, options2 = {}) => {
+      return trace(name, fn, {
+        ...options2,
+        [TraceAttributes.TABLE]: __privateGet$4(this, _table),
+        [TraceAttributes.KIND]: "sdk-operation",
+        [TraceAttributes.VERSION]: VERSION
       });
-      return initObject(this.db, __privateGet$3(this, _links), __privateGet$3(this, _table), response);
-    } catch (e) {
-      if (isObject(e) && e.status === 404) {
-        return null;
+    });
+  }
+  async create(a, b, c) {
+    return __privateGet$4(this, _trace).call(this, "create", async () => {
+      if (Array.isArray(a)) {
+        if (a.length === 0)
+          return [];
+        const columns = isStringArray(b) ? b : void 0;
+        return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a, columns);
       }
-      throw e;
-    }
+      if (isString(a) && isObject(b)) {
+        if (a === "")
+          throw new Error("The id can't be empty");
+        const columns = isStringArray(c) ? c : void 0;
+        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b, columns);
+      }
+      if (isObject(a) && isString(a.id)) {
+        if (a.id === "")
+          throw new Error("The id can't be empty");
+        const columns = isStringArray(b) ? b : void 0;
+        return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 }, columns);
+      }
+      if (isObject(a)) {
+        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 update(a, b) {
-    if (Array.isArray(a)) {
-      if (a.length > 100) {
-        console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
+  async read(a, b) {
+    return __privateGet$4(this, _trace).call(this, "read", async () => {
+      const columns = isStringArray(b) ? b : ["*"];
+      if (Array.isArray(a)) {
+        if (a.length === 0)
+          return [];
+        const ids = a.map((item) => extractId(item));
+        const finalObjects = await this.getAll({ filter: { id: { $any: compact(ids) } }, columns });
+        const dictionary = finalObjects.reduce((acc, object) => {
+          acc[object.id] = object;
+          return acc;
+        }, {});
+        return ids.map((id2) => dictionary[id2 ?? ""] ?? null);
       }
-      return Promise.all(a.map((object) => this.update(object)));
-    }
-    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;
-    }
-    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;
-    }
-    throw new Error("Invalid arguments for update method");
+      const id = extractId(a);
+      if (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: id
+            },
+            queryParams: { columns },
+            ...fetchProps
+          });
+          const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+          return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
+        } catch (e) {
+          if (isObject(e) && e.status === 404) {
+            return null;
+          }
+          throw e;
+        }
+      }
+      return null;
+    });
   }
-  async createOrUpdate(a, b) {
-    if (Array.isArray(a)) {
-      if (a.length > 100) {
-        console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
+  async readOrThrow(a, b) {
+    return __privateGet$4(this, _trace).call(this, "readOrThrow", async () => {
+      const result = await this.read(a, b);
+      if (Array.isArray(result)) {
+        const missingIds = compact(
+          a.filter((_item, index) => result[index] === null).map((item) => extractId(item))
+        );
+        if (missingIds.length > 0) {
+          throw new Error(`Could not find records with ids: ${missingIds.join(", ")}`);
+        }
+        return result;
       }
-      return Promise.all(a.map((object) => this.createOrUpdate(object)));
-    }
-    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;
-    }
-    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;
-    }
-    throw new Error("Invalid arguments for createOrUpdate method");
+      if (result === null) {
+        const id = extractId(a) ?? "unknown";
+        throw new Error(`Record with id ${id} not found`);
+      }
+      return result;
+    });
   }
-  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");
+  async update(a, b, c) {
+    return __privateGet$4(this, _trace).call(this, "update", async () => {
+      if (Array.isArray(a)) {
+        if (a.length === 0)
+          return [];
+        if (a.length > 100) {
+          console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
+        }
+        const columns = isStringArray(b) ? b : ["*"];
+        return Promise.all(a.map((object) => this.update(object, columns)));
       }
-      await Promise.all(a.map((id) => this.delete(id)));
-      return;
-    }
-    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");
+      if (isString(a) && isObject(b)) {
+        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)) {
+        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 updateOrThrow(a, b, c) {
+    return __privateGet$4(this, _trace).call(this, "updateOrThrow", async () => {
+      const result = await this.update(a, b, c);
+      if (Array.isArray(result)) {
+        const missingIds = compact(
+          a.filter((_item, index) => result[index] === null).map((item) => extractId(item))
+        );
+        if (missingIds.length > 0) {
+          throw new Error(`Could not find records with ids: ${missingIds.join(", ")}`);
+        }
+        return result;
+      }
+      if (result === null) {
+        const id = extractId(a) ?? "unknown";
+        throw new Error(`Record with id ${id} not found`);
+      }
+      return result;
+    });
+  }
+  async createOrUpdate(a, b, c) {
+    return __privateGet$4(this, _trace).call(this, "createOrUpdate", async () => {
+      if (Array.isArray(a)) {
+        if (a.length === 0)
+          return [];
+        if (a.length > 100) {
+          console.warn("Bulk update operation is not optimized in the Xata API yet, this request might be slow");
+        }
+        const columns = isStringArray(b) ? b : ["*"];
+        return Promise.all(a.map((object) => this.createOrUpdate(object, columns)));
+      }
+      if (isString(a) && isObject(b)) {
+        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)) {
+        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");
+    });
+  }
+  async delete(a, b) {
+    return __privateGet$4(this, _trace).call(this, "delete", async () => {
+      if (Array.isArray(a)) {
+        if (a.length === 0)
+          return [];
+        if (a.length > 100) {
+          console.warn("Bulk delete operation is not optimized in the Xata API yet, this request might be slow");
+        }
+        return Promise.all(a.map((id) => this.delete(id, b)));
+      }
+      if (isString(a)) {
+        return __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a, b);
+      }
+      if (isObject(a) && isString(a.id)) {
+        return __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a.id, b);
+      }
+      throw new Error("Invalid arguments for delete method");
+    });
+  }
+  async deleteOrThrow(a, b) {
+    return __privateGet$4(this, _trace).call(this, "deleteOrThrow", async () => {
+      const result = await this.delete(a, b);
+      if (Array.isArray(result)) {
+        const missingIds = compact(
+          a.filter((_item, index) => result[index] === null).map((item) => extractId(item))
+        );
+        if (missingIds.length > 0) {
+          throw new Error(`Could not find records with ids: ${missingIds.join(", ")}`);
+        }
+        return result;
+      } else if (result === null) {
+        const id = extractId(a) ?? "unknown";
+        throw new Error(`Record with id ${id} not found`);
+      }
+      return result;
+    });
   }
   async search(query, options = {}) {
-    const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
-    const { records } = await searchBranch({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-      body: { tables: [__privateGet$3(this, _table)], query, fuzziness: options.fuzziness },
-      ...fetchProps
+    return __privateGet$4(this, _trace).call(this, "search", async () => {
+      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+      const { records } = await searchTable({
+        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        body: {
+          query,
+          fuzziness: options.fuzziness,
+          prefix: options.prefix,
+          highlight: options.highlight,
+          filter: options.filter,
+          boosters: options.boosters
+        },
+        ...fetchProps
+      });
+      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 aggregate(aggs, filter) {
+    return __privateGet$4(this, _trace).call(this, "aggregate", async () => {
+      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+      const result = await aggregateTable({
+        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        body: { aggs, filter },
+        ...fetchProps
+      });
+      return result;
     });
-    return records.map((item) => initObject(this.db, __privateGet$3(this, _links), __privateGet$3(this, _table), item));
   }
   async query(query) {
-    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(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$3(this, _getFetchProps).call(this);
-    const { meta, records: objects } = await queryTable({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table) },
-      body,
-      ...fetchProps
+    return __privateGet$4(this, _trace).call(this, "query", async () => {
+      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 fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+      const { meta, records: objects } = await queryTable({
+        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        body: {
+          filter: cleanFilter(data.filter),
+          sort: data.sort !== void 0 ? buildSortFilter(data.sort) : void 0,
+          page: data.pagination,
+          columns: data.columns ?? ["*"]
+        },
+        ...fetchProps
+      });
+      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, data.columns ?? ["*"])
+      );
+      await __privateMethod$2(this, _setCacheQuery, setCacheQuery_fn).call(this, query, meta, records);
+      return new Page(query, meta, records);
+    });
+  }
+  async summarizeTable(query, summaries, summariesFilter) {
+    return __privateGet$4(this, _trace).call(this, "summarize", async () => {
+      const data = query.getQueryOptions();
+      const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+      const result = await summarizeTable({
+        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+        body: {
+          filter: cleanFilter(data.filter),
+          sort: data.sort !== void 0 ? buildSortFilter(data.sort) : void 0,
+          columns: data.columns,
+          summaries,
+          summariesFilter
+        },
+        ...fetchProps
+      });
+      return result;
     });
-    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();
+_db = new WeakMap();
 _cache = new WeakMap();
+_schemaTables$2 = new WeakMap();
+_trace = new WeakMap();
 _insertRecordWithoutId = new WeakSet();
-insertRecordWithoutId_fn = async function(object) {
-  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
+insertRecordWithoutId_fn = async function(object, columns = ["*"]) {
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecord({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
-      tableName: __privateGet$3(this, _table)
+      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, columns);
 };
 _insertRecordWithId = new WeakSet();
-insertRecordWithId_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
+insertRecordWithId_fn = async function(recordId, object, columns = ["*"]) {
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
-      tableName: __privateGet$3(this, _table),
+      tableName: __privateGet$4(this, _table),
       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, columns);
 };
 _bulkInsertTableRecords = new WeakSet();
-bulkInsertTableRecords_fn = async function(objects) {
-  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
+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$3(this, _table) },
+    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, columns));
 };
 _updateRecordWithID = new WeakSet();
-updateRecordWithID_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
+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$3(this, _table), recordId },
-    body: record,
-    ...fetchProps
-  });
-  const item = await this.read(response.id);
-  if (!item)
-    throw new Error("The server failed to save the record");
-  return item;
+  try {
+    const response = await updateRecordWithID({
+      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
+      queryParams: { columns },
+      body: record,
+      ...fetchProps
+    });
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
+  } catch (e) {
+    if (isObject(e) && e.status === 404) {
+      return null;
+    }
+    throw e;
+  }
 };
 _upsertRecordWithID = new WeakSet();
-upsertRecordWithID_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
+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$3(this, _table), recordId },
+    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, columns);
 };
 _deleteRecord = new WeakSet();
-deleteRecord_fn = async function(recordId) {
-  const fetchProps = await __privateGet$3(this, _getFetchProps).call(this);
-  await deleteRecord({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$3(this, _table), recordId },
-    ...fetchProps
-  });
-};
-_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);
+deleteRecord_fn = async function(recordId, columns = ["*"]) {
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+  try {
+    const response = await deleteRecord({
+      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
+      queryParams: { columns },
+      ...fetchProps
+    });
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    return initObject(__privateGet$4(this, _db), schemaTables, __privateGet$4(this, _table), response, columns);
+  } catch (e) {
+    if (isObject(e) && e.status === 404) {
+      return null;
+    }
+    throw e;
   }
 };
-_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 });
+  await __privateGet$4(this, _cache).set(`query_${__privateGet$4(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);
+  const key = `query_${__privateGet$4(this, _table)}:${query.key()}`;
+  const result = await __privateGet$4(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 { cache: ttl = __privateGet$4(this, _cache).defaultQueryTTL } = query.getQueryOptions();
+  if (ttl < 0)
+    return null;
   const hasExpired = result.date.getTime() + ttl < Date.now();
   return hasExpired ? null : result;
 };
+_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$4(this, _schemaTables$2, schema.tables);
+  return schema.tables;
+};
 const transformObjectLinks = (object) => {
   return Object.entries(object).reduce((acc, [key, value]) => {
     if (key === "xata")
@@ -1412,47 +2242,99 @@ const transformObjectLinks = (object) => {
     return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
   }, {});
 };
-const initObject = (db, links, table, object) => {
+const initObject = (db, schemaTables, table, object, selectedColumns) => {
   const result = {};
-  Object.assign(result, object);
-  const tableLinks = links[table] || [];
-  for (const link of tableLinks) {
-    const [field, linkTable] = link;
-    const value = result[field];
-    if (value && isObject(value)) {
-      result[field] = initObject(db, links, linkTable, value);
+  const { xata, ...rest } = object ?? {};
+  Object.assign(result, rest);
+  const { columns } = schemaTables.find(({ name }) => name === table) ?? {};
+  if (!columns)
+    console.error(`Table ${table} not found in schema`);
+  for (const column of columns ?? []) {
+    if (!isValidColumn(selectedColumns, column))
+      continue;
+    const value = result[column.name];
+    switch (column.type) {
+      case "datetime": {
+        const date = value !== void 0 ? new Date(value) : void 0;
+        if (date && isNaN(date.getTime())) {
+          console.error(`Failed to parse date ${value} for field ${column.name}`);
+        } else if (date) {
+          result[column.name] = date;
+        }
+        break;
+      }
+      case "link": {
+        const linkTable = column.link?.table;
+        if (!linkTable) {
+          console.error(`Failed to parse link for field ${column.name}`);
+        } else if (isObject(value)) {
+          const selectedLinkColumns = selectedColumns.reduce((acc, item) => {
+            if (item === column.name) {
+              return [...acc, "*"];
+            }
+            if (item.startsWith(`${column.name}.`)) {
+              const [, ...path] = item.split(".");
+              return [...acc, path.join(".")];
+            }
+            return acc;
+          }, []);
+          result[column.name] = initObject(db, schemaTables, linkTable, value, selectedLinkColumns);
+        } else {
+          result[column.name] = null;
+        }
+        break;
+      }
+      default:
+        result[column.name] = value ?? null;
+        if (column.notNull === true && value === null) {
+          console.error(`Parse error, column ${column.name} is non nullable and value resolves null`);
+        }
+        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"]);
   };
-  for (const prop of ["read", "update", "delete"]) {
+  result.getMetadata = function() {
+    return xata;
+  };
+  for (const prop of ["read", "update", "delete", "getMetadata"]) {
     Object.defineProperty(result, prop, { enumerable: false });
   }
   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);
+}
+function extractId(value) {
+  if (isString(value))
+    return value;
+  if (isObject(value) && isString(value.id))
+    return value.id;
+  return void 0;
+}
+function isValidColumn(columns, column) {
+  if (columns.includes("*"))
+    return true;
+  if (column.type === "link") {
+    const linkColumns = columns.filter((item) => item.startsWith(column.name));
+    return linkColumns.length > 0;
+  }
+  return columns.includes(column.name);
 }
 
 var __accessCheck$3 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$2 = (obj, member, getter) => {
+var __privateGet$3 = (obj, member, getter) => {
   __accessCheck$3(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
@@ -1461,7 +2343,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$1 = (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;
@@ -1470,46 +2352,52 @@ var _map;
 class SimpleCache {
   constructor(options = {}) {
     __privateAdd$3(this, _map, void 0);
-    __privateSet$1(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() {
-    return Object.fromEntries(__privateGet$2(this, _map));
+    return Object.fromEntries(__privateGet$3(this, _map));
   }
   async get(key) {
-    return __privateGet$2(this, _map).get(key) ?? null;
+    return __privateGet$3(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;
+    __privateGet$3(this, _map).set(key, value);
+    if (__privateGet$3(this, _map).size > this.capacity) {
+      const leastRecentlyUsed = __privateGet$3(this, _map).keys().next().value;
       await this.delete(leastRecentlyUsed);
     }
   }
   async delete(key) {
-    __privateGet$2(this, _map).delete(key);
+    __privateGet$3(this, _map).delete(key);
   }
   async clear() {
-    return __privateGet$2(this, _map).clear();
+    return __privateGet$3(this, _map).clear();
   }
 }
 _map = new WeakMap();
 
-const gt = (value) => ({ $gt: value });
-const ge = (value) => ({ $ge: value });
-const gte = (value) => ({ $ge: value });
-const lt = (value) => ({ $lt: value });
-const lte = (value) => ({ $le: value });
-const le = (value) => ({ $le: value });
+const greaterThan = (value) => ({ $gt: value });
+const gt = greaterThan;
+const greaterThanEquals = (value) => ({ $ge: value });
+const greaterEquals = greaterThanEquals;
+const gte = greaterThanEquals;
+const ge = greaterThanEquals;
+const lessThan = (value) => ({ $lt: value });
+const lt = lessThan;
+const lessThanEquals = (value) => ({ $le: value });
+const lessEquals = lessThanEquals;
+const lte = lessThanEquals;
+const le = lessThanEquals;
 const exists = (column) => ({ $exists: column });
 const notExists = (column) => ({ $notExists: column });
 const startsWith = (value) => ({ $startsWith: value });
 const endsWith = (value) => ({ $endsWith: value });
 const pattern = (value) => ({ $pattern: value });
 const is = (value) => ({ $is: value });
+const equals = is;
 const isNot = (value) => ({ $isNot: value });
 const contains = (value) => ({ $contains: value });
 const includes = (value) => ({ $includes: value });
@@ -1521,7 +2409,7 @@ var __accessCheck$2 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$1 = (obj, member, getter) => {
+var __privateGet$2 = (obj, member, getter) => {
   __accessCheck$2(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
@@ -1530,130 +2418,178 @@ 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(links, tableNames) {
+  constructor(schemaTables) {
     super();
-    this.links = links;
-    this.tableNames = tableNames;
     __privateAdd$2(this, _tables, {});
+    __privateAdd$2(this, _schemaTables$1, void 0);
+    __privateSet$2(this, _schemaTables$1, schemaTables);
   }
   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, pluginOptions, table, links });
+    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$1(this, _tables)[table];
       }
-    });
-    for (const table of this.tableNames ?? []) {
-      db[table] = new RestRepository({ db, pluginOptions, table, links });
+    );
+    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))
     throw TypeError("Cannot " + msg);
 };
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
 var __privateAdd$1 = (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$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
 var __privateMethod$1 = (obj, member, method) => {
   __accessCheck$1(obj, member, "access private method");
   return method;
 };
-var _search, search_fn;
+var _schemaTables, _search, search_fn, _getSchemaTables, getSchemaTables_fn;
 class SearchPlugin extends XataPlugin {
-  constructor(db, links) {
+  constructor(db, schemaTables) {
     super();
     this.db = db;
-    this.links = links;
     __privateAdd$1(this, _search);
+    __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 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, this.links, 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 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, this.links, table, record);
+          const item = initObject(this.db, schemaTables, table, record, ["*"]);
           return { ...acc, [table]: [...items, item] };
         }, {});
       }
     };
   }
 }
+_schemaTables = new WeakMap();
 _search = new WeakSet();
 search_fn = async function(query, options, getFetchProps) {
   const fetchProps = await getFetchProps();
-  const { tables, fuzziness } = options ?? {};
+  const { tables, fuzziness, highlight, prefix } = options ?? {};
   const { records } = await searchBranch({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-    body: { tables, query, fuzziness },
+    body: { tables, query, fuzziness, prefix, highlight },
     ...fetchProps
   });
   return records;
 };
+_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, _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"
-];
-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;
+  const { branch, envBranch } = getEnvironment();
+  if (branch) {
+    const details = await getDatabaseBranch(branch, options);
+    if (details)
+      return branch;
+    console.warn(`Branch ${branch} not found in Xata. Ignoring...`);
+  }
+  const gitBranch = envBranch || await getGitBranch();
+  return resolveXataBranch(gitBranch, options);
 }
 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);
+  const branch = await getCurrentBranchName(options);
+  return getDatabaseBranch(branch, options);
+}
+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"
+    );
+  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, , 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 },
+    trace: defaultTrace
+  });
+  return branch;
 }
 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}`;
@@ -1663,10 +2599,8 @@ async function getDatabaseBranch(branch, options) {
       apiUrl: databaseURL,
       fetchImpl: getFetchImplementation(options?.fetchImpl),
       workspacesApiUrl: `${protocol}//${host}`,
-      pathParams: {
-        dbBranchName,
-        workspace
-      }
+      pathParams: { dbBranchName, workspace },
+      trace: defaultTrace
     });
   } catch (err) {
     if (isObject(err) && err.status === 404)
@@ -1674,21 +2608,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;
   }
@@ -1717,24 +2640,27 @@ 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 = {}, links, 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
+        cache: safeOptions.cache,
+        trace: safeOptions.trace
       };
-      const db = new SchemaPlugin(links, tables).build(pluginOptions);
-      const search = new SearchPlugin(db, links ?? {}).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 ?? {})) {
-        if (!namespace)
+        if (namespace === void 0)
           continue;
         const result = namespace.build(pluginOptions);
         if (result instanceof Promise) {
@@ -1746,21 +2672,32 @@ 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 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");
+    const cache = options?.cache ?? new SimpleCache({ defaultQueryTTL: 0 });
+    const trace = options?.trace ?? defaultTrace;
+    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 (!apiKey) {
+      throw new Error("Option apiKey is required");
+    }
+    if (!databaseURL) {
+      throw new Error("Option databaseURL is required");
     }
-    return { fetch, databaseURL, apiKey, branch, cache };
+    return { fetch, databaseURL, apiKey, branch, cache, trace, clientID: generateUUID() };
   }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({
     fetch,
     apiKey,
     databaseURL,
-    branch
+    branch,
+    trace,
+    clientID
   }) {
     const branchValue = await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, branch);
     if (!branchValue)
@@ -1771,14 +2708,16 @@ const buildClient = (plugins) => {
       apiUrl: "",
       workspacesApiUrl: (path, params) => {
         const hasBranch = params.dbBranchName ?? params.branch;
-        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch ? `:${branchValue}` : "");
+        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch !== void 0 ? `:${branchValue}` : "");
         return databaseURL + newPath;
-      }
+      },
+      trace,
+      clientID
     };
   }, _evaluateBranch = new WeakSet(), evaluateBranch_fn = async function(param) {
     if (__privateGet(this, _branch))
       return __privateGet(this, _branch);
-    if (!param)
+    if (param === void 0)
       return void 0;
     const strategies = Array.isArray(param) ? [...param] : [param];
     const evaluateBranch = async (strategy) => {
@@ -1796,6 +2735,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);
@@ -1803,5 +2824,5 @@ class XataError extends Error {
   }
 }
 
-export { BaseClient, operationsByTag as Operations, PAGINATION_DEFAULT_OFFSET, PAGINATION_DEFAULT_SIZE, PAGINATION_MAX_OFFSET, PAGINATION_MAX_SIZE, Page, Query, Repository, RestRepository, SchemaPlugin, SearchPlugin, SimpleCache, XataApiClient, XataApiPlugin, XataError, XataPlugin, acceptWorkspaceMemberInvite, 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, getRecord, getTableColumns, getTableSchema, getUser, getUserAPIKeys, getWorkspace, getWorkspaceMembersList, getWorkspacesList, gt, gte, includes, includesAll, includesAny, includesNone, insertRecord, insertRecordWithID, inviteWorkspaceMember, is, isIdentifiable, isNot, isXataRecord, le, lt, lte, notExists, operationsByTag, pattern, queryTable, removeWorkspaceMember, resendWorkspaceMemberInvite, searchBranch, 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, aggregateTable, applyBranchSchemaEdit, buildClient, buildWorkerRunner, bulkInsertTableRecords, cPCreateDatabase, cPDeleteDatabase, cPGetCPDatabaseMetadata, cPGetDatabaseList, cPUpdateCPDatabaseMetadata, cancelWorkspaceMemberInvite, compareBranchSchemas, compareBranchWithUserSchema, compareMigrationRequest, contains, createBranch, createDatabase, createMigrationRequest, createTable, createUserAPIKey, createWorkspace, deleteBranch, deleteColumn, deleteDatabase, deleteRecord, deleteTable, deleteUser, deleteUserAPIKey, deleteWorkspace, deserialize, endsWith, equals, executeBranchMigrationPlan, exists, ge, getAPIKey, getBranchDetails, getBranchList, getBranchMetadata, getBranchMigrationHistory, getBranchMigrationPlan, getBranchSchemaHistory, getBranchStats, getColumn, getCurrentBranchDetails, getCurrentBranchName, getDatabaseList, getDatabaseMetadata, getDatabaseURL, getGitBranchesMapping, getHostUrl, getMigrationRequest, getMigrationRequestIsMerged, getRecord, getTableColumns, getTableSchema, getUser, getUserAPIKeys, getWorkspace, getWorkspaceMembersList, getWorkspacesList, greaterEquals, greaterThan, greaterThanEquals, gt, gte, includes, includesAll, includesAny, includesNone, insertRecord, insertRecordWithID, inviteWorkspaceMember, is, isCursorPaginationOptions, isHostProviderAlias, isHostProviderBuilder, isIdentifiable, isNot, isXataRecord, le, lessEquals, lessThan, lessThanEquals, listMigrationRequestsCommits, listRegions, lt, lte, mergeMigrationRequest, notExists, operationsByTag, parseProviderString, pattern, previewBranchSchemaEdit, queryMigrationRequests, queryTable, removeGitBranchesEntry, removeWorkspaceMember, resendWorkspaceMemberInvite, resolveBranch, searchBranch, searchTable, serialize, setTableSchema, startsWith, summarizeTable, updateBranchMetadata, updateBranchSchema, updateColumn, updateDatabaseMetadata, updateMigrationRequest, updateRecordWithID, updateTable, updateUser, updateWorkspace, updateWorkspaceMemberInvite, updateWorkspaceMemberRole, upsertRecordWithID };
 //# sourceMappingURL=index.mjs.map