@xata.io/client 0.0.0-alpha.vc4283f6 → 0.0.0-alpha.vfb85b8b

package/dist/api/index.d.ts

@@ -1,5 +1,3 @@
-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';
@@ -7,6 +5,3 @@ export * from './client';
 export * from './components';
 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,28 +13,9 @@ 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.XataApiPlugin = exports.Operations = void 0;
-const client_1 = require("./client");
+exports.Operations = void 0;
 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 { XataPlugin } from './plugins';
-import { SchemaPlugin } from './schema';
+import { Namespace } from './namespace';
+import { SchemaNamespace } from './schema';
 import { BaseData } from './schema/record';
 import { LinkDictionary } from './schema/repository';
-import { SearchPlugin } from './search';
+import { SearchNamespace } from './search';
 import { BranchStrategyOption } from './util/branches';
 import { StringKeys } from './util/types';
 export declare type BaseClientOptions = {
@@ -12,16 +12,28 @@ export declare type BaseClientOptions = {
     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']>>;
+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']>;
     };
 }
-declare const BaseClient_base: ClientConstructor<{}>;
-export declare class BaseClient extends BaseClient_base<Record<string, any>> {
+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 {
 }
 export {};

package/dist/client.js

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

package/dist/index.d.ts

@@ -3,7 +3,6 @@ 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,7 +23,6 @@ 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/namespace.d.ts

@@ -0,0 +1,7 @@
+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

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

package/dist/schema/index.d.ts

@@ -1,23 +1,21 @@
-import { XataPlugin, XataPluginOptions } from '../plugins';
+import { Namespace, NamespaceBuildOptions } from '../namespace';
 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 { BaseData, EditableData, Identifiable, XataRecord } from './record';
+export type { 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>> = {
+export declare type SchemaNamespaceResult<Schemas extends Record<string, BaseData>> = {
     [Key in keyof Schemas]: Repository<Schemas[Key]>;
 };
-export declare class SchemaPlugin<Schemas extends Record<string, BaseData>> extends XataPlugin {
+export declare class SchemaNamespace<Schemas extends Record<string, BaseData>> extends Namespace {
     private links?;
     constructor(links?: LinkDictionary | undefined);
-    build(options: XataPluginOptions): SchemaPluginResult<Schemas>;
+    build(options: NamespaceBuildOptions): SchemaNamespaceResult<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.SchemaPlugin = exports.RestRepository = exports.Repository = exports.isXataRecord = exports.isIdentifiable = exports.Query = void 0;
-const plugins_1 = require("../plugins");
+exports.SchemaNamespace = exports.RestRepository = exports.Repository = exports.isXataRecord = exports.isIdentifiable = exports.Query = void 0;
+const namespace_1 = require("../namespace");
 const lang_1 = require("../util/lang");
 const repository_1 = require("./repository");
 __exportStar(require("./operators"), exports);
@@ -28,8 +28,7 @@ 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; } });
-__exportStar(require("./selection"), exports);
-class SchemaPlugin extends plugins_1.XataPlugin {
+class SchemaNamespace extends namespace_1.Namespace {
     constructor(links) {
         super();
         this.links = links;
@@ -37,14 +36,14 @@ class SchemaPlugin extends plugins_1.XataPlugin {
     build(options) {
         const { getFetchProps } = options;
         const links = this.links;
-        const db = new Proxy({}, {
+        const schemaNamespace = new Proxy({}, {
             get: (_target, table) => {
                 if (!(0, lang_1.isString)(table))
                     throw new Error('Invalid table name');
-                return new repository_1.RestRepository({ db, getFetchProps, table, links });
+                return new repository_1.RestRepository({ schemaNamespace, getFetchProps, table, links });
             }
         });
-        return db;
+        return schemaNamespace;
     }
 }
-exports.SchemaPlugin = SchemaPlugin;
+exports.SchemaNamespace = SchemaNamespace;

package/dist/schema/repository.d.ts

@@ -1,4 +1,4 @@
-import { SchemaPluginResult } from '.';
+import { SchemaNamespaceResult } from '.';
 import { FetcherExtraProps } from '../api/fetcher';
 import { Dictionary } from '../util/types';
 import { Page } from './pagination';
@@ -107,14 +107,13 @@ 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, ['*']>> implements Repository<Data, Record> {
+export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, SelectedPick<Record, ['*']>> {
     #private;
-    db: SchemaPluginResult<any>;
     constructor(options: {
         table: string;
         links?: LinkDictionary;
         getFetchProps: () => Promise<FetcherExtraProps>;
-        db: SchemaPluginResult<any>;
+        schemaNamespace: SchemaNamespaceResult<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_insertRecordWithoutId, _RestRepository_insertRecordWithId, _RestRepository_bulkInsertTableRecords, _RestRepository_updateRecordWithID, _RestRepository_upsertRecordWithID, _RestRepository_deleteRecord, _RestRepository_initObject;
+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;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestRepository = exports.Repository = void 0;
 const api_1 = require("../api");
@@ -42,10 +42,11 @@ 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");
-        this.db = options.db;
+        __classPrivateFieldSet(this, _RestRepository_schemaNamespace, options.schemaNamespace, "f");
     }
     create(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -179,7 +180,7 @@ class RestRepository extends query_1.Query {
     }
 }
 exports.RestRepository = RestRepository;
-_RestRepository_table = new WeakMap(), _RestRepository_links = new WeakMap(), _RestRepository_getFetchProps = 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_schemaNamespace = 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);
@@ -256,7 +257,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 = this.db;
+    const db = __classPrivateFieldGet(this, _RestRepository_schemaNamespace, "f");
     result.read = function () {
         return db[table].read(result['id']);
     };

package/dist/schema/sorting.d.ts

@@ -1,4 +1,4 @@
-import { SingleOrArray, StringKeys, Values } from '../util/types';
+import { SingleOrArray, Values } from '../util/types';
 import { XataRecord } from './record';
 import { SelectableColumn } from './selection';
 export declare type SortDirection = 'asc' | 'desc';
@@ -6,17 +6,12 @@ export declare type SortFilterExtended<T extends XataRecord> = {
     column: SelectableColumn<T>;
     direction?: SortDirection;
 };
-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 SortFilter<T extends XataRecord> = SelectableColumn<T> | SortFilterExtended<T>;
 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,17 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSortFilter = exports.isSortFilterObject = exports.isSortFilterBase = exports.isSortFilterString = void 0;
+exports.buildSortFilter = exports.isSortFilterObject = 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) && !isSortFilterBase(filter) && filter.column !== undefined;
+    return (0, lang_1.isObject)(filter) && filter.column !== undefined;
 }
 exports.isSortFilterObject = isSortFilterObject;
 function buildSortFilter(filter) {
@@ -22,9 +18,6 @@ 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,30 +1,16 @@
-import { XataPlugin, XataPluginOptions } from '../plugins';
+import { Namespace, NamespaceBuildOptions } from '../namespace';
 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;
-            };
-        }, ["*"]>[]; }>;
-    };
+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;
+        };
+    }, ["*"]>[]; }>;
 }
 declare type SearchXataRecord = XataRecord & {
     xata: {

package/dist/search/index.js

@@ -8,48 +8,23 @@ 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.SearchPlugin = void 0;
+exports.SearchNamespace = 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);
-    }
+const namespace_1 = require("../namespace");
+class SearchNamespace extends namespace_1.Namespace {
     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] });
-                }, {});
-            })
-        };
+        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] });
+            }, {});
+        });
     }
 }
-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;
-    });
-};
+exports.SearchNamespace = SearchNamespace;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.0.0-alpha.vc4283f6",
+  "version": "0.0.0-alpha.vfb85b8b",
   "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": "c4283f68fb3760f0771661e6b38158947e1b056f"
+  "gitHead": "fb85b8b847299a3fa60b6f347255484ffdc1752c"
 }

package/dist/plugins.d.ts

@@ -1,7 +0,0 @@
-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

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