@xata.io/client 0.13.2 → 0.14.0

package/dist/index.cjs

@@ -2,6 +2,24 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
 function notEmpty(value) {
   return value !== null && value !== void 0;
 }
@@ -26,35 +44,81 @@ function toBase64(value) {
   }
 }
 
-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 nodeModule = ["child", "process"].join("_");
   try {
     if (typeof require === "function") {
-      const req = require;
-      return req("child_process").execSync("git branch --show-current", { encoding: "utf-8" }).trim();
+      return require(nodeModule).execSync(cmd.join(" "), { encoding: "utf-8" }).trim();
     }
+    const { execSync } = await (function (t) { return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(t)); }); })(nodeModule);
+    return execSync(cmd.join(" "), { encoding: "utf-8" }).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: "piped" });
       return new TextDecoder().decode(await process2.output()).trim();
     }
   } catch (err) {
@@ -63,7 +127,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;
   }
@@ -78,7 +143,7 @@ function getFetchImplementation(userFetch) {
   return fetchImpl;
 }
 
-const VERSION = "0.13.2";
+const VERSION = "0.14.0";
 
 class ErrorWithCause extends Error {
   constructor(message, options) {
@@ -504,7 +569,7 @@ var __privateAdd$7 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$6 = (obj, member, value, setter) => {
+var __privateSet$7 = (obj, member, value, setter) => {
   __accessCheck$7(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -519,7 +584,7 @@ class XataApiClient {
     if (!apiKey) {
       throw new Error("Could not resolve a valid apiKey");
     }
-    __privateSet$6(this, _extraProps, {
+    __privateSet$7(this, _extraProps, {
       apiUrl: getHostUrl(provider, "main"),
       workspacesApiUrl: getHostUrl(provider, "workspaces"),
       fetchImpl: getFetchImplementation(options.fetch),
@@ -956,7 +1021,7 @@ var __privateAdd$6 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$5 = (obj, member, value, setter) => {
+var __privateSet$6 = (obj, member, value, setter) => {
   __accessCheck$6(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -965,7 +1030,7 @@ var _query, _page;
 class Page {
   constructor(query, meta, records = []) {
     __privateAdd$6(this, _query, void 0);
-    __privateSet$5(this, _query, query);
+    __privateSet$6(this, _query, query);
     this.meta = meta;
     this.records = new RecordArray(this, records);
   }
@@ -994,10 +1059,26 @@ function isCursorPaginationOptions(options) {
   return isDefined(options) && (isDefined(options.first) || isDefined(options.last) || isDefined(options.after) || isDefined(options.before));
 }
 const _RecordArray = class extends Array {
-  constructor(page, overrideRecords) {
-    super(...overrideRecords ?? page.records);
+  constructor(...args) {
+    super(..._RecordArray.parseConstructorParams(...args));
     __privateAdd$6(this, _page, void 0);
-    __privateSet$5(this, _page, page);
+    __privateSet$6(this, _page, isObject(args[0]?.meta) ? args[0] : { meta: { page: { cursor: "", more: false } }, records: [] });
+  }
+  static parseConstructorParams(...args) {
+    if (args.length === 1 && typeof args[0] === "number") {
+      return new Array(args[0]);
+    }
+    if (args.length <= 2 && isObject(args[0]?.meta) && Array.isArray(args[1] ?? [])) {
+      const result = args[1] ?? args[0].records ?? [];
+      return new Array(...result);
+    }
+    return new Array(...args);
+  }
+  toArray() {
+    return new Array(...this);
+  }
+  map(callbackfn, thisArg) {
+    return this.toArray().map(callbackfn, thisArg);
   }
   async nextPage(size, offset) {
     const newPage = await __privateGet$6(this, _page).nextPage(size, offset);
@@ -1035,7 +1116,7 @@ var __privateAdd$5 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$4 = (obj, member, value, setter) => {
+var __privateSet$5 = (obj, member, value, setter) => {
   __accessCheck$5(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -1048,11 +1129,11 @@ const _Query = class {
     __privateAdd$5(this, _data, { filter: {} });
     this.meta = { page: { cursor: "start", more: true } };
     this.records = new RecordArray(this, []);
-    __privateSet$4(this, _table$1, table);
+    __privateSet$5(this, _table$1, table);
     if (repository) {
-      __privateSet$4(this, _repository, repository);
+      __privateSet$5(this, _repository, repository);
     } else {
-      __privateSet$4(this, _repository, this);
+      __privateSet$5(this, _repository, this);
     }
     const parent = cleanParent(data, rawParent);
     __privateGet$5(this, _data).filter = data.filter ?? parent?.filter ?? {};
@@ -1229,7 +1310,7 @@ var __privateAdd$4 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$3 = (obj, member, value, setter) => {
+var __privateSet$4 = (obj, member, value, setter) => {
   __accessCheck$4(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -1238,7 +1319,7 @@ var __privateMethod$2 = (obj, member, method) => {
   __accessCheck$4(obj, member, "access private method");
   return method;
 };
-var _table, _getFetchProps, _cache, _schema$1, _insertRecordWithoutId, insertRecordWithoutId_fn, _insertRecordWithId, insertRecordWithId_fn, _bulkInsertTableRecords, bulkInsertTableRecords_fn, _updateRecordWithID, updateRecordWithID_fn, _upsertRecordWithID, upsertRecordWithID_fn, _deleteRecord, deleteRecord_fn, _invalidateCache, invalidateCache_fn, _setCacheRecord, setCacheRecord_fn, _getCacheRecord, getCacheRecord_fn, _setCacheQuery, setCacheQuery_fn, _getCacheQuery, getCacheQuery_fn, _getSchema$1, getSchema_fn$1;
+var _table, _getFetchProps, _cache, _schemaTables$2, _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, _getSchemaTables$1, getSchemaTables_fn$1;
 class Repository extends Query {
 }
 class RestRepository extends Query {
@@ -1255,43 +1336,24 @@ class RestRepository extends Query {
     __privateAdd$4(this, _getCacheRecord);
     __privateAdd$4(this, _setCacheQuery);
     __privateAdd$4(this, _getCacheQuery);
-    __privateAdd$4(this, _getSchema$1);
+    __privateAdd$4(this, _getSchemaTables$1);
     __privateAdd$4(this, _table, void 0);
     __privateAdd$4(this, _getFetchProps, void 0);
     __privateAdd$4(this, _cache, void 0);
-    __privateAdd$4(this, _schema$1, void 0);
-    __privateSet$3(this, _table, options.table);
-    __privateSet$3(this, _getFetchProps, options.pluginOptions.getFetchProps);
+    __privateAdd$4(this, _schemaTables$2, void 0);
+    __privateSet$4(this, _table, options.table);
+    __privateSet$4(this, _getFetchProps, options.pluginOptions.getFetchProps);
     this.db = options.db;
-    __privateSet$3(this, _cache, options.pluginOptions.cache);
+    __privateSet$4(this, _cache, options.pluginOptions.cache);
+    __privateSet$4(this, _schemaTables$2, options.schemaTables);
   }
   async create(a, b) {
     if (Array.isArray(a)) {
       if (a.length === 0)
         return [];
-      const [itemsWithoutIds, itemsWithIds, order] = a.reduce(([accWithoutIds, accWithIds, accOrder], item) => {
-        const condition = isString(item.id);
-        accOrder.push(condition);
-        if (condition) {
-          accWithIds.push(item);
-        } else {
-          accWithoutIds.push(item);
-        }
-        return [accWithoutIds, accWithIds, accOrder];
-      }, [[], [], []]);
-      const recordsWithoutId = await __privateMethod$2(this, _bulkInsertTableRecords, bulkInsertTableRecords_fn).call(this, itemsWithoutIds);
-      await Promise.all(recordsWithoutId.map((record) => __privateMethod$2(this, _setCacheRecord, setCacheRecord_fn).call(this, record)));
-      if (itemsWithIds.length > 100) {
-        console.warn("Bulk create operation with id is not optimized in the Xata API yet, this request might be slow");
-      }
-      const recordsWithId = await Promise.all(itemsWithIds.map((object) => this.create(object)));
-      return order.map((condition) => {
-        if (condition) {
-          return recordsWithId.shift();
-        } else {
-          return recordsWithoutId.shift();
-        }
-      }).filter((record) => !!record);
+      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 === "")
@@ -1332,8 +1394,8 @@ class RestRepository extends Query {
           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);
+        const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+        return initObject(this.db, schemaTables, __privateGet$4(this, _table), response);
       } catch (e) {
         if (isObject(e) && e.status === 404) {
           return null;
@@ -1422,8 +1484,8 @@ class RestRepository extends Query {
       },
       ...fetchProps
     });
-    const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
-    return records.map((item) => initObject(this.db, schema, __privateGet$4(this, _table), item));
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    return records.map((item) => initObject(this.db, schemaTables, __privateGet$4(this, _table), item));
   }
   async query(query) {
     const cacheQuery = await __privateMethod$2(this, _getCacheQuery, getCacheQuery_fn).call(this, query);
@@ -1442,8 +1504,8 @@ class RestRepository extends Query {
       body,
       ...fetchProps
     });
-    const schema = await __privateMethod$2(this, _getSchema$1, getSchema_fn$1).call(this);
-    const records = objects.map((record) => initObject(this.db, schema, __privateGet$4(this, _table), record));
+    const schemaTables = await __privateMethod$2(this, _getSchemaTables$1, getSchemaTables_fn$1).call(this);
+    const records = objects.map((record) => initObject(this.db, schemaTables, __privateGet$4(this, _table), record));
     await __privateMethod$2(this, _setCacheQuery, setCacheQuery_fn).call(this, query, meta, records);
     return new Page(query, meta, records);
   }
@@ -1451,7 +1513,7 @@ class RestRepository extends Query {
 _table = new WeakMap();
 _getFetchProps = new WeakMap();
 _cache = new WeakMap();
-_schema$1 = new WeakMap();
+_schemaTables$2 = new WeakMap();
 _insertRecordWithoutId = new WeakSet();
 insertRecordWithoutId_fn = async function(object) {
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
@@ -1496,16 +1558,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.read(response.recordIDs);
+  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) {
@@ -1581,17 +1647,17 @@ getCacheQuery_fn = async function(query) {
   const hasExpired = result.date.getTime() + ttl < Date.now();
   return hasExpired ? null : result;
 };
-_getSchema$1 = new WeakSet();
-getSchema_fn$1 = async function() {
-  if (__privateGet$4(this, _schema$1))
-    return __privateGet$4(this, _schema$1);
+_getSchemaTables$1 = new WeakSet();
+getSchemaTables_fn$1 = async function() {
+  if (__privateGet$4(this, _schemaTables$2))
+    return __privateGet$4(this, _schemaTables$2);
   const fetchProps = await __privateGet$4(this, _getFetchProps).call(this);
   const { schema } = await getBranchDetails({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
     ...fetchProps
   });
-  __privateSet$3(this, _schema$1, schema);
-  return schema;
+  __privateSet$4(this, _schemaTables$2, schema.tables);
+  return schema.tables;
 };
 const transformObjectLinks = (object) => {
   return Object.entries(object).reduce((acc, [key, value]) => {
@@ -1600,11 +1666,11 @@ const transformObjectLinks = (object) => {
     return { ...acc, [key]: isIdentifiable(value) ? value.id : value };
   }, {});
 };
-const initObject = (db, schema, table, object) => {
+const initObject = (db, schemaTables, table, object) => {
   const result = {};
   const { xata, ...rest } = object ?? {};
   Object.assign(result, rest);
-  const { columns } = schema.tables.find(({ name }) => name === table) ?? {};
+  const { columns } = schemaTables.find(({ name }) => name === table) ?? {};
   if (!columns)
     console.error(`Table ${table} not found in schema`);
   for (const column of columns ?? []) {
@@ -1624,7 +1690,7 @@ const initObject = (db, schema, table, object) => {
         if (!linkTable) {
           console.error(`Failed to parse link for field ${column.name}`);
         } else if (isObject(value)) {
-          result[column.name] = initObject(db, schema, linkTable, value);
+          result[column.name] = initObject(db, schemaTables, linkTable, value);
         }
         break;
       }
@@ -1671,7 +1737,7 @@ var __privateAdd$3 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$2 = (obj, member, value, setter) => {
+var __privateSet$3 = (obj, member, value, setter) => {
   __accessCheck$3(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
@@ -1680,7 +1746,7 @@ var _map;
 class SimpleCache {
   constructor(options = {}) {
     __privateAdd$3(this, _map, void 0);
-    __privateSet$2(this, _map, /* @__PURE__ */ new Map());
+    __privateSet$3(this, _map, /* @__PURE__ */ new Map());
     this.capacity = options.max ?? 500;
     this.cacheRecords = options.cacheRecords ?? true;
     this.defaultQueryTTL = options.defaultQueryTTL ?? 60 * 1e3;
@@ -1740,12 +1806,18 @@ var __privateAdd$2 = (obj, member, value) => {
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var _tables;
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _tables, _schemaTables$1;
 class SchemaPlugin extends XataPlugin {
-  constructor(tableNames) {
+  constructor(schemaTables) {
     super();
-    this.tableNames = tableNames;
     __privateAdd$2(this, _tables, {});
+    __privateAdd$2(this, _schemaTables$1, void 0);
+    __privateSet$2(this, _schemaTables$1, schemaTables);
   }
   build(pluginOptions) {
     const db = new Proxy({}, {
@@ -1753,18 +1825,20 @@ class SchemaPlugin extends XataPlugin {
         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 });
+          __privateGet$2(this, _tables)[table] = new RestRepository({ db, pluginOptions, table, schemaTables: __privateGet$2(this, _schemaTables$1) });
         }
         return __privateGet$2(this, _tables)[table];
       }
     });
-    for (const table of this.tableNames ?? []) {
-      db[table] = new RestRepository({ db, pluginOptions, table });
+    const tableNames = __privateGet$2(this, _schemaTables$1)?.map(({ name }) => name) ?? [];
+    for (const table of tableNames) {
+      db[table] = new RestRepository({ db, pluginOptions, table, schemaTables: __privateGet$2(this, _schemaTables$1) });
     }
     return db;
   }
 }
 _tables = new WeakMap();
+_schemaTables$1 = new WeakMap();
 
 var __accessCheck$1 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -1788,39 +1862,40 @@ var __privateMethod$1 = (obj, member, method) => {
   __accessCheck$1(obj, member, "access private method");
   return method;
 };
-var _schema, _search, search_fn, _getSchema, getSchema_fn;
+var _schemaTables, _search, search_fn, _getSchemaTables, getSchemaTables_fn;
 class SearchPlugin extends XataPlugin {
-  constructor(db) {
+  constructor(db, schemaTables) {
     super();
     this.db = db;
     __privateAdd$1(this, _search);
-    __privateAdd$1(this, _getSchema);
-    __privateAdd$1(this, _schema, void 0);
+    __privateAdd$1(this, _getSchemaTables);
+    __privateAdd$1(this, _schemaTables, void 0);
+    __privateSet$1(this, _schemaTables, schemaTables);
   }
   build({ getFetchProps }) {
     return {
       all: async (query, options = {}) => {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
-        const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, getFetchProps);
         return records.map((record) => {
           const { table = "orphan" } = record.xata;
-          return { table, record: initObject(this.db, schema, table, record) };
+          return { table, record: initObject(this.db, schemaTables, table, record) };
         });
       },
       byTable: async (query, options = {}) => {
         const records = await __privateMethod$1(this, _search, search_fn).call(this, query, options, getFetchProps);
-        const schema = await __privateMethod$1(this, _getSchema, getSchema_fn).call(this, getFetchProps);
+        const schemaTables = await __privateMethod$1(this, _getSchemaTables, getSchemaTables_fn).call(this, getFetchProps);
         return records.reduce((acc, record) => {
           const { table = "orphan" } = record.xata;
           const items = acc[table] ?? [];
-          const item = initObject(this.db, schema, table, record);
+          const item = initObject(this.db, schemaTables, table, record);
           return { ...acc, [table]: [...items, item] };
         }, {});
       }
     };
   }
 }
-_schema = new WeakMap();
+_schemaTables = new WeakMap();
 _search = new WeakSet();
 search_fn = async function(query, options, getFetchProps) {
   const fetchProps = await getFetchProps();
@@ -1832,38 +1907,32 @@ 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);
+_getSchemaTables = new WeakSet();
+getSchemaTables_fn = async function(getFetchProps) {
+  if (__privateGet$1(this, _schemaTables))
+    return __privateGet$1(this, _schemaTables);
   const fetchProps = await getFetchProps();
   const { schema } = await getBranchDetails({
     pathParams: { workspace: "{workspaceId}", dbBranchName: "{dbBranch}" },
     ...fetchProps
   });
-  __privateSet$1(this, _schema, schema);
-  return schema;
+  __privateSet$1(this, _schemaTables, schema.tables);
+  return schema.tables;
 };
 
 const isBranchStrategyBuilder = (strategy) => {
   return typeof strategy === "function";
 };
 
-const envBranchNames = [
-  "XATA_BRANCH",
-  "VERCEL_GIT_COMMIT_REF",
-  "CF_PAGES_BRANCH",
-  "BRANCH"
-];
 async function getCurrentBranchName(options) {
-  const env = getBranchByEnvVariable();
-  if (env) {
-    const details = await getDatabaseBranch(env, options);
+  const { branch, envBranch } = getEnvironment();
+  if (branch) {
+    const details = await getDatabaseBranch(branch, options);
     if (details)
-      return env;
-    console.warn(`Branch ${env} not found in Xata. Ignoring...`);
+      return branch;
+    console.warn(`Branch ${branch} not found in Xata. Ignoring...`);
   }
-  const gitBranch = await getGitBranch();
+  const gitBranch = envBranch || await getGitBranch();
   return resolveXataBranch(gitBranch, options);
 }
 async function getCurrentBranchDetails(options) {
@@ -1879,13 +1948,14 @@ async function resolveXataBranch(gitBranch, options) {
     throw new Error("An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely");
   const [protocol, , host, , dbName] = databaseURL.split("/");
   const [workspace] = host.split(".");
+  const { fallbackBranch } = getEnvironment();
   const { branch } = await resolveBranch({
     apiKey,
     apiUrl: databaseURL,
     fetchImpl: getFetchImplementation(options?.fetchImpl),
     workspacesApiUrl: `${protocol}//${host}`,
     pathParams: { dbName, workspace },
-    queryParams: { gitBranch, fallbackBranch: getEnvVariable("XATA_FALLBACK_BRANCH") }
+    queryParams: { gitBranch, fallbackBranch }
   });
   return branch;
 }
@@ -1913,21 +1983,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;
   }
@@ -1958,7 +2017,7 @@ 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 = {}, tables) {
+    constructor(options = {}, schemaTables) {
       __privateAdd(this, _parseOptions);
       __privateAdd(this, _getFetchProps);
       __privateAdd(this, _evaluateBranch);
@@ -1968,8 +2027,8 @@ const buildClient = (plugins) => {
         getFetchProps: () => __privateMethod(this, _getFetchProps, getFetchProps_fn).call(this, safeOptions),
         cache: safeOptions.cache
       };
-      const db = new SchemaPlugin(tables).build(pluginOptions);
-      const search = new SearchPlugin(db).build(pluginOptions);
+      const db = new SchemaPlugin(schemaTables).build(pluginOptions);
+      const search = new SearchPlugin(db, schemaTables).build(pluginOptions);
       this.db = db;
       this.search = search;
       for (const [key, namespace] of Object.entries(plugins ?? {})) {