@xata.io/client 0.8.0 → 0.8.1

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,14 @@
 # @xata.io/client
 
+## 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

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

@@ -1,9 +1,9 @@
 import { FetchImpl } from './api/fetcher';
-import { Namespace } from './namespace';
-import { SchemaNamespace } from './schema';
+import { XataPlugin } from './plugins';
+import { SchemaPlugin } from './schema';
 import { BaseData } from './schema/record';
 import { LinkDictionary } from './schema/repository';
-import { SearchNamespace } from './search';
+import { SearchPlugin } from './search';
 import { BranchStrategyOption } from './util/branches';
 import { StringKeys } from './util/types';
 export declare type BaseClientOptions = {
@@ -12,28 +12,16 @@ export declare type BaseClientOptions = {
     databaseURL?: string;
     branch?: BranchStrategyOption;
 };
-export declare const buildClientWithNamespaces: <ExternalNamespaces extends Record<string, Namespace>>(namespaces: ExternalNamespaces) => <Schemas extends Record<string, BaseData>>() => WrapperConstructor<Schemas, {
-    db: SchemaNamespace<Schemas>;
-    search: SearchNamespace<Schemas>;
-}, ExternalNamespaces>;
-export declare const buildClient: <Schemas extends Record<string, BaseData>, ExternalNamespaces extends Record<string, Namespace> = {}, Namespaces extends Record<string, Namespace> = {
-    db: SchemaNamespace<Schemas>;
-    search: SearchNamespace<Schemas>;
-}>(external?: ExternalNamespaces | undefined) => WrapperConstructor<Schemas, Namespaces, ExternalNamespaces>;
-export interface WrapperConstructor<Schemas extends Record<string, BaseData> = Record<string, any>, Namespaces extends Record<string, Namespace> = {
-    db: SchemaNamespace<Schemas>;
-    search: SearchNamespace<Schemas>;
-}, ExternalNamespaces extends Record<string, Namespace> = Record<string, Namespace>> {
-    new (options?: Partial<BaseClientOptions>, links?: LinkDictionary): {
-        [Key in StringKeys<Namespaces>]: ReturnType<Namespaces[Key]['build']>;
-    } & {
-        [Key in StringKeys<NonNullable<ExternalNamespaces>>]: ReturnType<NonNullable<ExternalNamespaces>[Key]['build']>;
+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: WrapperConstructor<Record<string, any>, {
-    db: SchemaNamespace<Record<string, any>>;
-    search: SearchNamespace<Record<string, any>>;
-}, {}>;
-export declare class BaseClient extends BaseClient_base {
+declare const BaseClient_base: ClientConstructor<{}>;
+export declare class BaseClient extends BaseClient_base<Record<string, any>> {
 }
 export {};

package/dist/client.js

@@ -27,27 +27,34 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     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 = exports.buildClientWithNamespaces = void 0;
+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 buildClientWithNamespaces = (namespaces) => () => (0, exports.buildClient)(namespaces);
-exports.buildClientWithNamespaces = buildClientWithNamespaces;
-const buildClient = (external) => {
+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.SchemaNamespace(links), search: new search_1.SearchNamespace() }, external);
+                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;
-                    // @ts-ignore
-                    this[key] = namespace.build({ getFetchProps: () => __classPrivateFieldGet(this, _instances, "m", _getFetchProps).call(this, safeOptions) });
+                    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;
+                    }
                 }
             }
         },

package/dist/index.d.ts

@@ -3,6 +3,7 @@ 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';

package/dist/index.js

@@ -23,6 +23,7 @@ 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);

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/index.d.ts

@@ -1,21 +1,23 @@
-import { Namespace, NamespaceBuildOptions } from '../namespace';
+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 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 SchemaNamespaceResult<Schemas extends Record<string, BaseData>> = {
+export declare type SchemaPluginResult<Schemas extends Record<string, BaseData>> = {
     [Key in keyof Schemas]: Repository<Schemas[Key]>;
 };
-export declare class SchemaNamespace<Schemas extends Record<string, BaseData>> extends Namespace {
+export declare class SchemaPlugin<Schemas extends Record<string, BaseData>> extends XataPlugin {
     private links?;
     constructor(links?: LinkDictionary | undefined);
-    build(options: NamespaceBuildOptions): SchemaNamespaceResult<Schemas>;
+    build(options: XataPluginOptions): SchemaPluginResult<Schemas>;
 }

package/dist/schema/index.js

@@ -14,8 +14,8 @@ 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);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaNamespace = exports.RestRepository = exports.Repository = exports.isXataRecord = exports.isIdentifiable = exports.Query = void 0;
-const namespace_1 = require("../namespace");
+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);
@@ -28,7 +28,8 @@ Object.defineProperty(exports, "isXataRecord", { enumerable: true, get: function
 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; } });
-class SchemaNamespace extends namespace_1.Namespace {
+__exportStar(require("./selection"), exports);
+class SchemaPlugin extends plugins_1.XataPlugin {
     constructor(links) {
         super();
         this.links = links;
@@ -36,14 +37,14 @@ class SchemaNamespace extends namespace_1.Namespace {
     build(options) {
         const { getFetchProps } = options;
         const links = this.links;
-        const schemaNamespace = new Proxy({}, {
+        const db = new Proxy({}, {
             get: (_target, table) => {
                 if (!(0, lang_1.isString)(table))
                     throw new Error('Invalid table name');
-                return new repository_1.RestRepository({ schemaNamespace, getFetchProps, table, links });
+                return new repository_1.RestRepository({ db, getFetchProps, table, links });
             }
         });
-        return schemaNamespace;
+        return db;
     }
 }
-exports.SchemaNamespace = SchemaNamespace;
+exports.SchemaPlugin = SchemaPlugin;

package/dist/schema/repository.d.ts

@@ -1,4 +1,4 @@
-import { SchemaNamespaceResult } from '.';
+import { SchemaPluginResult } from '.';
 import { FetcherExtraProps } from '../api/fetcher';
 import { Dictionary } from '../util/types';
 import { Page } from './pagination';
@@ -107,13 +107,14 @@ 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;
+    db: SchemaPluginResult<any>;
     constructor(options: {
         table: string;
         links?: LinkDictionary;
         getFetchProps: () => Promise<FetcherExtraProps>;
-        schemaNamespace: SchemaNamespaceResult<any>;
+        db: SchemaPluginResult<any>;
     });
     create(object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     create(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;

package/dist/schema/repository.js

@@ -19,7 +19,7 @@ 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 _RestRepository_instances, _RestRepository_table, _RestRepository_links, _RestRepository_getFetchProps, _RestRepository_schemaNamespace, _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.RestRepository = exports.Repository = void 0;
 const api_1 = require("../api");
@@ -42,11 +42,10 @@ class RestRepository extends query_1.Query {
         _RestRepository_table.set(this, void 0);
         _RestRepository_links.set(this, void 0);
         _RestRepository_getFetchProps.set(this, void 0);
-        _RestRepository_schemaNamespace.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");
-        __classPrivateFieldSet(this, _RestRepository_schemaNamespace, options.schemaNamespace, "f");
+        this.db = options.db;
     }
     create(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -180,7 +179,7 @@ class RestRepository extends query_1.Query {
     }
 }
 exports.RestRepository = RestRepository;
-_RestRepository_table = new WeakMap(), _RestRepository_links = new WeakMap(), _RestRepository_getFetchProps = new WeakMap(), _RestRepository_schemaNamespace = new WeakMap(), _RestRepository_instances = new WeakSet(), _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_getFetchProps, "f").call(this);
         const record = transformObjectLinks(object);
@@ -257,7 +256,7 @@ _RestRepository_table = new WeakMap(), _RestRepository_links = new WeakMap(), _R
             result[field] = __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, linkTable, value);
         }
     }
-    const db = __classPrivateFieldGet(this, _RestRepository_schemaNamespace, "f");
+    const db = this.db;
     result.read = function () {
         return db[table].read(result['id']);
     };

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/search/index.d.ts

@@ -1,16 +1,30 @@
-import { Namespace, NamespaceBuildOptions } from '../namespace';
+import { XataPlugin, XataPluginOptions } from '../plugins';
 import { BaseData, XataRecord } from '../schema/record';
 import { SelectedPick } from '../schema/selection';
-import { GetArrayInnerType } from '../util/types';
-export declare class SearchNamespace<Schemas extends Record<string, BaseData>> extends Namespace {
-    build({ getFetchProps }: NamespaceBuildOptions): <Tables extends Extract<keyof Schemas, string>>(query: string, options?: {
-        fuzziness?: number | undefined;
-        tables?: Tables[] | undefined;
-    } | undefined) => Promise<{ [Model in Tables]: SelectedPick<Schemas[Model] & XataRecord & {
-        xata: {
-            table: string;
-        };
-    }, ["*"]>[]; }>;
+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: {

package/dist/search/index.js

@@ -8,23 +8,48 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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.SearchNamespace = void 0;
+exports.SearchPlugin = void 0;
 const api_1 = require("../api");
-const namespace_1 = require("../namespace");
-class SearchNamespace extends namespace_1.Namespace {
+const plugins_1 = require("../plugins");
+class SearchPlugin extends plugins_1.XataPlugin {
+    constructor() {
+        super(...arguments);
+        _SearchPlugin_instances.add(this);
+    }
     build({ getFetchProps }) {
-        return (query, options) => __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.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] });
-            }, {});
-        });
+        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.SearchNamespace = SearchNamespace;
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "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": "ca9389ac662985428e3714be546cbf9d3bc5c4b6"
+  "gitHead": "e0277aa65a86bd878e236c28677bab8aeff9a051"
 }

package/dist/namespace.d.ts

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

package/dist/namespace.js

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