@xata.io/client 0.7.2 → 0.8.2

package/.eslintrc.cjs

@@ -3,7 +3,7 @@ module.exports = {
   parserOptions: {
     ecmaVersion: 2020,
     sourceType: 'module',
-    project: 'client/tsconfig.json'
+    project: 'packages/client/tsconfig.json'
   },
   rules: {
     '@typescript-eslint/no-explicit-any': 'off',

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @xata.io/client
 
+## 0.8.2
+
+### Patch Changes
+
+- 3d81e7a: Make db model references stable
+
+## 0.8.1
+
+### Patch Changes
+
+- 5110261: Fix execution from the browser
+- aa3d7e7: Allow sending sort as in the API
+- 0047193: Add new plugin system for the SDK
+- 43856a5: Add discriminated union search
+
+## 0.8.0
+
+### Patch Changes
+
+- bde908e: Refactor client builder
+- ea3eef8: Make records returned by the API readonly
+
 ## 0.7.2
 
 ### Patch Changes

package/dist/api/index.d.ts

@@ -1,7 +1,13 @@
+import { XataPlugin, XataPluginOptions } from '../plugins';
+import { XataApiClient } from './client';
 import { operationsByTag } from './components';
 import type * as Responses from './responses';
 import type * as Schemas from './schemas';
 export * from './client';
 export * from './components';
+export type { FetcherExtraProps, FetchImpl } from './fetcher';
 export { operationsByTag as Operations };
 export type { Responses, Schemas };
+export declare class XataApiPlugin implements XataPlugin {
+    build(options: XataPluginOptions): Promise<XataApiClient>;
+}

package/dist/api/index.js

@@ -13,9 +13,28 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+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.Operations = void 0;
+exports.XataApiPlugin = exports.Operations = void 0;
+const client_1 = require("./client");
 const components_1 = require("./components");
 Object.defineProperty(exports, "Operations", { enumerable: true, get: function () { return components_1.operationsByTag; } });
 __exportStar(require("./client"), exports);
 __exportStar(require("./components"), exports);
+class XataApiPlugin {
+    build(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { fetchImpl, apiKey } = yield options.getFetchProps();
+            return new client_1.XataApiClient({ fetch: fetchImpl, apiKey });
+        });
+    }
+}
+exports.XataApiPlugin = XataApiPlugin;

package/dist/client.d.ts

@@ -0,0 +1,27 @@
+import { FetchImpl } from './api/fetcher';
+import { XataPlugin } from './plugins';
+import { SchemaPlugin } from './schema';
+import { BaseData } from './schema/record';
+import { LinkDictionary } from './schema/repository';
+import { SearchPlugin } from './search';
+import { BranchStrategyOption } from './util/branches';
+import { StringKeys } from './util/types';
+export declare type BaseClientOptions = {
+    fetch?: FetchImpl;
+    apiKey?: string;
+    databaseURL?: string;
+    branch?: BranchStrategyOption;
+};
+export declare const buildClient: <Plugins extends Record<string, XataPlugin> = {}>(plugins?: Plugins | undefined) => ClientConstructor<Plugins>;
+export interface ClientConstructor<Plugins extends Record<string, XataPlugin>> {
+    new <Schemas extends Record<string, BaseData>>(options?: Partial<BaseClientOptions>, links?: LinkDictionary): Omit<{
+        db: Awaited<ReturnType<SchemaPlugin<Schemas>['build']>>;
+        search: Awaited<ReturnType<SearchPlugin<Schemas>['build']>>;
+    }, keyof Plugins> & {
+        [Key in StringKeys<NonNullable<Plugins>>]: Awaited<ReturnType<NonNullable<Plugins>[Key]['build']>>;
+    };
+}
+declare const BaseClient_base: ClientConstructor<{}>;
+export declare class BaseClient extends BaseClient_base<Record<string, any>> {
+}
+export {};

package/dist/client.js

@@ -0,0 +1,131 @@
+"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());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = exports.buildClient = void 0;
+const schema_1 = require("./schema");
+const search_1 = require("./search");
+const branches_1 = require("./util/branches");
+const config_1 = require("./util/config");
+const fetch_1 = require("./util/fetch");
+const buildClient = (plugins) => {
+    var _instances, _branch, _parseOptions, _getFetchProps, _evaluateBranch, _a;
+    return _a = class {
+            constructor(options = {}, links) {
+                _instances.add(this);
+                _branch.set(this, void 0);
+                const safeOptions = __classPrivateFieldGet(this, _instances, "m", _parseOptions).call(this, options);
+                const namespaces = Object.assign({ db: new schema_1.SchemaPlugin(links), search: new search_1.SearchPlugin() }, plugins);
+                for (const [key, namespace] of Object.entries(namespaces)) {
+                    if (!namespace)
+                        continue;
+                    const result = namespace.build({ getFetchProps: () => __classPrivateFieldGet(this, _instances, "m", _getFetchProps).call(this, safeOptions) });
+                    if (result instanceof Promise) {
+                        void result.then((namespace) => {
+                            // @ts-ignore
+                            this[key] = namespace;
+                        });
+                    }
+                    else {
+                        // @ts-ignore
+                        this[key] = result;
+                    }
+                }
+            }
+        },
+        _branch = new WeakMap(),
+        _instances = new WeakSet(),
+        _parseOptions = function _parseOptions(options) {
+            const fetch = (0, fetch_1.getFetchImplementation)(options === null || options === void 0 ? void 0 : options.fetch);
+            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 = () => __awaiter(this, void 0, void 0, function* () {
+                return (options === null || options === void 0 ? void 0 : options.branch)
+                    ? yield __classPrivateFieldGet(this, _instances, "m", _evaluateBranch).call(this, options.branch)
+                    : yield (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');
+            }
+            return { fetch, databaseURL, apiKey, branch };
+        },
+        _getFetchProps = function _getFetchProps({ fetch, apiKey, databaseURL, branch }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const branchValue = yield __classPrivateFieldGet(this, _instances, "m", _evaluateBranch).call(this, branch);
+                if (!branchValue)
+                    throw new Error('Unable to resolve branch value');
+                return {
+                    fetchImpl: fetch,
+                    apiKey,
+                    apiUrl: '',
+                    // Instead of using workspace and dbBranch, we inject a probably CNAME'd URL
+                    workspacesApiUrl: (path, params) => {
+                        var _a;
+                        const hasBranch = (_a = params.dbBranchName) !== null && _a !== void 0 ? _a : params.branch;
+                        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch ? `:${branchValue}` : '');
+                        return databaseURL + newPath;
+                    }
+                };
+            });
+        },
+        _evaluateBranch = function _evaluateBranch(param) {
+            var e_1, _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if (__classPrivateFieldGet(this, _branch, "f"))
+                    return __classPrivateFieldGet(this, _branch, "f");
+                if (!param)
+                    return undefined;
+                const strategies = Array.isArray(param) ? [...param] : [param];
+                const evaluateBranch = (strategy) => __awaiter(this, void 0, void 0, function* () {
+                    return (0, branches_1.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, _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; }
+                }
+            });
+        },
+        _a;
+};
+exports.buildClient = buildClient;
+class BaseClient extends (0, exports.buildClient)() {
+}
+exports.BaseClient = BaseClient;

package/dist/index.d.ts

@@ -3,5 +3,8 @@ export declare class XataError extends Error {
     constructor(message: string, status: number);
 }
 export * from './api';
+export * from './plugins';
+export * from './client';
 export * from './schema';
+export * from './search';
 export * from './util/config';

package/dist/index.js

@@ -23,5 +23,8 @@ class XataError extends Error {
 }
 exports.XataError = XataError;
 __exportStar(require("./api"), exports);
+__exportStar(require("./plugins"), exports);
+__exportStar(require("./client"), exports);
 __exportStar(require("./schema"), exports);
+__exportStar(require("./search"), exports);
 __exportStar(require("./util/config"), exports);

package/dist/plugins.d.ts

@@ -0,0 +1,7 @@
+import { FetcherExtraProps } from './api/fetcher';
+export declare abstract class XataPlugin {
+    abstract build(options: XataPluginOptions): unknown | Promise<unknown>;
+}
+export declare type XataPluginOptions = {
+    getFetchProps: () => Promise<FetcherExtraProps>;
+};

package/dist/plugins.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XataPlugin = void 0;
+class XataPlugin {
+}
+exports.XataPlugin = XataPlugin;

package/dist/schema/filters.spec.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const vitest_1 = require("vitest");
 // Single column with implicit is
 const singleColumnWithImplicitIs = { name: 'r2' };
 // Single column with explicit is
@@ -170,6 +172,6 @@ const filterWithInvalidNestedObjectPropertyType = { settings: { plan: 42 } };
 // Filter with invalid property $is type
 // @ts-expect-error
 const filterWithInvalidOperator = { name: { $is: 42 } };
-test('fake test', () => {
+(0, vitest_1.test)('fake test', () => {
     // This is a fake test to make sure that the type definitions in this file are working
 });

package/dist/schema/index.d.ts

@@ -1,7 +1,24 @@
+import { XataPlugin, XataPluginOptions } from '../plugins';
+import { BaseData } from './record';
+import { LinkDictionary, Repository } from './repository';
 export * from './operators';
 export * from './pagination';
 export { Query } from './query';
 export { isIdentifiable, isXataRecord } from './record';
-export type { Identifiable, XataRecord } from './record';
-export { BaseClient, Repository, RestRepository, RestRespositoryFactory } from './repository';
-export type { XataClientOptions } from './repository';
+export type { BaseData, EditableData, Identifiable, XataRecord } from './record';
+export { Repository, RestRepository } from './repository';
+export type { LinkDictionary } from './repository';
+export * from './selection';
+export declare type SchemaDefinition = {
+    table: string;
+    links?: LinkDictionary;
+};
+export declare type SchemaPluginResult<Schemas extends Record<string, BaseData>> = {
+    [Key in keyof Schemas]: Repository<Schemas[Key]>;
+};
+export declare class SchemaPlugin<Schemas extends Record<string, BaseData>> extends XataPlugin {
+    #private;
+    private links?;
+    constructor(links?: LinkDictionary | undefined);
+    build(options: XataPluginOptions): SchemaPluginResult<Schemas>;
+}

package/dist/schema/index.js

@@ -13,8 +13,17 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _SchemaPlugin_tables;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = exports.BaseClient = exports.isXataRecord = exports.isIdentifiable = exports.Query = void 0;
+exports.SchemaPlugin = exports.RestRepository = exports.Repository = exports.isXataRecord = exports.isIdentifiable = exports.Query = void 0;
+const plugins_1 = require("../plugins");
+const lang_1 = require("../util/lang");
+const repository_1 = require("./repository");
 __exportStar(require("./operators"), exports);
 __exportStar(require("./pagination"), exports);
 var query_1 = require("./query");
@@ -22,8 +31,30 @@ Object.defineProperty(exports, "Query", { enumerable: true, get: function () { r
 var record_1 = require("./record");
 Object.defineProperty(exports, "isIdentifiable", { enumerable: true, get: function () { return record_1.isIdentifiable; } });
 Object.defineProperty(exports, "isXataRecord", { enumerable: true, get: function () { return record_1.isXataRecord; } });
-var repository_1 = require("./repository");
-Object.defineProperty(exports, "BaseClient", { enumerable: true, get: function () { return repository_1.BaseClient; } });
-Object.defineProperty(exports, "Repository", { enumerable: true, get: function () { return repository_1.Repository; } });
-Object.defineProperty(exports, "RestRepository", { enumerable: true, get: function () { return repository_1.RestRepository; } });
-Object.defineProperty(exports, "RestRespositoryFactory", { enumerable: true, get: function () { return repository_1.RestRespositoryFactory; } });
+var repository_2 = require("./repository");
+Object.defineProperty(exports, "Repository", { enumerable: true, get: function () { return repository_2.Repository; } });
+Object.defineProperty(exports, "RestRepository", { enumerable: true, get: function () { return repository_2.RestRepository; } });
+__exportStar(require("./selection"), exports);
+class SchemaPlugin extends plugins_1.XataPlugin {
+    constructor(links) {
+        super();
+        this.links = links;
+        _SchemaPlugin_tables.set(this, {});
+    }
+    build(options) {
+        const { getFetchProps } = options;
+        const links = this.links;
+        const db = new Proxy({}, {
+            get: (_target, table) => {
+                if (!(0, lang_1.isString)(table))
+                    throw new Error('Invalid table name');
+                if (!__classPrivateFieldGet(this, _SchemaPlugin_tables, "f")[table])
+                    __classPrivateFieldGet(this, _SchemaPlugin_tables, "f")[table] = new repository_1.RestRepository({ db, getFetchProps, table, links });
+                return __classPrivateFieldGet(this, _SchemaPlugin_tables, "f")[table];
+            }
+        });
+        return db;
+    }
+}
+exports.SchemaPlugin = SchemaPlugin;
+_SchemaPlugin_tables = new WeakMap();

package/dist/schema/record.d.ts

@@ -27,14 +27,14 @@ export interface XataRecord extends Identifiable {
     /**
      * Retrieves a refreshed copy of the current record from the database.
      */
-    read(): Promise<SelectedPick<this, ['*']> | null>;
+    read(): Promise<Readonly<SelectedPick<this, ['*']>> | null>;
     /**
      * Performs a partial update of the current record. On success a new object is
      * returned and the current object is not mutated.
      * @param data The columns and their values that have to be updated.
      * @returns A new record containing the latest values for all the columns of the current record.
      */
-    update(data: Partial<EditableData<Omit<this, keyof XataRecord>>>): Promise<SelectedPick<this, ['*']>>;
+    update(partialUpdate: Partial<EditableData<Omit<this, keyof XataRecord>>>): Promise<Readonly<SelectedPick<this, ['*']>>>;
     /**
      * Performs a deletion of the current record in the database.
      *
@@ -46,14 +46,14 @@ export declare type Link<Record extends XataRecord> = Omit<XataRecord, 'read' |
     /**
      * Retrieves a refreshed copy of the current record from the database.
      */
-    read(): Promise<SelectedPick<Record, ['*']> | null>;
+    read(): Promise<Readonly<SelectedPick<Record, ['*']>> | null>;
     /**
      * Performs a partial update of the current record. On success a new object is
      * returned and the current object is not mutated.
      * @param data The columns and their values that have to be updated.
      * @returns A new record containing the latest values for all the columns of the current record.
      */
-    update(data: Partial<EditableData<Omit<Record, keyof XataRecord>>>): Promise<SelectedPick<Record, ['*']>>;
+    update(partialUpdate: Partial<EditableData<Omit<Record, keyof XataRecord>>>): Promise<Readonly<SelectedPick<Record, ['*']>>>;
 };
 export declare function isIdentifiable(x: any): x is Identifiable & Record<string, unknown>;
 export declare function isXataRecord(x: any): x is XataRecord & Record<string, unknown>;

package/dist/schema/repository.d.ts

@@ -1,5 +1,6 @@
-import { FetchImpl } from '../api/fetcher';
-import { Dictionary, GetArrayInnerType, StringKeys } from '../util/types';
+import { SchemaPluginResult } from '.';
+import { FetcherExtraProps } from '../api/fetcher';
+import { Dictionary } from '../util/types';
 import { Page } from './pagination';
 import { Query } from './query';
 import { BaseData, EditableData, Identifiable, XataRecord } from './record';
@@ -9,53 +10,53 @@ export declare type LinkDictionary = Dictionary<TableLink[]>;
 /**
  * Common interface for performing operations on a table.
  */
-export declare abstract class Repository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, SelectedPick<Record, ['*']>> {
-    abstract create(object: EditableData<Data> & Partial<Identifiable>): Promise<SelectedPick<Record, ['*']>>;
+export declare abstract class Repository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, Readonly<SelectedPick<Record, ['*']>>> {
+    abstract create(object: EditableData<Data> & Partial<Identifiable>): Promise<Readonly<SelectedPick<Record, ['*']>>>;
     /**
      * Creates a single record in the table with a unique id.
      * @param id The unique id.
      * @param object Object containing the column names with their values to be stored in the table.
      * @returns The full persisted record.
      */
-    abstract create(id: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
+    abstract create(id: string, object: EditableData<Data>): Promise<Readonly<SelectedPick<Record, ['*']>>>;
     /**
      * Creates multiple records in the table.
      * @param objects Array of objects with the column names and the values to be stored in the table.
      * @returns Array of the persisted records.
      */
-    abstract create(objects: Array<EditableData<Data> & Partial<Identifiable>>): Promise<SelectedPick<Record, ['*']>[]>;
+    abstract create(objects: Array<EditableData<Data> & Partial<Identifiable>>): Promise<Readonly<SelectedPick<Record, ['*']>>[]>;
     /**
      * Queries a single record from the table given its unique id.
      * @param id The unique id.
      * @returns The persisted record for the given id or null if the record could not be found.
      */
-    abstract read(id: string): Promise<SelectedPick<Record, ['*']> | null>;
+    abstract read(id: string): Promise<Readonly<SelectedPick<Record, ['*']> | null>>;
     /**
      * Partially update a single record.
      * @param object An object with its id and the columns to be updated.
      * @returns The full persisted record.
      */
-    abstract update(object: Partial<EditableData<Data>> & Identifiable): Promise<SelectedPick<Record, ['*']>>;
+    abstract update(object: Partial<EditableData<Data>> & Identifiable): Promise<Readonly<SelectedPick<Record, ['*']>>>;
     /**
      * Partially update a single record given its unique id.
      * @param id The unique id.
      * @param object The column names and their values that have to be updated.
      * @returns The full persisted record.
      */
-    abstract update(id: string, object: Partial<EditableData<Data>>): Promise<SelectedPick<Record, ['*']>>;
+    abstract update(id: string, object: Partial<EditableData<Data>>): Promise<Readonly<SelectedPick<Record, ['*']>>>;
     /**
      * Partially updates multiple records.
      * @param objects An array of objects with their ids and columns to be updated.
      * @returns Array of the persisted records.
      */
-    abstract update(objects: Array<Partial<EditableData<Data>> & Identifiable>): Promise<SelectedPick<Record, ['*']>[]>;
+    abstract update(objects: Array<Partial<EditableData<Data>> & Identifiable>): Promise<Readonly<SelectedPick<Record, ['*']>>[]>;
     /**
      * Creates or updates a single record. If a record exists with the given id,
      * it will be update, otherwise a new record will be created.
      * @param object Object containing the column names with their values to be persisted in the table.
      * @returns The full persisted record.
      */
-    abstract createOrUpdate(object: EditableData<Data> & Identifiable): Promise<SelectedPick<Record, ['*']>>;
+    abstract createOrUpdate(object: EditableData<Data> & Identifiable): Promise<Readonly<SelectedPick<Record, ['*']>>>;
     /**
      * Creates or updates a single record. If a record exists with the given id,
      * it will be update, otherwise a new record will be created.
@@ -63,14 +64,14 @@ export declare abstract class Repository<Data extends BaseData, Record extends X
      * @param object The column names and the values to be persisted.
      * @returns The full persisted record.
      */
-    abstract createOrUpdate(id: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
+    abstract createOrUpdate(id: string, object: EditableData<Data>): Promise<Readonly<SelectedPick<Record, ['*']>>>;
     /**
      * Creates or updates a single record. If a record exists with the given id,
      * it will be update, otherwise a new record will be created.
      * @param objects Array of objects with the column names and the values to be stored in the table.
      * @returns Array of the persisted records.
      */
-    abstract createOrUpdate(objects: Array<EditableData<Data> & Identifiable>): Promise<SelectedPick<Record, ['*']>[]>;
+    abstract createOrUpdate(objects: Array<EditableData<Data> & Identifiable>): Promise<Readonly<SelectedPick<Record, ['*']>>[]>;
     /**
      * Deletes a record given its unique id.
      * @param id The unique id.
@@ -106,9 +107,15 @@ export declare abstract class Repository<Data extends BaseData, Record extends X
     }): 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, ['*']>> {
+export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, SelectedPick<Record, ['*']>> implements Repository<Data, Record> {
     #private;
-    constructor(client: BaseClient<any>, table: string, links?: LinkDictionary);
+    db: SchemaPluginResult<any>;
+    constructor(options: {
+        table: string;
+        links?: LinkDictionary;
+        getFetchProps: () => Promise<FetcherExtraProps>;
+        db: SchemaPluginResult<any>;
+    });
     create(object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     create(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     create(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
@@ -125,41 +132,4 @@ export declare class RestRepository<Data extends BaseData, Record extends XataRe
     }): 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, links?: LinkDictionary): Repository<Data & XataRecord>;
-}
-export declare class RestRespositoryFactory implements RepositoryFactory {
-    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>;
-declare type BranchStrategy = BranchStrategyValue | BranchStrategyBuilder;
-declare type BranchStrategyOption = NonNullable<BranchStrategy | BranchStrategy[]>;
-export declare type XataClientOptions = {
-    /**
-     * Fetch implementation. This option is only required if the runtime does not include a fetch implementation
-     * available in the global scope. If you are running your code on Deno or Cloudflare workers for example,
-     * you won't need to provide a specific fetch implementation. But for most versions of Node.js you'll need
-     * to provide one. Such as cross-fetch, node-fetch or isomorphic-fetch.
-     */
-    fetch?: FetchImpl;
-    databaseURL?: string;
-    branch?: BranchStrategyOption;
-    /**
-     * API key to be used. You can create one in your account settings at https://app.xata.io/settings.
-     */
-    apiKey?: string;
-    repositoryFactory?: RepositoryFactory;
-};
-export declare class BaseClient<D extends Record<string, Repository<any>> = Record<string, Repository<any>>> {
-    options: XataClientOptions;
-    db: D;
-    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

@@ -19,20 +19,11 @@ 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 __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    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_links, _RestRepository_branch, _RestRepository_getFetchProps, _RestRepository_getBranch, _RestRepository_insertRecordWithoutId, _RestRepository_insertRecordWithId, _RestRepository_bulkInsertTableRecords, _RestRepository_updateRecordWithID, _RestRepository_upsertRecordWithID, _RestRepository_deleteRecord, _RestRepository_initObject;
+var _RestRepository_instances, _RestRepository_table, _RestRepository_links, _RestRepository_getFetchProps, _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;
+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("../util/config");
 const pagination_1 = require("./pagination");
 const query_1 = require("./query");
 const record_1 = require("./record");
@@ -44,18 +35,17 @@ class Repository extends query_1.Query {
 }
 exports.Repository = Repository;
 class RestRepository extends query_1.Query {
-    constructor(client, table, links) {
-        super(null, table, {});
+    constructor(options) {
+        var _a;
+        super(null, options.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");
+        _RestRepository_getFetchProps.set(this, void 0);
+        __classPrivateFieldSet(this, _RestRepository_table, options.table, "f");
+        __classPrivateFieldSet(this, _RestRepository_links, (_a = options.links) !== null && _a !== void 0 ? _a : {}, "f");
+        __classPrivateFieldSet(this, _RestRepository_getFetchProps, options.getFetchProps, "f");
+        this.db = options.db;
     }
     create(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -85,7 +75,7 @@ class RestRepository extends query_1.Query {
     // TODO: Add column support: https://github.com/xataio/openapi/issues/139
     read(recordId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").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_instances, "m", _RestRepository_initObject).call(this, __classPrivateFieldGet(this, _RestRepository_table, "f"), response);
@@ -166,7 +156,7 @@ class RestRepository extends query_1.Query {
     }
     search(query, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").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));
         });
@@ -181,7 +171,7 @@ class RestRepository extends query_1.Query {
                 page: data.page,
                 columns: data.columns
             };
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").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_instances, "m", _RestRepository_initObject).call(this, __classPrivateFieldGet(this, _RestRepository_table, "f"), record));
             return new pagination_1.Page(query, meta, records);
@@ -189,60 +179,9 @@ class RestRepository extends query_1.Query {
     }
 }
 exports.RestRepository = RestRepository;
-_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_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');
-        }
-        return {
-            fetchImpl: __classPrivateFieldGet(this, _RestRepository_fetch, "f"),
-            apiKey,
-            apiUrl: '',
-            // Instead of using workspace and dbBranch, we inject a probably CNAME'd URL
-            workspacesApiUrl: (path, params) => {
-                var _a, _b;
-                const baseUrl = (_a = __classPrivateFieldGet(this, _RestRepository_client, "f").options.databaseURL) !== null && _a !== void 0 ? _a : '';
-                const hasBranch = (_b = params.dbBranchName) !== null && _b !== void 0 ? _b : params.branch;
-                const newPath = path.replace(/^\/db\/[^/]+/, hasBranch ? `:${branch}` : '');
-                return baseUrl + newPath;
-            }
-        };
-    });
-}, _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) {
+_RestRepository_table = new WeakMap(), _RestRepository_links = new WeakMap(), _RestRepository_getFetchProps = new WeakMap(), _RestRepository_instances = new WeakSet(), _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);
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").call(this);
         const record = transformObjectLinks(object);
         const response = yield (0, api_1.insertRecord)(Object.assign({ pathParams: {
                 workspace: '{workspaceId}',
@@ -257,7 +196,7 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
     });
 }, _RestRepository_insertRecordWithId = function _RestRepository_insertRecordWithId(recordId, object) {
     return __awaiter(this, void 0, void 0, function* () {
-        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").call(this);
         const record = transformObjectLinks(object);
         const response = yield (0, api_1.insertRecordWithID)(Object.assign({ pathParams: {
                 workspace: '{workspaceId}',
@@ -273,7 +212,7 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
     });
 }, _RestRepository_bulkInsertTableRecords = function _RestRepository_bulkInsertTableRecords(objects) {
     return __awaiter(this, void 0, void 0, function* () {
-        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").call(this);
         const records = objects.map((object) => transformObjectLinks(object));
         const response = yield (0, api_1.bulkInsertTableRecords)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f") }, body: { records } }, fetchProps));
         const finalObjects = yield this.any(...response.recordIDs.map((id) => this.filter('id', id))).getAll();
@@ -284,7 +223,7 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
     });
 }, _RestRepository_updateRecordWithID = function _RestRepository_updateRecordWithID(recordId, object) {
     return __awaiter(this, void 0, void 0, function* () {
-        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").call(this);
         const record = transformObjectLinks(object);
         const response = yield (0, api_1.updateRecordWithID)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId }, body: record }, fetchProps));
         const item = yield this.read(response.id);
@@ -294,7 +233,7 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
     });
 }, _RestRepository_upsertRecordWithID = function _RestRepository_upsertRecordWithID(recordId, object) {
     return __awaiter(this, void 0, void 0, function* () {
-        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").call(this);
         const response = yield (0, api_1.upsertRecordWithID)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId }, body: object }, fetchProps));
         const item = yield this.read(response.id);
         if (!item)
@@ -303,7 +242,7 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
     });
 }, _RestRepository_deleteRecord = function _RestRepository_deleteRecord(recordId) {
     return __awaiter(this, void 0, void 0, function* () {
-        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_getFetchProps, "f").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) {
@@ -317,7 +256,7 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
             result[field] = __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, linkTable, value);
         }
     }
-    const db = __classPrivateFieldGet(this, _RestRepository_client, "f").db;
+    const db = this.db;
     result.read = function () {
         return db[table].read(result['id']);
     };
@@ -333,51 +272,6 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
     Object.freeze(result);
     return result;
 };
-class RestRespositoryFactory {
-    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 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.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');
-    }
-    return Object.assign(Object.assign({}, options), { databaseURL,
-        apiKey,
-        branch });
-}
-class BaseClient {
-    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 });
-        const factory = this.options.repositoryFactory || new RestRespositoryFactory();
-        this.db = new Proxy({}, {
-            get: (_target, prop) => {
-                if (!(0, lang_1.isString)(prop))
-                    throw new Error('Invalid table name');
-                return factory.createRepository(this, prop, links);
-            }
-        });
-    }
-    search(query, options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            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;
-const isBranchStrategyBuilder = (strategy) => {
-    return typeof strategy === 'function';
-};
 const transformObjectLinks = (object) => {
     return Object.entries(object).reduce((acc, [key, value]) => {
         // Ignore internal properties

package/dist/schema/selection.spec.js

@@ -1,6 +1,7 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-floating-promises */
 Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
 //                              SelectableColumn<O>                            //
 // --------------------------------------------------------------------------- //
 const validTeamColumns = [
@@ -198,6 +199,6 @@ function test8(user) {
     user.partner = null;
     user.team = null;
 }
-test('fake test', () => {
+(0, vitest_1.test)('fake test', () => {
     // This is a fake test to make sure that the type definitions in this file are working
 });

package/dist/schema/sorting.d.ts

@@ -1,4 +1,4 @@
-import { SingleOrArray, Values } from '../util/types';
+import { SingleOrArray, StringKeys, Values } from '../util/types';
 import { XataRecord } from './record';
 import { SelectableColumn } from './selection';
 export declare type SortDirection = 'asc' | 'desc';
@@ -6,12 +6,17 @@ export declare type SortFilterExtended<T extends XataRecord> = {
     column: SelectableColumn<T>;
     direction?: SortDirection;
 };
-export declare type SortFilter<T extends XataRecord> = SelectableColumn<T> | SortFilterExtended<T>;
+export declare type SortFilter<T extends XataRecord> = SelectableColumn<T> | SortFilterExtended<T> | SortFilterBase<T>;
+declare type SortFilterBase<T extends XataRecord> = {
+    [Key in StringKeys<T>]: SortDirection;
+};
 export declare type ApiSortFilter<T extends XataRecord> = SingleOrArray<Values<{
-    [key in SelectableColumn<T>]: {
-        [K in key]: SortDirection;
+    [Key in SelectableColumn<T>]: {
+        [K in Key]: SortDirection;
     };
 }>>;
 export declare function isSortFilterString<T extends XataRecord>(value: any): value is SelectableColumn<T>;
+export declare function isSortFilterBase<T extends XataRecord>(filter: SortFilter<T>): filter is SortFilterBase<T>;
 export declare function isSortFilterObject<T extends XataRecord>(filter: SortFilter<T>): filter is SortFilterExtended<T>;
 export declare function buildSortFilter<T extends XataRecord>(filter: SingleOrArray<SortFilter<T>>): ApiSortFilter<T>;
+export {};

package/dist/schema/sorting.js

@@ -1,13 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSortFilter = exports.isSortFilterObject = exports.isSortFilterString = void 0;
+exports.buildSortFilter = exports.isSortFilterObject = exports.isSortFilterBase = exports.isSortFilterString = void 0;
 const lang_1 = require("../util/lang");
 function isSortFilterString(value) {
     return (0, lang_1.isString)(value);
 }
 exports.isSortFilterString = isSortFilterString;
+function isSortFilterBase(filter) {
+    return (0, lang_1.isObject)(filter) && Object.values(filter).every((value) => value === 'asc' || value === 'desc');
+}
+exports.isSortFilterBase = isSortFilterBase;
 function isSortFilterObject(filter) {
-    return (0, lang_1.isObject)(filter) && filter.column !== undefined;
+    return (0, lang_1.isObject)(filter) && !isSortFilterBase(filter) && filter.column !== undefined;
 }
 exports.isSortFilterObject = isSortFilterObject;
 function buildSortFilter(filter) {
@@ -18,6 +22,9 @@ function buildSortFilter(filter) {
     else if (Array.isArray(filter)) {
         return filter.map((item) => buildSortFilter(item));
     }
+    else if (isSortFilterBase(filter)) {
+        return filter;
+    }
     else if (isSortFilterObject(filter)) {
         return { [filter.column]: (_a = filter.direction) !== null && _a !== void 0 ? _a : 'asc' };
     }

package/dist/schema/sorting.spec.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const vitest_1 = require("vitest");
 // Simple sorting
 const simpleSorting = { name: 'asc' };
 // Array of simple sorting
 const arrayOfSimpleSorting = [{ name: 'asc' }, { age: 'desc' }];
-test('fake test', () => {
+(0, vitest_1.test)('fake test', () => {
     // This is a fake test to make sure that the type definitions in this file are working
 });

package/dist/search/index.d.ts

@@ -0,0 +1,34 @@
+import { XataPlugin, XataPluginOptions } from '../plugins';
+import { BaseData, XataRecord } from '../schema/record';
+import { SelectedPick } from '../schema/selection';
+import { GetArrayInnerType, Values } from '../util/types';
+export declare class SearchPlugin<Schemas extends Record<string, BaseData>> extends XataPlugin {
+    #private;
+    build({ getFetchProps }: XataPluginOptions): {
+        all: <Tables extends Extract<keyof Schemas, string>>(query: string, options?: {
+            fuzziness?: number | undefined;
+            tables?: Tables[] | undefined;
+        }) => Promise<Values<{ [Model in Tables]: {
+            table: Model;
+            record: Awaited<SelectedPick<Schemas[Model] & XataRecord & {
+                xata: {
+                    table: string;
+                };
+            }, ["*"]>>;
+        }; }>[]>;
+        byTable: <Tables_1 extends Extract<keyof Schemas, string>>(query: string, options?: {
+            fuzziness?: number | undefined;
+            tables?: Tables_1[] | undefined;
+        }) => Promise<{ [Model_1 in Tables_1]: SelectedPick<Schemas[Model_1] & XataRecord & {
+            xata: {
+                table: string;
+            };
+        }, ["*"]>[]; }>;
+    };
+}
+declare type SearchXataRecord = XataRecord & {
+    xata: {
+        table: string;
+    };
+};
+export {};

package/dist/search/index.js

@@ -0,0 +1,55 @@
+"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());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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 _SearchPlugin_instances, _SearchPlugin_search;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchPlugin = void 0;
+const api_1 = require("../api");
+const plugins_1 = require("../plugins");
+class SearchPlugin extends plugins_1.XataPlugin {
+    constructor() {
+        super(...arguments);
+        _SearchPlugin_instances.add(this);
+    }
+    build({ getFetchProps }) {
+        return {
+            all: (query, options = {}) => __awaiter(this, void 0, void 0, function* () {
+                const records = yield __classPrivateFieldGet(this, _SearchPlugin_instances, "m", _SearchPlugin_search).call(this, query, options, getFetchProps);
+                return records.map((record) => {
+                    const { table = 'orphan' } = record.xata;
+                    return { table, record };
+                });
+            }),
+            byTable: (query, options = {}) => __awaiter(this, void 0, void 0, function* () {
+                const records = yield __classPrivateFieldGet(this, _SearchPlugin_instances, "m", _SearchPlugin_search).call(this, query, options, getFetchProps);
+                return records.reduce((acc, record) => {
+                    var _a;
+                    const { table = 'orphan' } = record.xata;
+                    const items = (_a = acc[table]) !== null && _a !== void 0 ? _a : [];
+                    return Object.assign(Object.assign({}, acc), { [table]: [...items, record] });
+                }, {});
+            })
+        };
+    }
+}
+exports.SearchPlugin = SearchPlugin;
+_SearchPlugin_instances = new WeakSet(), _SearchPlugin_search = function _SearchPlugin_search(query, options, getFetchProps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fetchProps = yield getFetchProps();
+        const { tables, fuzziness } = options !== null && options !== void 0 ? options : {};
+        const { records } = yield (0, api_1.searchBranch)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}' }, body: { tables, query, fuzziness } }, fetchProps));
+        return records;
+    });
+};

package/dist/util/branches.d.ts

@@ -0,0 +1,5 @@
+export declare type BranchStrategyValue = string | undefined | null;
+export declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;
+export declare type BranchStrategy = BranchStrategyValue | BranchStrategyBuilder;
+export declare type BranchStrategyOption = NonNullable<BranchStrategy | BranchStrategy[]>;
+export declare const isBranchStrategyBuilder: (strategy: BranchStrategy) => strategy is BranchStrategyBuilder;

package/dist/util/branches.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBranchStrategyBuilder = void 0;
+const isBranchStrategyBuilder = (strategy) => {
+    return typeof strategy === 'function';
+};
+exports.isBranchStrategyBuilder = isBranchStrategyBuilder;

package/dist/util/types.d.ts

@@ -12,8 +12,8 @@ export declare type RequiredBy<T, K extends keyof T> = T & {
     [P in K]-?: NonNullable<T[P]>;
 };
 export declare type GetArrayInnerType<T extends readonly any[]> = T[number];
-export declare type NonNullableValues<Obj> = {
-    [K in keyof Obj]: NonNullable<Obj[K]>;
+export declare type AllRequired<T> = {
+    [P in keyof T]-?: T[P];
 };
 export declare type KeysOfUnion<T> = T extends T ? keyof T : never;
 declare type Impossible<K extends keyof any> = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.7.2",
+  "version": "0.8.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": "036d273ce2e938ef4bae72c3727881eefaf30574"
+  "gitHead": "af614392d9eac48c72ae01598f11689f409778df"
 }