@xata.io/client 0.7.1 → 0.7.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @xata.io/client
 
+## 0.7.2
+
+### Patch Changes
+
+- 4803b6f: Memoize ApiClient namespaces
+- 1f268d7: Add search in XataClient
+- d58c3d9: Hide private helper utilities
+- f3b731b: Expose branch resolution API
+
 ## 0.7.1
 
 ### Patch Changes

package/dist/api/client.js

@@ -10,10 +10,10 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _XataApiClient_extraProps;
+var _XataApiClient_extraProps, _XataApiClient_namespaces;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XataApiClient = void 0;
-const config_1 = require("../schema/config");
+const config_1 = require("../util/config");
 const fetch_1 = require("../util/fetch");
 const components_1 = require("./components");
 const providers_1 = require("./providers");
@@ -21,6 +21,7 @@ class XataApiClient {
     constructor(options) {
         var _a, _b;
         _XataApiClient_extraProps.set(this, void 0);
+        _XataApiClient_namespaces.set(this, {});
         const provider = (_a = options.host) !== null && _a !== void 0 ? _a : 'production';
         const apiKey = (_b = options === null || options === void 0 ? void 0 : options.apiKey) !== null && _b !== void 0 ? _b : (0, config_1.getAPIKey)();
         if (!apiKey) {
@@ -34,26 +35,38 @@ class XataApiClient {
         }, "f");
     }
     get user() {
-        return new UserApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user = new UserApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user;
     }
     get workspaces() {
-        return new WorkspaceApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces = new WorkspaceApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces;
     }
     get databases() {
-        return new DatabaseApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases = new DatabaseApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases;
     }
     get branches() {
-        return new BranchApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches = new BranchApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches;
     }
     get tables() {
-        return new TableApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables = new TableApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables;
     }
     get records() {
-        return new RecordsApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records = new RecordsApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records;
     }
 }
 exports.XataApiClient = XataApiClient;
-_XataApiClient_extraProps = new WeakMap();
+_XataApiClient_extraProps = new WeakMap(), _XataApiClient_namespaces = new WeakMap();
 class UserApi {
     constructor(extraProps) {
         this.extraProps = extraProps;

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export declare class XataError extends Error {
 }
 export * from './api';
 export * from './schema';
+export * from './util/config';

package/dist/index.js

@@ -24,3 +24,4 @@ class XataError extends Error {
 exports.XataError = XataError;
 __exportStar(require("./api"), exports);
 __exportStar(require("./schema"), exports);
+__exportStar(require("./util/config"), exports);

package/dist/schema/repository.d.ts

@@ -1,9 +1,11 @@
 import { FetchImpl } from '../api/fetcher';
+import { Dictionary, GetArrayInnerType, StringKeys } from '../util/types';
 import { Page } from './pagination';
 import { Query } from './query';
 import { BaseData, EditableData, Identifiable, XataRecord } from './record';
 import { SelectedPick } from './selection';
-export declare type Links = Record<string, Array<string[]>>;
+declare type TableLink = string[];
+export declare type LinkDictionary = Dictionary<TableLink[]>;
 /**
  * Common interface for performing operations on a table.
  */
@@ -93,11 +95,20 @@ export declare abstract class Repository<Data extends BaseData, Record extends X
      * @throws If the record could not be found or there was an error while performing the deletion.
      */
     abstract delete(ids: Identifiable[]): Promise<void>;
+    /**
+     * Search for records in the table.
+     * @param query The query to search for.
+     * @param options The options to search with (like: fuzziness)
+     * @returns The found records.
+     */
+    abstract search(query: string, options?: {
+        fuzziness?: number;
+    }): Promise<SelectedPick<Record, ['*']>[]>;
     abstract query<Result extends XataRecord>(query: Query<Record, Result>): Promise<Page<Record, Result>>;
 }
 export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, SelectedPick<Record, ['*']>> {
     #private;
-    constructor(client: BaseClient<any>, table: string);
+    constructor(client: BaseClient<any>, table: string, links?: LinkDictionary);
     create(object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     create(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     create(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
@@ -109,13 +120,16 @@ export declare class RestRepository<Data extends BaseData, Record extends XataRe
     createOrUpdate(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     createOrUpdate(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
     delete(recordId: string | Identifiable | Array<string | Identifiable>): Promise<void>;
+    search(query: string, options?: {
+        fuzziness?: number;
+    }): Promise<SelectedPick<Record, ['*']>[]>;
     query<Result extends XataRecord>(query: Query<Record, Result>): Promise<Page<Record, Result>>;
 }
 interface RepositoryFactory {
-    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data & XataRecord>;
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string, links?: LinkDictionary): Repository<Data & XataRecord>;
 }
 export declare class RestRespositoryFactory implements RepositoryFactory {
-    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data & XataRecord>;
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string, links?: LinkDictionary): Repository<Data & XataRecord>;
 }
 declare type BranchStrategyValue = string | undefined | null;
 declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;
@@ -138,11 +152,14 @@ export declare type XataClientOptions = {
     repositoryFactory?: RepositoryFactory;
 };
 export declare class BaseClient<D extends Record<string, Repository<any>> = Record<string, Repository<any>>> {
-    #private;
     options: XataClientOptions;
     db: D;
-    constructor(options?: XataClientOptions, links?: Links);
-    initObject<T>(table: string, object: object): T;
-    getBranch(): Promise<string>;
+    constructor(options?: XataClientOptions, links?: LinkDictionary);
+    search<Tables extends StringKeys<D>>(query: string, options?: {
+        fuzziness?: number;
+        tables?: Tables[];
+    }): Promise<{
+        [Model in GetArrayInnerType<NonNullable<NonNullable<typeof options>['tables']>>]: Awaited<ReturnType<D[Model]['search']>>;
+    }>;
 }
 export {};

package/dist/schema/repository.js

@@ -26,13 +26,13 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
-var _RestRepository_instances, _RestRepository_client, _RestRepository_fetch, _RestRepository_table, _RestRepository_getFetchProps, _RestRepository_insertRecordWithoutId, _RestRepository_insertRecordWithId, _RestRepository_bulkInsertTableRecords, _RestRepository_updateRecordWithID, _RestRepository_upsertRecordWithID, _RestRepository_deleteRecord, _BaseClient_links, _BaseClient_branch;
+var _RestRepository_instances, _RestRepository_client, _RestRepository_fetch, _RestRepository_table, _RestRepository_links, _RestRepository_branch, _RestRepository_getFetchProps, _RestRepository_getBranch, _RestRepository_insertRecordWithoutId, _RestRepository_insertRecordWithId, _RestRepository_bulkInsertTableRecords, _RestRepository_updateRecordWithID, _RestRepository_upsertRecordWithID, _RestRepository_deleteRecord, _RestRepository_initObject;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = void 0;
 const api_1 = require("../api");
 const fetch_1 = require("../util/fetch");
 const lang_1 = require("../util/lang");
-const config_1 = require("./config");
+const config_1 = require("../util/config");
 const pagination_1 = require("./pagination");
 const query_1 = require("./query");
 const record_1 = require("./record");
@@ -44,15 +44,18 @@ class Repository extends query_1.Query {
 }
 exports.Repository = Repository;
 class RestRepository extends query_1.Query {
-    constructor(client, table) {
+    constructor(client, table, links) {
         super(null, table, {});
         _RestRepository_instances.add(this);
         _RestRepository_client.set(this, void 0);
         _RestRepository_fetch.set(this, void 0);
         _RestRepository_table.set(this, void 0);
+        _RestRepository_links.set(this, void 0);
+        _RestRepository_branch.set(this, void 0);
         __classPrivateFieldSet(this, _RestRepository_client, client, "f");
         __classPrivateFieldSet(this, _RestRepository_table, table, "f");
         __classPrivateFieldSet(this, _RestRepository_fetch, (0, fetch_1.getFetchImplementation)(__classPrivateFieldGet(this, _RestRepository_client, "f").options.fetch), "f");
+        __classPrivateFieldSet(this, _RestRepository_links, links !== null && links !== void 0 ? links : {}, "f");
     }
     create(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -85,7 +88,7 @@ class RestRepository extends query_1.Query {
             const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
             try {
                 const response = yield (0, api_1.getRecord)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId } }, fetchProps));
-                return __classPrivateFieldGet(this, _RestRepository_client, "f").initObject(__classPrivateFieldGet(this, _RestRepository_table, "f"), response);
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, __classPrivateFieldGet(this, _RestRepository_table, "f"), response);
             }
             catch (e) {
                 if ((0, lang_1.isObject)(e) && e.status === 404) {
@@ -161,6 +164,13 @@ class RestRepository extends query_1.Query {
             throw new Error('Invalid arguments for delete method');
         });
     }
+    search(query, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+            const { records } = yield (0, api_1.searchBranch)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}' }, body: { tables: [__classPrivateFieldGet(this, _RestRepository_table, "f")], query, fuzziness: options.fuzziness } }, fetchProps));
+            return records.map((item) => __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, __classPrivateFieldGet(this, _RestRepository_table, "f"), item));
+        });
+    }
     query(query) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -173,16 +183,16 @@ class RestRepository extends query_1.Query {
             };
             const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
             const { meta, records: objects } = yield (0, api_1.queryTable)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f") }, body }, fetchProps));
-            const records = objects.map((record) => __classPrivateFieldGet(this, _RestRepository_client, "f").initObject(__classPrivateFieldGet(this, _RestRepository_table, "f"), record));
+            const records = objects.map((record) => __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, __classPrivateFieldGet(this, _RestRepository_table, "f"), record));
             return new pagination_1.Page(query, meta, records);
         });
     }
 }
 exports.RestRepository = RestRepository;
-_RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _RestRepository_table = new WeakMap(), _RestRepository_instances = new WeakSet(), _RestRepository_getFetchProps = function _RestRepository_getFetchProps() {
+_RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _RestRepository_table = new WeakMap(), _RestRepository_links = new WeakMap(), _RestRepository_branch = new WeakMap(), _RestRepository_instances = new WeakSet(), _RestRepository_getFetchProps = function _RestRepository_getFetchProps() {
     var _a;
     return __awaiter(this, void 0, void 0, function* () {
-        const branch = yield __classPrivateFieldGet(this, _RestRepository_client, "f").getBranch();
+        const branch = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getBranch).call(this);
         const apiKey = (_a = __classPrivateFieldGet(this, _RestRepository_client, "f").options.apiKey) !== null && _a !== void 0 ? _a : (0, config_1.getAPIKey)();
         if (!apiKey) {
             throw new Error('Could not resolve a valid apiKey');
@@ -201,6 +211,35 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
             }
         };
     });
+}, _RestRepository_getBranch = function _RestRepository_getBranch() {
+    var e_1, _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (__classPrivateFieldGet(this, _RestRepository_branch, "f"))
+            return __classPrivateFieldGet(this, _RestRepository_branch, "f");
+        const { branch: param } = __classPrivateFieldGet(this, _RestRepository_client, "f").options;
+        const strategies = Array.isArray(param) ? [...param] : [param];
+        const evaluateBranch = (strategy) => __awaiter(this, void 0, void 0, function* () {
+            return isBranchStrategyBuilder(strategy) ? yield strategy() : strategy;
+        });
+        try {
+            for (var strategies_1 = __asyncValues(strategies), strategies_1_1; strategies_1_1 = yield strategies_1.next(), !strategies_1_1.done;) {
+                const strategy = strategies_1_1.value;
+                const branch = yield evaluateBranch(strategy);
+                if (branch) {
+                    __classPrivateFieldSet(this, _RestRepository_branch, branch, "f");
+                    return branch;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (strategies_1_1 && !strategies_1_1.done && (_a = strategies_1.return)) yield _a.call(strategies_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        throw new Error('Unable to resolve branch value');
+    });
 }, _RestRepository_insertRecordWithoutId = function _RestRepository_insertRecordWithoutId(object) {
     return __awaiter(this, void 0, void 0, function* () {
         const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
@@ -267,22 +306,43 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
         const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
         yield (0, api_1.deleteRecord)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId } }, fetchProps));
     });
+}, _RestRepository_initObject = function _RestRepository_initObject(table, object) {
+    const result = {};
+    Object.assign(result, object);
+    const tableLinks = __classPrivateFieldGet(this, _RestRepository_links, "f")[table] || [];
+    for (const link of tableLinks) {
+        const [field, linkTable] = link;
+        const value = result[field];
+        if (value && (0, lang_1.isObject)(value)) {
+            result[field] = __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, linkTable, value);
+        }
+    }
+    const db = __classPrivateFieldGet(this, _RestRepository_client, "f").db;
+    result.read = function () {
+        return db[table].read(result['id']);
+    };
+    result.update = function (data) {
+        return db[table].update(result['id'], data);
+    };
+    result.delete = function () {
+        return db[table].delete(result['id']);
+    };
+    for (const prop of ['read', 'update', 'delete']) {
+        Object.defineProperty(result, prop, { enumerable: false });
+    }
+    Object.freeze(result);
+    return result;
 };
 class RestRespositoryFactory {
-    createRepository(client, table) {
-        return new RestRepository(client, table);
+    createRepository(client, table, links) {
+        return new RestRepository(client, table, links);
     }
 }
 exports.RestRespositoryFactory = RestRespositoryFactory;
 function resolveXataClientOptions(options) {
-    const databaseURL = (options === null || options === void 0 ? void 0 : options.databaseURL) || (0, config_1.getDatabaseUrl)() || '';
+    const databaseURL = (options === null || options === void 0 ? void 0 : options.databaseURL) || (0, config_1.getDatabaseURL)() || '';
     const apiKey = (options === null || options === void 0 ? void 0 : options.apiKey) || (0, config_1.getAPIKey)() || '';
-    const branch = (options === null || options === void 0 ? void 0 : options.branch) ||
-        (() => (0, config_1.getBranch)({
-            apiKey,
-            apiUrl: databaseURL,
-            fetchImpl: (0, fetch_1.getFetchImplementation)(options === null || options === void 0 ? void 0 : options.fetch)
-        }));
+    const branch = (options === null || options === void 0 ? void 0 : options.branch) || (() => (0, config_1.getCurrentBranchName)({ apiKey, databaseURL, fetchImpl: options === null || options === void 0 ? void 0 : options.fetch }));
     if (!databaseURL || !apiKey) {
         throw new Error('Options databaseURL and apiKey are required');
     }
@@ -291,82 +351,30 @@ function resolveXataClientOptions(options) {
         branch });
 }
 class BaseClient {
-    constructor(options = {}, links = {}) {
-        _BaseClient_links.set(this, void 0);
-        _BaseClient_branch.set(this, void 0);
+    constructor(options = {}, links) {
         this.options = resolveXataClientOptions(options);
         // Make this property not enumerable so it doesn't show up in console.dir, etc.
         Object.defineProperty(this.options, 'apiKey', { enumerable: false });
-        __classPrivateFieldSet(this, _BaseClient_links, links, "f");
         const factory = this.options.repositoryFactory || new RestRespositoryFactory();
         this.db = new Proxy({}, {
             get: (_target, prop) => {
-                if (typeof prop !== 'string')
+                if (!(0, lang_1.isString)(prop))
                     throw new Error('Invalid table name');
-                return factory.createRepository(this, prop);
+                return factory.createRepository(this, prop, links);
             }
         });
     }
-    initObject(table, object) {
-        const result = {};
-        Object.assign(result, object);
-        const tableLinks = __classPrivateFieldGet(this, _BaseClient_links, "f")[table] || [];
-        for (const link of tableLinks) {
-            const [field, linkTable] = link;
-            const value = result[field];
-            if (value && (0, lang_1.isObject)(value)) {
-                result[field] = this.initObject(linkTable, value);
-            }
-        }
-        const db = this.db;
-        result.read = function () {
-            return db[table].read(result['id']);
-        };
-        result.update = function (data) {
-            return db[table].update(result['id'], data);
-        };
-        result.delete = function () {
-            return db[table].delete(result['id']);
-        };
-        for (const prop of ['read', 'update', 'delete']) {
-            Object.defineProperty(result, prop, { enumerable: false });
-        }
-        Object.freeze(result);
-        return result;
-    }
-    getBranch() {
-        var e_1, _a;
+    search(query, options) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (__classPrivateFieldGet(this, _BaseClient_branch, "f"))
-                return __classPrivateFieldGet(this, _BaseClient_branch, "f");
-            const { branch: param } = this.options;
-            const strategies = Array.isArray(param) ? [...param] : [param];
-            const evaluateBranch = (strategy) => __awaiter(this, void 0, void 0, function* () {
-                return isBranchStrategyBuilder(strategy) ? yield strategy() : strategy;
-            });
-            try {
-                for (var strategies_1 = __asyncValues(strategies), strategies_1_1; strategies_1_1 = yield strategies_1.next(), !strategies_1_1.done;) {
-                    const strategy = strategies_1_1.value;
-                    const branch = yield evaluateBranch(strategy);
-                    if (branch) {
-                        __classPrivateFieldSet(this, _BaseClient_branch, branch, "f");
-                        return branch;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (strategies_1_1 && !strategies_1_1.done && (_a = strategies_1.return)) yield _a.call(strategies_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            throw new Error('Unable to resolve branch value');
+            const tables = (_a = options === null || options === void 0 ? void 0 : options.tables) !== null && _a !== void 0 ? _a : Object.keys(this.db);
+            // TODO: Implement global search with a single call, REST repository abstraction needed
+            const results = yield Promise.all(tables.map((table) => this.db[table].search(query, options).then((results) => [table, results])));
+            return Object.fromEntries(results);
         });
     }
 }
 exports.BaseClient = BaseClient;
-_BaseClient_links = new WeakMap(), _BaseClient_branch = new WeakMap();
 const isBranchStrategyBuilder = (strategy) => {
     return typeof strategy === 'function';
 };

package/dist/util/config.d.ts

@@ -0,0 +1,11 @@
+import { FetchImpl } from '../api/fetcher';
+declare type BranchResolutionOptions = {
+    databaseURL?: string;
+    apiKey?: string;
+    fetchImpl?: FetchImpl;
+};
+export declare function getCurrentBranchName(options?: BranchResolutionOptions): Promise<string | undefined>;
+export declare function getCurrentBranchDetails(options?: BranchResolutionOptions): Promise<import("../api/schemas").DBBranch | null>;
+export declare function getDatabaseURL(): string | undefined;
+export declare function getAPIKey(): string | undefined;
+export {};

package/dist/util/config.js

@@ -0,0 +1,121 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAPIKey = exports.getDatabaseURL = exports.getCurrentBranchDetails = exports.getCurrentBranchName = void 0;
+const api_1 = require("../api");
+const environment_1 = require("./environment");
+const fetch_1 = require("./fetch");
+const lang_1 = require("./lang");
+const envBranchNames = [
+    'XATA_BRANCH',
+    'VERCEL_GIT_COMMIT_REF',
+    'CF_PAGES_BRANCH',
+    'BRANCH' // Netlify. Putting it the last one because it is more ambiguous
+];
+const defaultBranch = 'main';
+function getCurrentBranchName(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const env = yield getBranchByEnvVariable();
+        if (env)
+            return env;
+        const branch = yield (0, environment_1.getGitBranch)();
+        if (!branch)
+            return defaultBranch;
+        // TODO: in the future, call /resolve endpoint
+        // For now, call API to see if the branch exists. If not, use a default value.
+        const details = yield getDatabaseBranch(branch, options);
+        if (details)
+            return branch;
+        return defaultBranch;
+    });
+}
+exports.getCurrentBranchName = getCurrentBranchName;
+function getCurrentBranchDetails(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const env = yield getBranchByEnvVariable();
+        if (env)
+            return getDatabaseBranch(env, options);
+        const branch = yield (0, environment_1.getGitBranch)();
+        if (!branch)
+            return getDatabaseBranch(defaultBranch, options);
+        // TODO: in the future, call /resolve endpoint
+        // For now, call API to see if the branch exists. If not, use a default value.
+        const details = yield getDatabaseBranch(branch, options);
+        if (details)
+            return details;
+        return getDatabaseBranch(defaultBranch, options);
+    });
+}
+exports.getCurrentBranchDetails = getCurrentBranchDetails;
+function getDatabaseBranch(branch, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const databaseURL = (options === null || options === void 0 ? void 0 : options.databaseURL) || getDatabaseURL();
+        const apiKey = (options === null || options === void 0 ? void 0 : options.apiKey) || getAPIKey();
+        if (!databaseURL)
+            throw new Error('A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely');
+        if (!apiKey)
+            throw new Error('An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely');
+        const [protocol, , host, , database] = databaseURL.split('/');
+        const [workspace] = host.split('.');
+        const dbBranchName = `${database}:${branch}`;
+        try {
+            return yield (0, api_1.getBranchDetails)({
+                apiKey,
+                apiUrl: databaseURL,
+                fetchImpl: (0, fetch_1.getFetchImplementation)(options === null || options === void 0 ? void 0 : options.fetchImpl),
+                workspacesApiUrl: `${protocol}//${host}`,
+                pathParams: {
+                    dbBranchName,
+                    workspace
+                }
+            });
+        }
+        catch (err) {
+            if ((0, lang_1.isObject)(err) && err.status === 404)
+                return null;
+            throw err;
+        }
+    });
+}
+function getBranchByEnvVariable() {
+    for (const name of envBranchNames) {
+        const value = (0, environment_1.getEnvVariable)(name);
+        if (value) {
+            return value;
+        }
+    }
+    try {
+        return XATA_BRANCH;
+    }
+    catch (err) {
+        // Ignore ReferenceError. Only CloudFlare workers set env variables as global variables
+    }
+}
+function getDatabaseURL() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_DATABASE_URL')) !== null && _a !== void 0 ? _a : XATA_DATABASE_URL;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getDatabaseURL = getDatabaseURL;
+function getAPIKey() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_API_KEY')) !== null && _a !== void 0 ? _a : XATA_API_KEY;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getAPIKey = getAPIKey;

package/dist/util/types.d.ts

@@ -21,4 +21,5 @@ declare type Impossible<K extends keyof any> = {
 };
 export declare type Exactly<T, U extends T = T> = U & Impossible<Exclude<keyof U, keyof T>>;
 export declare type SingleOrArray<T> = T | T[];
+export declare type Dictionary<T> = Record<string, T>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "Xata.io SDK for TypeScript and JavaScript",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,5 +23,5 @@
     "url": "https://github.com/xataio/client-ts/issues"
   },
   "homepage": "https://github.com/xataio/client-ts/blob/main/client/README.md",
-  "gitHead": "c817835c55f287286f4d30863e7bcfac0215f8f7"
+  "gitHead": "036d273ce2e938ef4bae72c3727881eefaf30574"
 }

package/dist/schema/config.d.ts

@@ -1,4 +0,0 @@
-import { FetcherExtraProps } from '../api/fetcher';
-export declare function getBranch(fetchProps: Omit<FetcherExtraProps, 'workspacesApiUrl'>): Promise<string | undefined>;
-export declare function getDatabaseUrl(): string | undefined;
-export declare function getAPIKey(): string | undefined;

package/dist/schema/config.js

@@ -1,83 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAPIKey = exports.getDatabaseUrl = exports.getBranch = void 0;
-const api_1 = require("../api");
-const environment_1 = require("../util/environment");
-const lang_1 = require("../util/lang");
-const envBranchNames = [
-    'XATA_BRANCH',
-    'VERCEL_GIT_COMMIT_REF',
-    'CF_PAGES_BRANCH',
-    'BRANCH' // Netlify. Putting it the last one because it is more ambiguous
-];
-function getBranch(fetchProps) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const env = getBranchByEnvVariable();
-        if (env)
-            return env;
-        const branch = yield (0, environment_1.getGitBranch)();
-        if (!branch)
-            return undefined;
-        // TODO: in the future, call /resolve endpoint
-        // For now, call API to see if the branch exists. If not, use a default value.
-        const [protocol, , host, , database] = fetchProps.apiUrl.split('/');
-        const [workspace] = host.split('.');
-        const dbBranchName = `${database}:${branch}`;
-        try {
-            yield (0, api_1.getBranchDetails)(Object.assign(Object.assign({}, fetchProps), { workspacesApiUrl: `${protocol}//${host}`, pathParams: {
-                    dbBranchName,
-                    workspace
-                } }));
-        }
-        catch (err) {
-            if ((0, lang_1.isObject)(err) && err.status === 404)
-                return 'main';
-            throw err;
-        }
-        return branch;
-    });
-}
-exports.getBranch = getBranch;
-function getBranchByEnvVariable() {
-    for (const name of envBranchNames) {
-        const value = (0, environment_1.getEnvVariable)(name);
-        if (value) {
-            return value;
-        }
-    }
-    try {
-        return XATA_BRANCH;
-    }
-    catch (err) {
-        // Ignore ReferenceError. Only CloudFlare workers set env variables as global variables
-    }
-}
-function getDatabaseUrl() {
-    var _a;
-    try {
-        return (_a = (0, environment_1.getEnvVariable)('XATA_DATABASE_URL')) !== null && _a !== void 0 ? _a : XATA_DATABASE_URL;
-    }
-    catch (err) {
-        return undefined;
-    }
-}
-exports.getDatabaseUrl = getDatabaseUrl;
-function getAPIKey() {
-    var _a;
-    try {
-        return (_a = (0, environment_1.getEnvVariable)('XATA_API_KEY')) !== null && _a !== void 0 ? _a : XATA_API_KEY;
-    }
-    catch (err) {
-        return undefined;
-    }
-}
-exports.getAPIKey = getAPIKey;