@xata.io/client 0.0.0-beta.f46df88 → 0.0.0-beta.f65b504

package/dist/schema/repository.d.ts

@@ -1,40 +1,62 @@
-import { FetchImpl } from '../api/fetcher';
+import { SchemaNamespaceResult } 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';
 import { SelectedPick } from './selection';
-export declare type Links = Record<string, Array<string[]>>;
+declare type TableLink = string[];
+export declare type LinkDictionary = Dictionary<TableLink[]>;
 /**
  * Common interface for performing operations on a table.
  */
-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 createMany(objects: EditableData<Data>[]): 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<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 updatd.
+     * @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<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<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.
@@ -42,59 +64,71 @@ 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<Readonly<SelectedPick<Record, ['*']>>[]>;
     /**
      * Deletes a record given its unique id.
      * @param id The unique id.
      * @throws If the record could not be found or there was an error while performing the deletion.
      */
-    abstract delete(id: string): void;
+    abstract delete(id: string): Promise<void>;
+    /**
+     * Deletes a record given its unique id.
+     * @param id An object with a unique id.
+     * @throws If the record could not be found or there was an error while performing the deletion.
+     */
+    abstract delete(id: Identifiable): Promise<void>;
+    /**
+     * Deletes a record given a list of unique ids.
+     * @param ids The array of unique ids.
+     * @throws If the record could not be found or there was an error while performing the deletion.
+     */
+    abstract delete(ids: string[]): Promise<void>;
+    /**
+     * Deletes a record given a list of unique ids.
+     * @param ids An array of objects with unique ids.
+     * @throws If the record could not be found or there was an error while performing the deletion.
+     */
+    abstract delete(ids: Identifiable[]): Promise<void>;
+    /**
+     * Search for records in the table.
+     * @param query The query to search for.
+     * @param options The options to search with (like: fuzziness)
+     * @returns The found records.
+     */
+    abstract search(query: string, options?: {
+        fuzziness?: number;
+    }): Promise<SelectedPick<Record, ['*']>[]>;
     abstract query<Result extends XataRecord>(query: Query<Record, Result>): Promise<Page<Record, Result>>;
 }
 export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, SelectedPick<Record, ['*']>> {
     #private;
-    constructor(client: BaseClient<any>, table: string);
+    constructor(options: {
+        table: string;
+        links?: LinkDictionary;
+        getFetchProps: () => Promise<FetcherExtraProps>;
+        schemaNamespace: SchemaNamespaceResult<any>;
+    });
     create(object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     create(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
-    createMany(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
+    create(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
     read(recordId: string): Promise<SelectedPick<Record, ['*']> | null>;
+    update(object: Partial<EditableData<Data>> & Identifiable): Promise<SelectedPick<Record, ['*']>>;
     update(recordId: string, object: Partial<EditableData<Data>>): Promise<SelectedPick<Record, ['*']>>;
+    update(objects: Array<Partial<EditableData<Data>> & Identifiable>): Promise<SelectedPick<Record, ['*']>[]>;
+    createOrUpdate(object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     createOrUpdate(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
-    delete(recordId: string): Promise<void>;
+    createOrUpdate(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
+    delete(recordId: string | Identifiable | Array<string | Identifiable>): Promise<void>;
+    search(query: string, options?: {
+        fuzziness?: number;
+    }): Promise<SelectedPick<Record, ['*']>[]>;
     query<Result extends XataRecord>(query: Query<Record, Result>): Promise<Page<Record, Result>>;
 }
-interface RepositoryFactory {
-    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data & XataRecord>;
-}
-export declare class RestRespositoryFactory implements RepositoryFactory {
-    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): 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>>> {
-    #private;
-    options: XataClientOptions;
-    db: D;
-    constructor(options: XataClientOptions, links?: Links);
-    initObject<T>(table: string, object: object): T;
-    getBranch(): Promise<string>;
-}
 export {};

package/dist/schema/repository.js

@@ -19,22 +19,15 @@ 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_getFetchProps, _RestRepository_insertRecordWithoutId, _RestRepository_insertRecordWithId, _BaseClient_links, _BaseClient_branch;
+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.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = void 0;
+exports.RestRepository = exports.Repository = void 0;
 const api_1 = require("../api");
 const lang_1 = require("../util/lang");
-const filters_1 = require("./filters");
 const pagination_1 = require("./pagination");
 const query_1 = require("./query");
 const record_1 = require("./record");
+const sorting_1 = require("./sorting");
 /**
  * Common interface for performing operations on a table.
  */
@@ -42,89 +35,131 @@ class Repository extends query_1.Query {
 }
 exports.Repository = Repository;
 class RestRepository extends query_1.Query {
-    constructor(client, table) {
+    constructor(options) {
         var _a;
-        super(null, table, {});
+        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);
-        __classPrivateFieldSet(this, _RestRepository_client, client, "f");
-        __classPrivateFieldSet(this, _RestRepository_table, table, "f");
-        // TODO: Remove when integrating with API client
-        const globalFetch = typeof fetch !== 'undefined' ? fetch : undefined;
-        const fetchImpl = (_a = __classPrivateFieldGet(this, _RestRepository_client, "f").options.fetch) !== null && _a !== void 0 ? _a : globalFetch;
-        if (!fetchImpl) {
-            /** @todo add a link after docs exist */
-            throw new Error(`The \`fetch\` option passed to the Xata client is resolving to a falsy value and may not be correctly imported.`);
-        }
-        __classPrivateFieldSet(this, _RestRepository_fetch, fetchImpl, "f");
+        _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");
     }
     create(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Create many records
+            if (Array.isArray(a)) {
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_bulkInsertTableRecords).call(this, a);
+            }
+            // Create one record with id as param
             if ((0, lang_1.isString)(a) && (0, lang_1.isObject)(b)) {
                 if (a === '')
                     throw new Error("The id can't be empty");
                 return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_insertRecordWithId).call(this, a, b);
             }
-            else if ((0, lang_1.isObject)(a) && (0, lang_1.isString)(a.id)) {
+            // Create one record with id as property
+            if ((0, lang_1.isObject)(a) && (0, lang_1.isString)(a.id)) {
                 if (a.id === '')
                     throw new Error("The id can't be empty");
                 return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_insertRecordWithId).call(this, a.id, Object.assign(Object.assign({}, a), { id: undefined }));
             }
-            else if ((0, lang_1.isObject)(a)) {
+            // Create one record without id
+            if ((0, lang_1.isObject)(a)) {
                 return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_insertRecordWithoutId).call(this, a);
             }
-            else {
-                throw new Error('Invalid arguments for create method');
-            }
+            throw new Error('Invalid arguments for create method');
         });
     }
-    createMany(objects) {
+    // 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 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();
-            if (finalObjects.length !== objects.length) {
-                throw new Error('The server failed to save some records');
+            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);
+            }
+            catch (e) {
+                if ((0, lang_1.isObject)(e) && e.status === 404) {
+                    return null;
+                }
+                throw e;
             }
-            return finalObjects;
         });
     }
-    // TODO: Add column support: https://github.com/xataio/openapi/issues/139
-    read(recordId) {
+    update(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
-            const response = yield (0, api_1.getRecord)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId } }, fetchProps));
-            return __classPrivateFieldGet(this, _RestRepository_client, "f").initObject(__classPrivateFieldGet(this, _RestRepository_table, "f"), response);
+            // Update many records
+            if (Array.isArray(a)) {
+                if (a.length > 100) {
+                    // TODO: Implement bulk update when API has support for it
+                    console.warn('Bulk update operation is not optimized in the Xata API yet, this request might be slow');
+                }
+                return Promise.all(a.map((object) => this.update(object)));
+            }
+            // Update one record with id as param
+            if ((0, lang_1.isString)(a) && (0, lang_1.isObject)(b)) {
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_updateRecordWithID).call(this, a, b);
+            }
+            // Update one record with id as property
+            if ((0, lang_1.isObject)(a) && (0, lang_1.isString)(a.id)) {
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_updateRecordWithID).call(this, a.id, Object.assign(Object.assign({}, a), { id: undefined }));
+            }
+            throw new Error('Invalid arguments for update method');
         });
     }
-    update(recordId, object) {
+    createOrUpdate(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).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);
-            if (!item)
-                throw new Error('The server failed to save the record');
-            return item;
+            // Create or update many records
+            if (Array.isArray(a)) {
+                if (a.length > 100) {
+                    // TODO: Implement bulk update when API has support for it
+                    console.warn('Bulk update operation is not optimized in the Xata API yet, this request might be slow');
+                }
+                return Promise.all(a.map((object) => this.createOrUpdate(object)));
+            }
+            // Create or update one record with id as param
+            if ((0, lang_1.isString)(a) && (0, lang_1.isObject)(b)) {
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_upsertRecordWithID).call(this, a, b);
+            }
+            // Create or update one record with id as property
+            if ((0, lang_1.isObject)(a) && (0, lang_1.isString)(a.id)) {
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_upsertRecordWithID).call(this, a.id, Object.assign(Object.assign({}, a), { id: undefined }));
+            }
+            throw new Error('Invalid arguments for createOrUpdate method');
         });
     }
-    createOrUpdate(recordId, object) {
+    delete(recordId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).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)
-                throw new Error('The server failed to save the record');
-            return item;
+            // Delete many records
+            if (Array.isArray(recordId)) {
+                if (recordId.length > 100) {
+                    // TODO: Implement bulk delete when API has support for it
+                    console.warn('Bulk delete operation is not optimized in the Xata API yet, this request might be slow');
+                }
+                yield Promise.all(recordId.map((id) => this.delete(id)));
+                return;
+            }
+            // Delete one record with id as param
+            if ((0, lang_1.isString)(recordId)) {
+                yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_deleteRecord).call(this, recordId);
+                return;
+            }
+            // Delete one record with id as property
+            if ((0, lang_1.isObject)(recordId) && (0, lang_1.isString)(recordId.id)) {
+                yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_deleteRecord).call(this, recordId.id);
+                return;
+            }
+            throw new Error('Invalid arguments for delete method');
         });
     }
-    delete(recordId) {
+    search(query, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
-            yield (0, api_1.deleteRecord)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId } }, fetchProps));
+            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));
         });
     }
     query(query) {
@@ -133,38 +168,21 @@ class RestRepository extends query_1.Query {
             const data = query.getQueryOptions();
             const body = {
                 filter: Object.values((_a = data.filter) !== null && _a !== void 0 ? _a : {}).some(Boolean) ? data.filter : undefined,
-                sort: (0, filters_1.buildSortFilter)(data.sort),
+                sort: data.sort ? (0, sorting_1.buildSortFilter)(data.sort) : undefined,
                 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_client, "f").initObject(__classPrivateFieldGet(this, _RestRepository_table, "f"), record));
+            const records = objects.map((record) => __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, __classPrivateFieldGet(this, _RestRepository_table, "f"), record));
             return new pagination_1.Page(query, meta, records);
         });
     }
 }
 exports.RestRepository = RestRepository;
-_RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _RestRepository_table = new WeakMap(), _RestRepository_instances = new WeakSet(), _RestRepository_getFetchProps = function _RestRepository_getFetchProps() {
+_RestRepository_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 branch = yield __classPrivateFieldGet(this, _RestRepository_client, "f").getBranch();
-        return {
-            fetchImpl: __classPrivateFieldGet(this, _RestRepository_fetch, "f"),
-            apiKey: __classPrivateFieldGet(this, _RestRepository_client, "f").options.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_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}',
@@ -179,7 +197,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}',
@@ -193,96 +211,74 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
         }
         return finalObject;
     });
-};
-class RestRespositoryFactory {
-    createRepository(client, table) {
-        return new RestRepository(client, table);
-    }
-}
-exports.RestRespositoryFactory = RestRespositoryFactory;
-class BaseClient {
-    constructor(options, links = {}) {
-        _BaseClient_links.set(this, void 0);
-        _BaseClient_branch.set(this, void 0);
-        if (!options.databaseURL || !options.apiKey || !options.branch) {
-            throw new Error('Options databaseURL, apiKey and branch are required');
-        }
-        this.options = options;
-        __classPrivateFieldSet(this, _BaseClient_links, links, "f");
-        const factory = options.repositoryFactory || new RestRespositoryFactory();
-        this.db = new Proxy({}, {
-            get: (_target, prop) => {
-                if (typeof prop !== 'string')
-                    throw new Error('Invalid table name');
-                return factory.createRepository(this, prop);
-            }
-        });
-    }
-    initObject(table, object) {
-        const result = {};
-        Object.assign(result, object);
-        const tableLinks = __classPrivateFieldGet(this, _BaseClient_links, "f")[table] || [];
-        for (const link of tableLinks) {
-            const [field, linkTable] = link;
-            const value = result[field];
-            if (value && (0, lang_1.isObject)(value)) {
-                result[field] = this.initObject(linkTable, value);
-            }
+}, _RestRepository_bulkInsertTableRecords = function _RestRepository_bulkInsertTableRecords(objects) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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();
+        if (finalObjects.length !== objects.length) {
+            throw new Error('The server failed to save some records');
         }
-        const db = this.db;
-        result.read = function () {
-            return db[table].read(result['id']);
-        };
-        result.update = function (data) {
-            return db[table].update(result['id'], data);
-        };
-        result.delete = function () {
-            return db[table].delete(result['id']);
-        };
-        for (const prop of ['read', 'update', 'delete']) {
-            Object.defineProperty(result, prop, { enumerable: false });
+        return finalObjects;
+    });
+}, _RestRepository_updateRecordWithID = function _RestRepository_updateRecordWithID(recordId, object) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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);
+        if (!item)
+            throw new Error('The server failed to save the record');
+        return item;
+    });
+}, _RestRepository_upsertRecordWithID = function _RestRepository_upsertRecordWithID(recordId, object) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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)
+            throw new Error('The server failed to save the record');
+        return item;
+    });
+}, _RestRepository_deleteRecord = function _RestRepository_deleteRecord(recordId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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) {
+    const result = {};
+    Object.assign(result, object);
+    const tableLinks = __classPrivateFieldGet(this, _RestRepository_links, "f")[table] || [];
+    for (const link of tableLinks) {
+        const [field, linkTable] = link;
+        const value = result[field];
+        if (value && (0, lang_1.isObject)(value)) {
+            result[field] = __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_initObject).call(this, linkTable, value);
         }
-        Object.freeze(result);
-        return result;
     }
-    getBranch() {
-        var e_1, _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (__classPrivateFieldGet(this, _BaseClient_branch, "f"))
-                return __classPrivateFieldGet(this, _BaseClient_branch, "f");
-            const { branch: param } = this.options;
-            const strategies = Array.isArray(param) ? [...param] : [param];
-            const evaluateBranch = (strategy) => __awaiter(this, void 0, void 0, function* () {
-                return isBranchStrategyBuilder(strategy) ? yield strategy() : strategy;
-            });
-            try {
-                for (var strategies_1 = __asyncValues(strategies), strategies_1_1; strategies_1_1 = yield strategies_1.next(), !strategies_1_1.done;) {
-                    const strategy = strategies_1_1.value;
-                    const branch = yield evaluateBranch(strategy);
-                    if (branch) {
-                        __classPrivateFieldSet(this, _BaseClient_branch, branch, "f");
-                        return branch;
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (strategies_1_1 && !strategies_1_1.done && (_a = strategies_1.return)) yield _a.call(strategies_1);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            throw new Error('Unable to resolve branch value');
-        });
+    const db = __classPrivateFieldGet(this, _RestRepository_schemaNamespace, "f");
+    result.read = function () {
+        return db[table].read(result['id']);
+    };
+    result.update = function (data) {
+        return db[table].update(result['id'], data);
+    };
+    result.delete = function () {
+        return db[table].delete(result['id']);
+    };
+    for (const prop of ['read', 'update', 'delete']) {
+        Object.defineProperty(result, prop, { enumerable: false });
     }
-}
-exports.BaseClient = BaseClient;
-_BaseClient_links = new WeakMap(), _BaseClient_branch = new WeakMap();
-const isBranchStrategyBuilder = (strategy) => {
-    return typeof strategy === 'function';
+    Object.freeze(result);
+    return result;
 };
 const transformObjectLinks = (object) => {
     return Object.entries(object).reduce((acc, [key, value]) => {
+        // Ignore internal properties
+        if (key === 'xata')
+            return acc;
+        // Transform links to identifier
         return Object.assign(Object.assign({}, acc), { [key]: (0, record_1.isIdentifiable)(value) ? value.id : value });
     }, {});
 };

package/dist/schema/selection.d.ts

@@ -4,7 +4,7 @@ export declare type SelectableColumn<O, RecursivePath extends any[] = []> = '*'
 export declare type SelectedPick<O extends XataRecord, Key extends SelectableColumn<O>[]> = XataRecord & UnionToIntersection<Values<{
     [K in Key[number]]: NestedValueAtColumn<O, K> & XataRecord;
 }>>;
-export declare type ValueAtColumn<O extends XataRecord, P extends SelectableColumn<O>> = P extends '*' ? Values<O> : P extends 'id' ? string : P extends keyof O ? O[P] : P extends `${infer K}.${infer V}` ? K extends keyof O ? Values<O[K] extends XataRecord ? (V extends SelectableColumn<O[K]> ? {
+export declare type ValueAtColumn<O, P extends SelectableColumn<O>> = P extends '*' ? Values<O> : P extends 'id' ? string : P extends keyof O ? O[P] : P extends `${infer K}.${infer V}` ? K extends keyof O ? Values<O[K] extends XataRecord ? (V extends SelectableColumn<O[K]> ? {
     V: ValueAtColumn<O[K], V>;
 } : never) : O[K]> : never : never;
 declare type MAX_RECURSION = 5;
@@ -15,10 +15,11 @@ declare type NestedColumns<O, RecursivePath extends any[]> = RecursivePath['leng
 }>, never>;
 declare type DataProps<O> = Exclude<StringKeys<O>, StringKeys<XataRecord>>;
 declare type NestedValueAtColumn<O, Key extends SelectableColumn<O>> = Key extends `${infer N}.${infer M}` ? N extends DataProps<O> ? {
-    [K in N]: M extends SelectableColumn<NonNullable<O[K]>> ? NestedValueAtColumn<NonNullable<O[K]>, M> & XataRecord : unknown;
+    [K in N]: M extends SelectableColumn<NonNullable<O[K]>> ? NonNullable<O[K]> extends XataRecord ? ForwardNullable<O[K], NestedValueAtColumn<NonNullable<O[K]>, M> & XataRecord> : ForwardNullable<O[K], NestedValueAtColumn<NonNullable<O[K]>, M>> : unknown;
 } : unknown : Key extends DataProps<O> ? {
-    [K in Key]: NonNullable<O[K]> extends XataRecord ? SelectedPick<NonNullable<O[K]>, ['*']> : O[K];
+    [K in Key]: NonNullable<O[K]> extends XataRecord ? ForwardNullable<O[K], SelectedPick<NonNullable<O[K]>, ['*']>> : O[K];
 } : Key extends '*' ? {
-    [K in keyof NonNullable<O>]: NonNullable<NonNullable<O>[K]> extends XataRecord ? NonNullable<O>[K] extends XataRecord ? Link<NonNullable<O>[K]> : Link<NonNullable<NonNullable<O>[K]>> | null : NonNullable<O>[K];
+    [K in StringKeys<O>]: NonNullable<O[K]> extends XataRecord ? ForwardNullable<O[K], Link<NonNullable<O[K]>>> : O[K];
 } : unknown;
+declare type ForwardNullable<T, R> = T extends NonNullable<T> ? R : R | null;
 export {};