@xata.io/client 0.0.0-alpha.ve276c32 → 0.0.0-alpha.vea30e82

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/dist/api/client.d.ts

@@ -10,7 +10,7 @@ export interface XataApiClientOptions {
 }
 export declare class XataApiClient {
     #private;
-    constructor(options: XataApiClientOptions);
+    constructor(options?: XataApiClientOptions);
     get user(): UserApi;
     get workspaces(): WorkspaceApi;
     get databases(): DatabaseApi;

package/dist/api/client.js

@@ -18,7 +18,7 @@ const fetch_1 = require("../util/fetch");
 const components_1 = require("./components");
 const providers_1 = require("./providers");
 class XataApiClient {
-    constructor(options) {
+    constructor(options = {}) {
         var _a, _b;
         _XataApiClient_extraProps.set(this, void 0);
         _XataApiClient_namespaces.set(this, {});

package/dist/api/index.d.ts

@@ -1,3 +1,5 @@
+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';
@@ -5,3 +7,6 @@ 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,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/search/index.d.ts

@@ -1,10 +1,10 @@
-import { Namespace, NamespaceBuildOptions } from '../namespace';
+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 SearchNamespace<Schemas extends Record<string, BaseData>> extends Namespace {
+export declare class SearchPlugin<Schemas extends Record<string, BaseData>> extends XataPlugin {
     #private;
-    build({ getFetchProps }: NamespaceBuildOptions): {
+    build({ getFetchProps }: XataPluginOptions): {
         all: <Tables extends Extract<keyof Schemas, string>>(query: string, options?: {
             fuzziness?: number | undefined;
             tables?: Tables[] | undefined;

package/dist/search/index.js

@@ -13,27 +13,27 @@ 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 _SearchNamespace_instances, _SearchNamespace_search;
+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);
-        _SearchNamespace_instances.add(this);
+        _SearchPlugin_instances.add(this);
     }
     build({ getFetchProps }) {
         return {
             all: (query, options = {}) => __awaiter(this, void 0, void 0, function* () {
-                const records = yield __classPrivateFieldGet(this, _SearchNamespace_instances, "m", _SearchNamespace_search).call(this, query, options, getFetchProps);
+                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, _SearchNamespace_instances, "m", _SearchNamespace_search).call(this, query, options, getFetchProps);
+                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;
@@ -44,8 +44,8 @@ class SearchNamespace extends namespace_1.Namespace {
         };
     }
 }
-exports.SearchNamespace = SearchNamespace;
-_SearchNamespace_instances = new WeakSet(), _SearchNamespace_search = function _SearchNamespace_search(query, options, getFetchProps) {
+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 : {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.0.0-alpha.ve276c32",
+  "version": "0.0.0-alpha.vea30e82",
   "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": "e276c32d9a0946b08d4eda5a9d2aa308b76ecac7"
+  "gitHead": "ea30e82a7fa5bbecbdb38b6dac6854cd926c2db1"
 }

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;