@xata.io/client 0.8.4 → 0.10.0

package/dist/index.cjs

@@ -14,6 +14,13 @@ function isObject(value) {
 function isString(value) {
   return value !== void 0 && value !== null && typeof value === "string";
 }
+function toBase64(value) {
+  try {
+    return btoa(value);
+  } catch (err) {
+    return Buffer.from(value).toString("base64");
+  }
+}
 
 function getEnvVariable(name) {
   try {
@@ -31,7 +38,10 @@ function getEnvVariable(name) {
 }
 async function getGitBranch() {
   try {
-    return require("child_process").execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    if (typeof require === "function") {
+      const req = require;
+      return req("child_process").execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+    }
   } catch (err) {
   }
   try {
@@ -245,6 +255,14 @@ const deleteDatabase = (variables) => fetch$1({
   method: "delete",
   ...variables
 });
+const getGitBranchesMapping = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "get", ...variables });
+const addGitBranchesEntry = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "post", ...variables });
+const removeGitBranchesEntry = (variables) => fetch$1({ url: "/dbs/{dbName}/gitBranches", method: "delete", ...variables });
+const resolveBranch = (variables) => fetch$1({
+  url: "/dbs/{dbName}/resolveBranch",
+  method: "get",
+  ...variables
+});
 const getBranchDetails = (variables) => fetch$1({
   url: "/db/{dbBranchName}",
   method: "get",
@@ -373,7 +391,15 @@ const operationsByTag = {
     resendWorkspaceMemberInvite,
     acceptWorkspaceMemberInvite
   },
-  database: { getDatabaseList, createDatabase, deleteDatabase },
+  database: {
+    getDatabaseList,
+    createDatabase,
+    deleteDatabase,
+    getGitBranchesMapping,
+    addGitBranchesEntry,
+    removeGitBranchesEntry,
+    resolveBranch
+  },
   branch: {
     getBranchList,
     getBranchDetails,
@@ -436,35 +462,35 @@ function isValidBuilder(builder) {
   return isObject(builder) && isString(builder.main) && isString(builder.workspaces);
 }
 
-var __accessCheck$6 = (obj, member, msg) => {
+var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$5 = (obj, member, getter) => {
-  __accessCheck$6(obj, member, "read from private field");
+var __privateGet$7 = (obj, member, getter) => {
+  __accessCheck$7(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$6 = (obj, member, value) => {
+var __privateAdd$7 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$4 = (obj, member, value, setter) => {
-  __accessCheck$6(obj, member, "write to private field");
+var __privateSet$6 = (obj, member, value, setter) => {
+  __accessCheck$7(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _extraProps, _namespaces;
 class XataApiClient {
   constructor(options = {}) {
-    __privateAdd$6(this, _extraProps, void 0);
-    __privateAdd$6(this, _namespaces, {});
+    __privateAdd$7(this, _extraProps, void 0);
+    __privateAdd$7(this, _namespaces, {});
     const provider = options.host ?? "production";
     const apiKey = options?.apiKey ?? getAPIKey();
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
-    __privateSet$4(this, _extraProps, {
+    __privateSet$6(this, _extraProps, {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
       fetchImpl: getFetchImplementation(options.fetch),
@@ -472,34 +498,34 @@ class XataApiClient {
     });
   }
   get user() {
-    if (!__privateGet$5(this, _namespaces).user)
-      __privateGet$5(this, _namespaces).user = new UserApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).user;
+    if (!__privateGet$7(this, _namespaces).user)
+      __privateGet$7(this, _namespaces).user = new UserApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).user;
   }
   get workspaces() {
-    if (!__privateGet$5(this, _namespaces).workspaces)
-      __privateGet$5(this, _namespaces).workspaces = new WorkspaceApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).workspaces;
+    if (!__privateGet$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$5(this, _namespaces).databases)
-      __privateGet$5(this, _namespaces).databases = new DatabaseApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).databases;
+    if (!__privateGet$7(this, _namespaces).databases)
+      __privateGet$7(this, _namespaces).databases = new DatabaseApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).databases;
   }
   get branches() {
-    if (!__privateGet$5(this, _namespaces).branches)
-      __privateGet$5(this, _namespaces).branches = new BranchApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).branches;
+    if (!__privateGet$7(this, _namespaces).branches)
+      __privateGet$7(this, _namespaces).branches = new BranchApi(__privateGet$7(this, _extraProps));
+    return __privateGet$7(this, _namespaces).branches;
   }
   get tables() {
-    if (!__privateGet$5(this, _namespaces).tables)
-      __privateGet$5(this, _namespaces).tables = new TableApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(this, _namespaces).tables;
+    if (!__privateGet$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$5(this, _namespaces).records)
-      __privateGet$5(this, _namespaces).records = new RecordsApi(__privateGet$5(this, _extraProps));
-    return __privateGet$5(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;
   }
 }
 _extraProps = new WeakMap();
@@ -633,6 +659,33 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
+  getGitBranchesMapping(workspace, dbName) {
+    return operationsByTag.database.getGitBranchesMapping({
+      pathParams: { workspace, dbName },
+      ...this.extraProps
+    });
+  }
+  addGitBranchesEntry(workspace, dbName, body) {
+    return operationsByTag.database.addGitBranchesEntry({
+      pathParams: { workspace, dbName },
+      body,
+      ...this.extraProps
+    });
+  }
+  removeGitBranchesEntry(workspace, dbName, gitBranch) {
+    return operationsByTag.database.removeGitBranchesEntry({
+      pathParams: { workspace, dbName },
+      queryParams: { gitBranch },
+      ...this.extraProps
+    });
+  }
+  resolveBranch(workspace, dbName, gitBranch) {
+    return operationsByTag.database.resolveBranch({
+      pathParams: { workspace, dbName },
+      queryParams: { gitBranch },
+      ...this.extraProps
+    });
+  }
 }
 class BranchApi {
   constructor(extraProps) {
@@ -650,10 +703,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
     });
@@ -854,43 +907,43 @@ class XataApiPlugin {
 class XataPlugin {
 }
 
-var __accessCheck$5 = (obj, member, msg) => {
+var __accessCheck$6 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$5(obj, member, "read from private field");
+var __privateGet$6 = (obj, member, getter) => {
+  __accessCheck$6(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$5 = (obj, member, value) => {
+var __privateAdd$6 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$3 = (obj, member, value, setter) => {
-  __accessCheck$5(obj, member, "write to private field");
+var __privateSet$5 = (obj, member, value, setter) => {
+  __accessCheck$6(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _query;
 class Page {
   constructor(query, meta, records = []) {
-    __privateAdd$5(this, _query, void 0);
-    __privateSet$3(this, _query, query);
+    __privateAdd$6(this, _query, void 0);
+    __privateSet$5(this, _query, query);
     this.meta = meta;
     this.records = records;
   }
   async nextPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, after: this.meta.page.cursor } });
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, after: this.meta.page.cursor } });
   }
   async previousPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, before: this.meta.page.cursor } });
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, before: this.meta.page.cursor } });
   }
   async firstPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, first: this.meta.page.cursor } });
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, first: this.meta.page.cursor } });
   }
   async lastPage(size, offset) {
-    return __privateGet$4(this, _query).getPaginated({ page: { size, offset, last: this.meta.page.cursor } });
+    return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, last: this.meta.page.cursor } });
   }
   hasNextPage() {
     return this.meta.page.more;
@@ -902,46 +955,47 @@ const PAGINATION_DEFAULT_SIZE = 200;
 const PAGINATION_MAX_OFFSET = 800;
 const PAGINATION_DEFAULT_OFFSET = 0;
 
-var __accessCheck$4 = (obj, member, msg) => {
+var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$3 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
+var __privateGet$5 = (obj, member, getter) => {
+  __accessCheck$5(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$4 = (obj, member, value) => {
+var __privateAdd$5 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$2 = (obj, member, value, setter) => {
-  __accessCheck$4(obj, member, "write to private field");
+var __privateSet$4 = (obj, member, value, setter) => {
+  __accessCheck$5(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var _table$1, _repository, _data;
 const _Query = class {
   constructor(repository, table, data, parent) {
-    __privateAdd$4(this, _table$1, void 0);
-    __privateAdd$4(this, _repository, void 0);
-    __privateAdd$4(this, _data, { filter: {} });
+    __privateAdd$5(this, _table$1, void 0);
+    __privateAdd$5(this, _repository, void 0);
+    __privateAdd$5(this, _data, { filter: {} });
     this.meta = { page: { cursor: "start", more: true } };
     this.records = [];
-    __privateSet$2(this, _table$1, table);
+    __privateSet$4(this, _table$1, table);
     if (repository) {
-      __privateSet$2(this, _repository, repository);
+      __privateSet$4(this, _repository, repository);
     } else {
-      __privateSet$2(this, _repository, this);
+      __privateSet$4(this, _repository, this);
     }
-    __privateGet$3(this, _data).filter = data.filter ?? parent?.filter ?? {};
-    __privateGet$3(this, _data).filter.$any = data.filter?.$any ?? parent?.filter?.$any;
-    __privateGet$3(this, _data).filter.$all = data.filter?.$all ?? parent?.filter?.$all;
-    __privateGet$3(this, _data).filter.$not = data.filter?.$not ?? parent?.filter?.$not;
-    __privateGet$3(this, _data).filter.$none = data.filter?.$none ?? parent?.filter?.$none;
-    __privateGet$3(this, _data).sort = data.sort ?? parent?.sort;
-    __privateGet$3(this, _data).columns = data.columns ?? parent?.columns ?? ["*"];
-    __privateGet$3(this, _data).page = data.page ?? parent?.page;
+    __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);
@@ -952,58 +1006,64 @@ const _Query = class {
     Object.defineProperty(this, "repository", { enumerable: false });
   }
   getQueryOptions() {
-    return __privateGet$3(this, _data);
+    return __privateGet$5(this, _data);
+  }
+  key() {
+    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$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $any } }, __privateGet$3(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$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(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$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $not } }, __privateGet$3(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$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $none } }, __privateGet$3(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$3(this, _data).filter?.$all].flat().concat(constraints));
-      return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(this, _data));
+      const $all = compact([__privateGet$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$3(this, _data).filter?.$all].flat().concat([{ [a]: b }]));
-      return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { filter: { $all } }, __privateGet$3(this, _data));
+      const $all = compact([__privateGet$5(this, _data).filter?.$all].flat().concat([{ [a]: b }]));
+      return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { filter: { $all } }, __privateGet$5(this, _data));
     }
   }
   sort(column, direction) {
-    const originalSort = [__privateGet$3(this, _data).sort ?? []].flat();
+    const originalSort = [__privateGet$5(this, _data).sort ?? []].flat();
     const sort = [...originalSort, { column, direction }];
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { sort }, __privateGet$3(this, _data));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { sort }, __privateGet$5(this, _data));
   }
   select(columns) {
-    return new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), { columns }, __privateGet$3(this, _data));
+    return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { columns }, __privateGet$5(this, _data));
   }
   getPaginated(options = {}) {
-    const query = new _Query(__privateGet$3(this, _repository), __privateGet$3(this, _table$1), options, __privateGet$3(this, _data));
-    return __privateGet$3(this, _repository).query(query);
+    const query = new _Query(__privateGet$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 = {}) {
+  async *getIterator(options = {}) {
+    const { batchSize = 1 } = options;
     let offset = 0;
     let end = false;
     while (!end) {
-      const { records, meta } = await this.getPaginated({ ...options, page: { size: chunk, offset } });
+      const { records, meta } = await this.getPaginated({ ...options, pagination: { size: batchSize, offset } });
       yield records;
-      offset += chunk;
+      offset += batchSize;
       end = !meta.page.more;
     }
   }
@@ -1011,17 +1071,21 @@ const _Query = class {
     const { records } = await this.getPaginated(options);
     return records;
   }
-  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 getOne(options = {}) {
-    const records = await this.getMany({ ...options, page: { size: 1 } });
+  async getFirst(options = {}) {
+    const records = await this.getMany({ ...options, pagination: { size: 1 } });
     return records[0] || null;
   }
+  cache(ttl) {
+    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);
   }
@@ -1029,10 +1093,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;
@@ -1073,75 +1137,94 @@ function buildSortFilter(filter) {
   }
 }
 
-var __accessCheck$3 = (obj, member, msg) => {
+var __accessCheck$4 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$2 = (obj, member, getter) => {
-  __accessCheck$3(obj, member, "read from private field");
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$3 = (obj, member, value) => {
+var __privateAdd$4 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$1 = (obj, member, value, setter) => {
-  __accessCheck$3(obj, member, "write to private field");
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var __privateMethod$2 = (obj, member, method) => {
-  __accessCheck$3(obj, member, "access private method");
+  __accessCheck$4(obj, member, "access private method");
   return method;
 };
-var _table, _links, _getFetchProps, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn;
+var _table, _getFetchProps, _cache, _schema$1, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _invalidateCache, invalidateCache_fn, _setCacheRecord, setCacheRecord_fn, _getCacheRecord, getCacheRecord_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchema$1, getSchema_fn$1;
 class Repository extends Query {
 }
 class RestRepository extends Query {
   constructor(options) {
     super(null, options.table, {});
-    __privateAdd$3(this, _insertRecordWithoutId);
-    __privateAdd$3(this, _insertRecordWithId);
-    __privateAdd$3(this, _bulkInsertTableRecords);
-    __privateAdd$3(this, _updateRecordWithID);
-    __privateAdd$3(this, _upsertRecordWithID);
-    __privateAdd$3(this, _deleteRecord);
-    __privateAdd$3(this, _table, void 0);
-    __privateAdd$3(this, _links, void 0);
-    __privateAdd$3(this, _getFetchProps, void 0);
-    __privateSet$1(this, _table, options.table);
-    __privateSet$1(this, _links, options.links ?? {});
-    __privateSet$1(this, _getFetchProps, options.getFetchProps);
+    __privateAdd$4(this, _insertRecordWithoutId);
+    __privateAdd$4(this, _insertRecordWithId);
+    __privateAdd$4(this, _bulkInsertTableRecords);
+    __privateAdd$4(this, _updateRecordWithID);
+    __privateAdd$4(this, _upsertRecordWithID);
+    __privateAdd$4(this, _deleteRecord);
+    __privateAdd$4(this, _invalidateCache);
+    __privateAdd$4(this, _setCacheRecord);
+    __privateAdd$4(this, _getCacheRecord);
+    __privateAdd$4(this, _setCacheQuery);
+    __privateAdd$4(this, _getCacheQuery);
+    __privateAdd$4(this, _getSchema$1);
+    __privateAdd$4(this, _table, void 0);
+    __privateAdd$4(this, _getFetchProps, void 0);
+    __privateAdd$4(this, _cache, void 0);
+    __privateAdd$4(this, _schema$1, void 0);
+    __privateSet$3(this, _table, options.table);
+    __privateSet$3(this, _getFetchProps, options.pluginOptions.getFetchProps);
     this.db = options.db;
+    __privateSet$3(this, _cache, options.pluginOptions.cache);
   }
   async create(a, b) {
     if (Array.isArray(a)) {
-      return __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a);
+      const records = await __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a);
+      await Promise.all(records.map((record) => __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record)));
+      return records;
     }
     if (isString(a) && isObject(b)) {
       if (a === "")
         throw new Error("The id can't be empty");
-      return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b);
+      const record = await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a, b);
+      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
+      return record;
     }
     if (isObject(a) && isString(a.id)) {
       if (a.id === "")
         throw new Error("The id can't be empty");
-      return __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 });
+      const record = await __privateMethod$2(this, _insertRecordWithId, insertRecordWithId_fn).call(this, a.id, { ...a, id: void 0 });
+      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
+      return record;
     }
     if (isObject(a)) {
-      return __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a);
+      const record = await __privateMethod$2(this, _insertRecordWithoutId, insertRecordWithoutId_fn).call(this, a);
+      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
+      return record;
     }
     throw new Error("Invalid arguments for create method");
   }
   async read(recordId) {
-    const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+    const cacheRecord = await __privateMethod$2(this, _getCacheRecord, getCacheRecord_fn).call(this, recordId);
+    if (cacheRecord)
+      return cacheRecord;
+    const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
     try {
       const response = await getRecord({
-        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
         ...fetchProps
       });
-      return initObject(this.db, __privateGet$2(this, _links), __privateGet$2(this, _table), response);
+      const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
+      return initObject(this.db, schema, __privateGet$4(this, _table), response);
     } catch (e) {
       if (isObject(e) && e.status === 404) {
         return null;
@@ -1157,10 +1240,16 @@ class RestRepository extends Query {
       return Promise.all(a.map((object) => this.update(object)));
     }
     if (isString(a) && isObject(b)) {
-      return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b);
+      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a);
+      const record = await __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a, b);
+      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
+      return record;
     }
     if (isObject(a) && isString(a.id)) {
-      return __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
+      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a.id);
+      const record = await __privateMethod$2(this, _updateRecordWithID, updateRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
+      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
+      return record;
     }
     throw new Error("Invalid arguments for update method");
   }
@@ -1172,70 +1261,85 @@ class RestRepository extends Query {
       return Promise.all(a.map((object) => this.createOrUpdate(object)));
     }
     if (isString(a) && isObject(b)) {
-      return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b);
+      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a);
+      const record = await __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a, b);
+      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
+      return record;
     }
     if (isObject(a) && isString(a.id)) {
-      return __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
+      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a.id);
+      const record = await __privateMethod$2(this, _upsertRecordWithID, upsertRecordWithID_fn).call(this, a.id, { ...a, id: void 0 });
+      await __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record);
+      return record;
     }
     throw new Error("Invalid arguments for createOrUpdate method");
   }
-  async delete(recordId) {
-    if (Array.isArray(recordId)) {
-      if (recordId.length > 100) {
+  async delete(a) {
+    if (Array.isArray(a)) {
+      if (a.length > 100) {
         console.warn("Bulk delete operation is not optimized in the Xata API yet, this request might be slow");
       }
-      await Promise.all(recordId.map((id) => this.delete(id)));
+      await Promise.all(a.map((id) => this.delete(id)));
       return;
     }
-    if (isString(recordId)) {
-      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, recordId);
+    if (isString(a)) {
+      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a);
+      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a);
       return;
     }
-    if (isObject(recordId) && isString(recordId.id)) {
-      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, recordId.id);
+    if (isObject(a) && isString(a.id)) {
+      await __privateMethod$2(this, _deleteRecord, deleteRecord_fn).call(this, a.id);
+      await __privateMethod$2(this, _invalidateCache, invalidateCache_fn).call(this, a.id);
       return;
     }
     throw new Error("Invalid arguments for delete method");
   }
   async search(query, options = {}) {
-    const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+    const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
     const { records } = await searchBranch({
       pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-      body: { tables: [__privateGet$2(this, _table)], query, fuzziness: options.fuzziness },
+      body: { tables: [__privateGet$4(this, _table)], query, fuzziness: options.fuzziness },
       ...fetchProps
     });
-    return records.map((item) => initObject(this.db, __privateGet$2(this, _links), __privateGet$2(this, _table), item));
+    const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
+    return records.map((item) => initObject(this.db, schema, __privateGet$4(this, _table), item));
   }
   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,
+      page: data.pagination,
       columns: data.columns
     };
-    const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+    const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
     const { meta, records: objects } = await queryTable({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table) },
+      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
       body,
       ...fetchProps
     });
-    const records = objects.map((record) => initObject(this.db, __privateGet$2(this, _links), __privateGet$2(this, _table), record));
+    const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
+    const records = objects.map((record) => initObject(this.db, schema, __privateGet$4(this, _table), record));
+    await __privateMethod$2(this, _setCacheQuery, setCacheQuery_fn).call(this, query, meta, records);
     return new Page(query, meta, records);
   }
 }
 _table = new WeakMap();
-_links = new WeakMap();
 _getFetchProps = new WeakMap();
+_cache = new WeakMap();
+_schema$1 = new WeakMap();
 _insertRecordWithoutId = new WeakSet();
 insertRecordWithoutId_fn = async function(object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecord({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
-      tableName: __privateGet$2(this, _table)
+      tableName: __privateGet$4(this, _table)
     },
     body: record,
     ...fetchProps
@@ -1248,13 +1352,13 @@ insertRecordWithoutId_fn = async function(object) {
 };
 _insertRecordWithId = new WeakSet();
 insertRecordWithId_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await insertRecordWithID({
     pathParams: {
       workspace: "{workspaceId}",
       dbBranchName: "{dbBranch}",
-      tableName: __privateGet$2(this, _table),
+      tableName: __privateGet$4(this, _table),
       recordId
     },
     body: record,
@@ -1269,10 +1373,10 @@ insertRecordWithId_fn = async function(recordId, object) {
 };
 _bulkInsertTableRecords = new WeakSet();
 bulkInsertTableRecords_fn = async function(objects) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const records = objects.map((object) => transformObjectLinks(object));
   const response = await bulkInsertTableRecords({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table) },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
     body: { records },
     ...fetchProps
   });
@@ -1284,10 +1388,10 @@ bulkInsertTableRecords_fn = async function(objects) {
 };
 _updateRecordWithID = new WeakSet();
 updateRecordWithID_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const record = transformObjectLinks(object);
   const response = await updateRecordWithID({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
     body: record,
     ...fetchProps
   });
@@ -1298,9 +1402,9 @@ updateRecordWithID_fn = async function(recordId, object) {
 };
 _upsertRecordWithID = new WeakSet();
 upsertRecordWithID_fn = async function(recordId, object) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const response = await upsertRecordWithID({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
     body: object,
     ...fetchProps
   });
@@ -1311,11 +1415,62 @@ upsertRecordWithID_fn = async function(recordId, object) {
 };
 _deleteRecord = new WeakSet();
 deleteRecord_fn = async function(recordId) {
-  const fetchProps = await __privateGet$2(this, _getFetchProps).call(this);
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   await deleteRecord({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$2(this, _table), recordId },
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
+    ...fetchProps
+  });
+};
+_invalidateCache = new WeakSet();
+invalidateCache_fn = async function(recordId) {
+  await __privateGet$4(this, _cache).delete(`rec_${__privateGet$4(this, _table)}:${recordId}`);
+  const cacheItems = await __privateGet$4(this, _cache).getAll();
+  const queries = Object.entries(cacheItems).filter(([key]) => key.startsWith("query_"));
+  for (const [key, value] of queries) {
+    const ids = getIds(value);
+    if (ids.includes(recordId))
+      await __privateGet$4(this, _cache).delete(key);
+  }
+};
+_setCacheRecord = new WeakSet();
+setCacheRecord_fn = async function(record) {
+  if (!__privateGet$4(this, _cache).cacheRecords)
+    return;
+  await __privateGet$4(this, _cache).set(`rec_${__privateGet$4(this, _table)}:${record.id}`, record);
+};
+_getCacheRecord = new WeakSet();
+getCacheRecord_fn = async function(recordId) {
+  if (!__privateGet$4(this, _cache).cacheRecords)
+    return null;
+  return __privateGet$4(this, _cache).get(`rec_${__privateGet$4(this, _table)}:${recordId}`);
+};
+_setCacheQuery = new WeakSet();
+setCacheQuery_fn = async function(query, meta, records) {
+  await __privateGet$4(this, _cache).set(`query_${__privateGet$4(this, _table)}:${query.key()}`, { date: new Date(), meta, records });
+};
+_getCacheQuery = new WeakSet();
+getCacheQuery_fn = async function(query) {
+  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$4(this, _cache).defaultQueryTTL } = query.getQueryOptions();
+  if (ttl < 0)
+    return null;
+  const hasExpired = result.date.getTime() + ttl < Date.now();
+  return hasExpired ? null : result;
+};
+_getSchema$1 = new WeakSet();
+getSchema_fn$1 = async function() {
+  if (__privateGet$4(this, _schema$1))
+    return __privateGet$4(this, _schema$1);
+  const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
+  const { schema } = await getBranchDetails({
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
     ...fetchProps
   });
+  __privateSet$3(this, _schema$1, schema);
+  return schema;
 };
 const transformObjectLinks = (object) => {
   return Object.entries(object).reduce((acc, [key, value]) => {
@@ -1324,15 +1479,33 @@ const transformObjectLinks = (object) => {
     return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
   }, {});
 };
-const initObject = (db, links, table, object) => {
+const initObject = (db, schema, table, object) => {
   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 { columns } = schema.tables.find(({ name }) => name === table) ?? {};
+  if (!columns)
+    console.error(`Table ${table} not found in schema`);
+  for (const column of columns ?? []) {
+    const value = result[column.name];
+    switch (column.type) {
+      case "datetime": {
+        const date = new Date(value);
+        if (isNaN(date.getTime())) {
+          console.error(`Failed to parse date ${value} for field ${column.name}`);
+        } else {
+          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 (value && isObject(value)) {
+          result[column.name] = initObject(db, schema, linkTable, value);
+        }
+        break;
+      }
     }
   }
   result.read = function() {
@@ -1350,6 +1523,65 @@ const initObject = (db, links, table, object) => {
   Object.freeze(result);
   return result;
 };
+function getIds(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => getIds(item)).flat();
+  }
+  if (!isObject(value))
+    return [];
+  const nestedIds = Object.values(value).map((item) => getIds(item)).flat();
+  return isString(value.id) ? [value.id, ...nestedIds] : nestedIds;
+}
+
+var __accessCheck$3 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$3 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _map;
+class SimpleCache {
+  constructor(options = {}) {
+    __privateAdd$3(this, _map, void 0);
+    __privateSet$2(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$3(this, _map));
+  }
+  async get(key) {
+    return __privateGet$3(this, _map).get(key) ?? null;
+  }
+  async set(key, value) {
+    await this.delete(key);
+    __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$3(this, _map).delete(key);
+  }
+  async clear() {
+    return __privateGet$3(this, _map).clear();
+  }
+}
+_map = new WeakMap();
 
 const gt = (value) => ({ $gt: value });
 const ge = (value) => ({ $ge: value });
@@ -1374,7 +1606,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);
 };
@@ -1385,23 +1617,25 @@ var __privateAdd$2 = (obj, member, value) => {
 };
 var _tables;
 class SchemaPlugin extends XataPlugin {
-  constructor(links) {
+  constructor(tableNames) {
     super();
-    this.links = links;
+    this.tableNames = tableNames;
     __privateAdd$2(this, _tables, {});
   }
-  build(options) {
-    const { getFetchProps } = options;
-    const links = this.links;
+  build(pluginOptions) {
     const db = new Proxy({}, {
       get: (_target, table) => {
         if (!isString(table))
           throw new Error("Invalid table name");
-        if (!__privateGet$1(this, _tables)[table])
-          __privateGet$1(this, _tables)[table] = new RestRepository({ db, getFetchProps, table, links });
-        return __privateGet$1(this, _tables)[table];
+        if (!__privateGet$2(this, _tables)[table]) {
+          __privateGet$2(this, _tables)[table] = new RestRepository({ db, pluginOptions, table });
+        }
+        return __privateGet$2(this, _tables)[table];
       }
     });
+    for (const table of this.tableNames ?? []) {
+      db[table] = new RestRepository({ db, pluginOptions, table });
+    }
     return db;
   }
 }
@@ -1411,44 +1645,57 @@ 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 _schema, _search, search_fn, _getSchema, getSchema_fn;
 class SearchPlugin extends XataPlugin {
-  constructor(db, links) {
+  constructor(db) {
     super();
     this.db = db;
-    this.links = links;
     __privateAdd$1(this, _search);
+    __privateAdd$1(this, _getSchema);
+    __privateAdd$1(this, _schema, void 0);
   }
   build({ getFetchProps }) {
     return {
       all: async (query, options = {}) => {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
+        const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
         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, schema, table, record) };
         });
       },
       byTable: async (query, options = {}) => {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
+        const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
         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, schema, table, record);
           return { ...acc, [table]: [...items, item] };
         }, {});
       }
     };
   }
 }
+_schema = new WeakMap();
 _search = new WeakSet();
 search_fn = async function(query, options, getFetchProps) {
   const fetchProps = await getFetchProps();
@@ -1460,6 +1707,18 @@ search_fn = async function(query, options, getFetchProps) {
   });
   return records;
 };
+_getSchema = new WeakSet();
+getSchema_fn = async function(getFetchProps) {
+  if (__privateGet$1(this, _schema))
+    return __privateGet$1(this, _schema);
+  const fetchProps = await getFetchProps();
+  const { schema } = await getBranchDetails({
+    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
+    ...fetchProps
+  });
+  __privateSet$1(this, _schema, schema);
+  return schema;
+};
 
 const isBranchStrategyBuilder = (strategy) => {
   return typeof strategy === "function";
@@ -1568,22 +1827,24 @@ var __privateMethod = (obj, member, method) => {
 const buildClient = (plugins) => {
   var _branch, _parseOptions, parseOptions_fn, _getFetchProps, getFetchProps_fn, _evaluateBranch, evaluateBranch_fn, _a;
   return _a = class {
-    constructor(options = {}, links) {
+    constructor(options = {}, tables) {
       __privateAdd(this, _parseOptions);
       __privateAdd(this, _getFetchProps);
       __privateAdd(this, _evaluateBranch);
       __privateAdd(this, _branch, void 0);
       const safeOptions = __privateMethod(this, _parseOptions, parseOptions_fn).call(this, options);
-      const db = new SchemaPlugin(links).build({ getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions) });
-      const search = new SearchPlugin(db, links ?? {}).build({
-        getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions)
-      });
+      const pluginOptions = {
+        getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions),
+        cache: safeOptions.cache
+      };
+      const db = new SchemaPlugin(tables).build(pluginOptions);
+      const search = new SearchPlugin(db).build(pluginOptions);
       this.db = db;
       this.search = search;
       for (const [key, namespace] of Object.entries(plugins ?? {})) {
         if (!namespace)
           continue;
-        const result = namespace.build({ getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions) });
+        const result = namespace.build(pluginOptions);
         if (result instanceof Promise) {
           void result.then((namespace2) => {
             this[key] = namespace2;
@@ -1597,11 +1858,12 @@ const buildClient = (plugins) => {
     const fetch = getFetchImplementation(options?.fetch);
     const databaseURL = options?.databaseURL || getDatabaseURL();
     const apiKey = options?.apiKey || getAPIKey();
+    const cache = options?.cache ?? new SimpleCache({ cacheRecords: false, defaultQueryTTL: 0 });
     const branch = async () => options?.branch ? await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, options.branch) : await getCurrentBranchName({ apiKey, databaseURL, fetchImpl: options?.fetch });
     if (!databaseURL || !apiKey) {
       throw new Error("Options databaseURL and apiKey are required");
     }
-    return { fetch, databaseURL, apiKey, branch };
+    return { fetch, databaseURL, apiKey, branch, cache };
   }, _getFetchProps = new WeakSet(), getFetchProps_fn = async function({
     fetch,
     apiKey,
@@ -1661,11 +1923,13 @@ exports.Repository = Repository;
 exports.RestRepository = RestRepository;
 exports.SchemaPlugin = SchemaPlugin;
 exports.SearchPlugin = SearchPlugin;
+exports.SimpleCache = SimpleCache;
 exports.XataApiClient = XataApiClient;
 exports.XataApiPlugin = XataApiPlugin;
 exports.XataError = XataError;
 exports.XataPlugin = XataPlugin;
 exports.acceptWorkspaceMemberInvite = acceptWorkspaceMemberInvite;
+exports.addGitBranchesEntry = addGitBranchesEntry;
 exports.addTableColumn = addTableColumn;
 exports.buildClient = buildClient;
 exports.bulkInsertTableRecords = bulkInsertTableRecords;
@@ -1700,6 +1964,7 @@ exports.getCurrentBranchDetails = getCurrentBranchDetails;
 exports.getCurrentBranchName = getCurrentBranchName;
 exports.getDatabaseList = getDatabaseList;
 exports.getDatabaseURL = getDatabaseURL;
+exports.getGitBranchesMapping = getGitBranchesMapping;
 exports.getRecord = getRecord;
 exports.getTableColumns = getTableColumns;
 exports.getTableSchema = getTableSchema;
@@ -1728,8 +1993,10 @@ exports.notExists = notExists;
 exports.operationsByTag = operationsByTag;
 exports.pattern = pattern;
 exports.queryTable = queryTable;
+exports.removeGitBranchesEntry = removeGitBranchesEntry;
 exports.removeWorkspaceMember = removeWorkspaceMember;
 exports.resendWorkspaceMemberInvite = resendWorkspaceMemberInvite;
+exports.resolveBranch = resolveBranch;
 exports.searchBranch = searchBranch;
 exports.setTableSchema = setTableSchema;
 exports.startsWith = startsWith;