@xata.io/client 0.0.0-alpha.vf350c0a → 0.0.0-alpha.vf45a2df

package/dist/index.cjs

@@ -11,14 +11,18 @@ 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 toBase64(value) {
   try {
     return btoa(value);
   } catch (err) {
-    return Buffer.from(value).toString("base64");
+    const buf = Buffer;
+    return buf.from(value).toString("base64");
   }
 }
 
@@ -74,16 +78,28 @@ function getFetchImplementation(userFetch) {
   return fetchImpl;
 }
 
-class FetcherError extends Error {
-  constructor(status, data) {
+const VERSION = "0.0.0-alpha.vf45a2df";
+
+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);
@@ -106,7 +122,12 @@ function getMessage(data) {
 }
 
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
-  const query = new URLSearchParams(queryParams).toString();
+  const cleanQueryParams = Object.entries(queryParams).reduce((acc, [key, value]) => {
+    if (value === void 0 || value === null)
+      return acc;
+    return { ...acc, [key]: value };
+  }, {});
+  const query = new URLSearchParams(cleanQueryParams).toString();
   const queryString = query.length > 0 ? `?${query}` : "";
   return url.replace(/\{\w*\}/g, (key) => pathParams[key.slice(1, -1)]) + queryString;
 };
@@ -146,6 +167,7 @@ async function fetch$1({
     body: body ? JSON.stringify(body) : void 0,
     headers: {
       "Content-Type": "application/json",
+      "User-Agent": `Xata client-ts/${VERSION}`,
       ...headers,
       ...hostHeader(fullUrl),
       Authorization: `Bearer ${apiKey}`
@@ -154,14 +176,15 @@ async function fetch$1({
   if (response.status === 204) {
     return {};
   }
+  const requestId = response.headers?.get("x-request-id") ?? void 0;
   try {
     const jsonResponse = await response.json();
     if (response.ok) {
       return jsonResponse;
     }
-    throw new FetcherError(response.status, jsonResponse);
+    throw new FetcherError(response.status, jsonResponse, requestId);
   } catch (error) {
-    throw new FetcherError(response.status, error);
+    throw new FetcherError(response.status, error, requestId);
   }
 }
 
@@ -370,6 +393,11 @@ const queryTable = (variables) => fetch$1({
   method: "post",
   ...variables
 });
+const searchTable = (variables) => fetch$1({
+  url: "/db/{dbBranchName}/tables/{tableName}/search",
+  method: "post",
+  ...variables
+});
 const searchBranch = (variables) => fetch$1({
   url: "/db/{dbBranchName}/search",
   method: "post",
@@ -433,6 +461,7 @@ const operationsByTag = {
     getRecord,
     bulkInsertTableRecords,
     queryTable,
+    searchTable,
     searchBranch
   }
 };
@@ -679,10 +708,10 @@ class DatabaseApi {
       ...this.extraProps
     });
   }
-  resolveBranch(workspace, dbName, gitBranch) {
+  resolveBranch(workspace, dbName, gitBranch, fallbackBranch) {
     return operationsByTag.database.resolveBranch({
       pathParams: { workspace, dbName },
-      queryParams: { gitBranch },
+      queryParams: { gitBranch, fallbackBranch },
       ...this.extraProps
     });
   }
@@ -703,10 +732,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
     });
@@ -888,6 +917,13 @@ class RecordsApi {
       ...this.extraProps
     });
   }
+  searchTable(workspace, database, branch, tableName, query) {
+    return operationsByTag.records.searchTable({
+      pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName },
+      body: query,
+      ...this.extraProps
+    });
+  }
   searchBranch(workspace, database, branch, query) {
     return operationsByTag.records.searchBranch({
       pathParams: { workspace, dbBranchName: `${database}:${branch}` },
@@ -925,25 +961,25 @@ var __privateSet$5 = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var _query;
+var _query, _page;
 class Page {
   constructor(query, meta, records = []) {
     __privateAdd$6(this, _query, void 0);
     __privateSet$5(this, _query, query);
     this.meta = meta;
-    this.records = records;
+    this.records = new RecordArray(this, records);
   }
   async nextPage(size, offset) {
-    return __privateGet$6(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$6(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$6(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$6(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;
@@ -951,9 +987,50 @@ 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(page, overrideRecords) {
+    super(..._RecordArray.parseConstructorParams(page, overrideRecords));
+    __privateAdd$6(this, _page, void 0);
+    __privateSet$5(this, _page, page);
+  }
+  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);
+  }
+  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))
@@ -975,18 +1052,19 @@ var __privateSet$4 = (obj, member, value, setter) => {
 };
 var _table$1, _repository, _data;
 const _Query = class {
-  constructor(repository, table, data, parent) {
+  constructor(repository, table, data, rawParent) {
     __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 = [];
+    this.records = new RecordArray(this, []);
     __privateSet$4(this, _table$1, table);
     if (repository) {
       __privateSet$4(this, _repository, repository);
     } else {
       __privateSet$4(this, _repository, this);
     }
+    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;
@@ -994,7 +1072,7 @@ const _Query = class {
     __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).page = data.page ?? parent?.page;
+    __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);
@@ -1009,8 +1087,8 @@ const _Query = class {
     return __privateGet$5(this, _data);
   }
   key() {
-    const { columns = [], filter = {}, sort = [], page = {} } = __privateGet$5(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) {
@@ -1052,34 +1130,39 @@ const _Query = class {
     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 page = await this.getPaginated(options);
+    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.");
+    }
+    return page.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 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;
   }
   cache(ttl) {
     return new _Query(__privateGet$5(this, _repository), __privateGet$5(this, _table$1), { cache: ttl }, __privateGet$5(this, _data));
@@ -1091,10 +1174,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;
@@ -1104,12 +1187,20 @@ let Query = _Query;
 _table$1 = new WeakMap();
 _repository = new WeakMap();
 _data = new WeakMap();
+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) {
@@ -1157,7 +1248,7 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$4(obj, member, "access private method");
   return method;
 };
-var _table, _getFetchProps, _cache, _schemaColumns, _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, _getSchemaColumns, getSchemaColumns_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 {
@@ -1174,11 +1265,11 @@ class RestRepository extends Query {
     __privateAdd$4(this, _getCacheRecord);
     __privateAdd$4(this, _setCacheQuery);
     __privateAdd$4(this, _getCacheQuery);
-    __privateAdd$4(this, _getSchemaColumns);
+    __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, _schemaColumns, 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;
@@ -1186,6 +1277,8 @@ class RestRepository extends Query {
   }
   async create(a, b) {
     if (Array.isArray(a)) {
+      if (a.length === 0)
+        return [];
       const records = await __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, a);
       await Promise.all(records.map((record) => __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record)));
       return records;
@@ -1211,27 +1304,38 @@ class RestRepository extends Query {
     }
     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$4(this, _getFetchProps).call(this);
-    try {
-      const response = await getRecord({
-        pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table), recordId },
-        ...fetchProps
-      });
-      const columns = await __privateMethod$2(this, _getSchemaColumns, getSchemaColumns_fn).call(this);
-      return initObject(this.db, columns, __privateGet$4(this, _table), response);
-    } catch (e) {
-      if (isObject(e) && e.status === 404) {
-        return null;
+  async read(a) {
+    if (Array.isArray(a)) {
+      if (a.length === 0)
+        return [];
+      const ids = a.map((item) => isString(item) ? item : item.id).filter((id2) => isString(id2));
+      return this.getAll({ filter: { id: { $any: ids } } });
+    }
+    const id = isString(a) ? a : a.id;
+    if (isString(id)) {
+      const cacheRecord = await __privateMethod$2(this, _getCacheRecord, getCacheRecord_fn).call(this, id);
+      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$4(this, _table), recordId: id },
+          ...fetchProps
+        });
+        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;
+        }
+        throw e;
       }
-      throw e;
     }
   }
   async update(a, b) {
     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");
       }
@@ -1253,6 +1357,8 @@ class RestRepository extends Query {
   }
   async createOrUpdate(a, b) {
     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");
       }
@@ -1274,6 +1380,8 @@ class RestRepository extends Query {
   }
   async delete(a) {
     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");
       }
@@ -1294,13 +1402,18 @@ class RestRepository extends Query {
   }
   async search(query, options = {}) {
     const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
-    const { records } = await searchBranch({
-      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-      body: { tables: [__privateGet$4(this, _table)], query, fuzziness: options.fuzziness },
+    const { records } = await searchTable({
+      pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
+      body: {
+        query,
+        fuzziness: options.fuzziness,
+        highlight: options.highlight,
+        filter: options.filter
+      },
       ...fetchProps
     });
-    const columns = await __privateMethod$2(this, _getSchemaColumns, getSchemaColumns_fn).call(this);
-    return records.map((item) => initObject(this.db, columns, __privateGet$4(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);
@@ -1309,8 +1422,8 @@ class RestRepository extends Query {
     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,
+      sort: data.sort !== void 0 ? buildSortFilter(data.sort) : void 0,
+      page: data.pagination,
       columns: data.columns
     };
     const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
@@ -1319,8 +1432,8 @@ class RestRepository extends Query {
       body,
       ...fetchProps
     });
-    const columns = await __privateMethod$2(this, _getSchemaColumns, getSchemaColumns_fn).call(this);
-    const records = objects.map((record) => initObject(this.db, columns, __privateGet$4(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);
   }
@@ -1328,7 +1441,7 @@ class RestRepository extends Query {
 _table = new WeakMap();
 _getFetchProps = new WeakMap();
 _cache = new WeakMap();
-_schemaColumns = new WeakMap();
+_schema$1 = new WeakMap();
 _insertRecordWithoutId = new WeakSet();
 insertRecordWithoutId_fn = async function(object) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
@@ -1373,16 +1486,20 @@ _bulkInsertTableRecords = new WeakSet();
 bulkInsertTableRecords_fn = async function(objects) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const records = objects.map((object) => transformObjectLinks(object));
-  const response = await bulkInsertTableRecords({
+  const { recordIDs } = await bulkInsertTableRecords({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
     body: { records },
     ...fetchProps
   });
-  const finalObjects = await this.any(...response.recordIDs.map((id) => this.filter("id", id))).getAll();
+  const finalObjects = await this.read(recordIDs);
   if (finalObjects.length !== objects.length) {
     throw new Error("The server failed to save some records");
   }
-  return finalObjects;
+  const dictionary = finalObjects.reduce((acc, object) => {
+    acc[object.id] = object;
+    return acc;
+  }, {});
+  return recordIDs.map((id) => dictionary[id]);
 };
 _updateRecordWithID = new WeakSet();
 updateRecordWithID_fn = async function(recordId, object) {
@@ -1453,21 +1570,22 @@ getCacheQuery_fn = async function(query) {
   if (!result)
     return null;
   const { cache: ttl = __privateGet$4(this, _cache).defaultQueryTTL } = query.getQueryOptions();
-  if (!ttl || ttl < 0)
-    return result;
+  if (ttl < 0)
+    return null;
   const hasExpired = result.date.getTime() + ttl < Date.now();
   return hasExpired ? null : result;
 };
-_getSchemaColumns = new WeakSet();
-getSchemaColumns_fn = async function() {
-  if (__privateGet$4(this, _schemaColumns))
-    return __privateGet$4(this, _schemaColumns);
-  const { columns } = await getTableSchema({
-    pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}", tableName: __privateGet$4(this, _table) },
-    ...await __privateGet$4(this, _getFetchProps).call(this)
+_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, _schemaColumns, columns);
-  return columns;
+  __privateSet$3(this, _schema$1, schema);
+  return schema;
 };
 const transformObjectLinks = (object) => {
   return Object.entries(object).reduce((acc, [key, value]) => {
@@ -1476,17 +1594,21 @@ const transformObjectLinks = (object) => {
     return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
   }, {});
 };
-const initObject = (db, columns, table, object) => {
+const initObject = (db, schema, table, object) => {
   const result = {};
-  Object.assign(result, object);
-  for (const column of columns) {
+  const { xata, ...rest } = object ?? {};
+  Object.assign(result, rest);
+  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())) {
+        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 {
+        } else if (date) {
           result[column.name] = date;
         }
         break;
@@ -1495,8 +1617,8 @@ const initObject = (db, columns, table, object) => {
         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, columns, linkTable, value);
+        } else if (isObject(value)) {
+          result[column.name] = initObject(db, schema, linkTable, value);
         }
         break;
       }
@@ -1511,7 +1633,10 @@ const initObject = (db, columns, table, object) => {
   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);
@@ -1621,7 +1746,7 @@ class SchemaPlugin extends XataPlugin {
       get: (_target, table) => {
         if (!isString(table))
           throw new Error("Invalid table name");
-        if (!__privateGet$2(this, _tables)[table]) {
+        if (__privateGet$2(this, _tables)[table] === void 0) {
           __privateGet$2(this, _tables)[table] = new RestRepository({ db, pluginOptions, table });
         }
         return __privateGet$2(this, _tables)[table];
@@ -1673,11 +1798,7 @@ class SearchPlugin extends XataPlugin {
         const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
         return records.map((record) => {
           const { table = "orphan" } = record.xata;
-          const columns = schema.tables.find((t) => t.name === table)?.columns;
-          if (!columns) {
-            console.error(`No schema columns found for table ${table}`);
-          }
-          return { table, record: initObject(this.db, columns ?? [], table, record) };
+          return { table, record: initObject(this.db, schema, table, record) };
         });
       },
       byTable: async (query, options = {}) => {
@@ -1685,12 +1806,8 @@ class SearchPlugin extends XataPlugin {
         const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
         return records.reduce((acc, record) => {
           const { table = "orphan" } = record.xata;
-          const columns = schema.tables.find((t) => t.name === table)?.columns;
-          if (!columns) {
-            console.error(`No schema columns found for table ${table}`);
-          }
           const items = acc[table] ?? [];
-          const item = initObject(this.db, columns ?? [], table, record);
+          const item = initObject(this.db, schema, table, record);
           return { ...acc, [table]: [...items, item] };
         }, {});
       }
@@ -1701,10 +1818,10 @@ _schema = new WeakMap();
 _search = new WeakSet();
 search_fn = async function(query, options, getFetchProps) {
   const fetchProps = await getFetchProps();
-  const { tables, fuzziness } = options ?? {};
+  const { tables, fuzziness, highlight } = options ?? {};
   const { records } = await searchBranch({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
-    body: { tables, query, fuzziness },
+    body: { tables, query, fuzziness, highlight },
     ...fetchProps
   });
   return records;
@@ -1732,30 +1849,39 @@ const envBranchNames = [
   "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 env = getBranchByEnvVariable();
+  if (env) {
+    const details = await getDatabaseBranch(env, options);
+    if (details)
+      return env;
+    console.warn(`Branch ${env} not found in Xata. Ignoring...`);
+  }
+  const gitBranch = 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 { branch } = await resolveBranch({
+    apiKey,
+    apiUrl: databaseURL,
+    fetchImpl: getFetchImplementation(options?.fetchImpl),
+    workspacesApiUrl: `${protocol}//${host}`,
+    pathParams: { dbName, workspace },
+    queryParams: { gitBranch, fallbackBranch: getEnvVariable("XATA_FALLBACK_BRANCH") }
+  });
+  return branch;
 }
 async function getDatabaseBranch(branch, options) {
   const databaseURL = options?.databaseURL || getDatabaseURL();
@@ -1773,10 +1899,7 @@ async function getDatabaseBranch(branch, options) {
       apiUrl: databaseURL,
       fetchImpl: getFetchImplementation(options?.fetchImpl),
       workspacesApiUrl: `${protocol}//${host}`,
-      pathParams: {
-        dbBranchName,
-        workspace
-      }
+      pathParams: { dbBranchName, workspace }
     });
   } catch (err) {
     if (isObject(err) && err.status === 404)
@@ -1844,7 +1967,7 @@ const buildClient = (plugins) => {
       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) {
@@ -1861,7 +1984,7 @@ const buildClient = (plugins) => {
     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 });
+    const branch = async () => options?.branch !== void 0 ? await __privateMethod(this, _evaluateBranch, evaluateBranch_fn).call(this, options.branch) : await getCurrentBranchName({ apiKey, databaseURL, fetchImpl: options?.fetch });
     if (!databaseURL || !apiKey) {
       throw new Error("Options databaseURL and apiKey are required");
     }
@@ -1888,7 +2011,7 @@ const buildClient = (plugins) => {
   }, _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) => {
@@ -1921,6 +2044,7 @@ exports.PAGINATION_MAX_OFFSET = PAGINATION_MAX_OFFSET;
 exports.PAGINATION_MAX_SIZE = PAGINATION_MAX_SIZE;
 exports.Page = Page;
 exports.Query = Query;
+exports.RecordArray = RecordArray;
 exports.Repository = Repository;
 exports.RestRepository = RestRepository;
 exports.SchemaPlugin = SchemaPlugin;
@@ -1985,6 +2109,7 @@ exports.insertRecord = insertRecord;
 exports.insertRecordWithID = insertRecordWithID;
 exports.inviteWorkspaceMember = inviteWorkspaceMember;
 exports.is = is;
+exports.isCursorPaginationOptions = isCursorPaginationOptions;
 exports.isIdentifiable = isIdentifiable;
 exports.isNot = isNot;
 exports.isXataRecord = isXataRecord;
@@ -2000,6 +2125,7 @@ exports.removeWorkspaceMember = removeWorkspaceMember;
 exports.resendWorkspaceMemberInvite = resendWorkspaceMemberInvite;
 exports.resolveBranch = resolveBranch;
 exports.searchBranch = searchBranch;
+exports.searchTable = searchTable;
 exports.setTableSchema = setTableSchema;
 exports.startsWith = startsWith;
 exports.updateBranchMetadata = updateBranchMetadata;