@xata.io/client 0.1.5 → 0.4.0

package/dist/schema/repository.js

@@ -0,0 +1,280 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __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 __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, _BaseClient_links, _BaseClient_branch;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = void 0;
+const api_1 = require("../api");
+const filters_1 = require("./filters");
+const pagination_1 = require("./pagination");
+const query_1 = require("./query");
+/**
+ * Common interface for performing operations on a table.
+ */
+class Repository extends query_1.Query {
+}
+exports.Repository = Repository;
+class RestRepository extends Repository {
+    constructor(client, table) {
+        super(null, 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 fetchImpl = typeof fetch !== 'undefined' ? fetch : __classPrivateFieldGet(this, _RestRepository_client, "f").options.fetch;
+        if (!fetchImpl) {
+            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");
+    }
+    create(object) {
+        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.insertRecord)(Object.assign({ pathParams: {
+                    workspace: '{workspaceId}',
+                    dbBranchName: '{dbBranch}',
+                    tableName: __classPrivateFieldGet(this, _RestRepository_table, "f")
+                }, body: record }, fetchProps));
+            const finalObject = yield this.read(response.id);
+            if (!finalObject) {
+                throw new Error('The server failed to save the record');
+            }
+            return finalObject;
+        });
+    }
+    createMany(objects) {
+        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');
+            }
+            return finalObjects;
+        });
+    }
+    read(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.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(recordId, object) {
+        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.updateRecordWithID)(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;
+        });
+    }
+    insert(recordId, object) {
+        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.insertRecordWithID)(Object.assign({ pathParams: {
+                    workspace: '{workspaceId}',
+                    dbBranchName: '{dbBranch}',
+                    tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"),
+                    recordId
+                }, body: record }, fetchProps));
+            const finalObject = yield this.read(response.id);
+            if (!finalObject) {
+                throw new Error('The server failed to save the record');
+            }
+            return finalObject;
+        });
+    }
+    updateOrInsert(recordId, object) {
+        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(recordId) {
+        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));
+        });
+    }
+    query(query, options = {}) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = query.getQueryOptions();
+            const body = {
+                filter: Object.values(data.filter).some(Boolean) ? data.filter : undefined,
+                sort: (_a = (0, filters_1.buildSortFilter)(options === null || options === void 0 ? void 0 : options.sort)) !== null && _a !== void 0 ? _a : data.sort,
+                page: (_b = options === null || options === void 0 ? void 0 : options.page) !== null && _b !== void 0 ? _b : data.page,
+                columns: (_c = options === null || options === void 0 ? void 0 : options.columns) !== null && _c !== void 0 ? _c : data.columns
+            };
+            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).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));
+            // TODO: We should properly type this any
+            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() {
+    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;
+            }
+        };
+    });
+};
+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 o = {};
+        Object.assign(o, object);
+        const tableLinks = __classPrivateFieldGet(this, _BaseClient_links, "f")[table] || [];
+        for (const link of tableLinks) {
+            const [field, linkTable] = link;
+            const value = o[field];
+            if (value && typeof value === 'object') {
+                const { id } = value;
+                if (Object.keys(value).find((col) => col === 'id')) {
+                    o[field] = this.initObject(linkTable, value);
+                }
+                else if (id) {
+                    o[field] = {
+                        id,
+                        get: () => {
+                            this.db[linkTable].read(id);
+                        }
+                    };
+                }
+            }
+        }
+        const db = this.db;
+        o.read = function () {
+            return db[table].read(o['id']);
+        };
+        o.update = function (data) {
+            return db[table].update(o['id'], data);
+        };
+        o.delete = function () {
+            return db[table].delete(o['id']);
+        };
+        for (const prop of ['read', 'update', 'delete']) {
+            Object.defineProperty(o, prop, { enumerable: false });
+        }
+        // TODO: links and rev links
+        Object.freeze(o);
+        return o;
+    }
+    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');
+        });
+    }
+}
+exports.BaseClient = BaseClient;
+_BaseClient_links = new WeakMap(), _BaseClient_branch = new WeakMap();
+const isBranchStrategyBuilder = (strategy) => {
+    return typeof strategy === 'function';
+};
+// TODO: We can find a better implementation for links
+const transformObjectLinks = (object) => {
+    return Object.entries(object).reduce((acc, [key, value]) => {
+        if (value && typeof value === 'object' && typeof value.id === 'string') {
+            return Object.assign(Object.assign({}, acc), { [key]: value.id });
+        }
+        return Object.assign(Object.assign({}, acc), { [key]: value });
+    }, {});
+};

package/dist/schema/selection.d.ts

@@ -0,0 +1,14 @@
+import { XataRecord } from '..';
+import { StringKeys, UnionToIntersection, Values } from '../util/types';
+import { Query } from './query';
+import { Identifiable } from './record';
+declare type Queries<T> = {
+    [key in keyof T as T[key] extends Query<any> ? key : never]: T[key];
+};
+declare type InternalProperties = keyof XataRecord;
+export declare type Selectable<T extends XataRecord> = Omit<T, InternalProperties> & Identifiable;
+export declare type SelectableColumn<O> = '*' | (O extends Array<unknown> ? never : O extends Record<string, any> ? '*' | Values<{
+    [K in StringKeys<O>]: O[K] extends Record<string, any> ? `${K}.${SelectableColumn<O[K]>}` : K;
+}> : '');
+export declare type Select<T, K extends SelectableColumn<T>> = UnionToIntersection<K extends keyof T ? Pick<T, K> : T> & Queries<T> & XataRecord;
+export {};

package/dist/schema/selection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util/lang.d.ts

@@ -0,0 +1,2 @@
+export declare function compact<T>(arr: Array<T | null | undefined>): T[];
+export declare type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/util/lang.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compact = void 0;
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+function compact(arr) {
+    return arr.filter(notEmpty);
+}
+exports.compact = compact;

package/dist/util/types.d.ts

@@ -0,0 +1,3 @@
+export declare type StringKeys<O> = Extract<keyof O, string>;
+export declare type Values<O> = O[keyof O];
+export declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;

package/dist/util/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@xata.io/client",
-  "version": "0.1.5",
+  "version": "0.4.0",
   "description": "Xata.io SDK for TypeScript and JavaScript",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json",
     "prepack": "npm run build"
   },
   "repository": {
@@ -19,5 +19,6 @@
   "bugs": {
     "url": "https://github.com/xataio/client-ts/issues"
   },
-  "homepage": "https://github.com/xataio/client-ts#readme"
+  "homepage": "https://github.com/xataio/client-ts/blob/main/client/README.md",
+  "gitHead": "d29cf06c96a17f69ca80c57b430059abc90fcad8"
 }

package/dist/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/index.test.js

@@ -1,182 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const _1 = require("./");
-const fetch = jest.fn();
-const client = new _1.BaseClient({
-    fetch,
-    apiKey: '1234',
-    databaseURL: 'https://my-workspace-5df34do.staging.xatabase.co/db/xata:main'
-}, {});
-const users = new _1.RestRepository(client, 'users');
-describe('request', () => {
-    test('builds the right arguments for a GET request', () => __awaiter(void 0, void 0, void 0, function* () {
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        users.request('GET', '/foo');
-        expect(fetch).toHaveBeenCalledTimes(1);
-        expect(fetch.mock.calls[0]).toMatchInlineSnapshot(`
-      Array [
-        "https://my-workspace-5df34do.staging.xatabase.co/db/xata:main/foo",
-        Object {
-          "body": undefined,
-          "headers": Object {
-            "Accept": "*/*",
-            "Authorization": "Bearer 1234",
-            "Content-Type": "application/json",
-          },
-          "method": "GET",
-        },
-      ]
-    `);
-    }));
-    test('builds the right arguments for a POST request', () => __awaiter(void 0, void 0, void 0, function* () {
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        users.request('POST', '/foo', { a: 1 });
-        expect(fetch).toHaveBeenCalledTimes(1);
-        expect(fetch.mock.calls[0]).toMatchInlineSnapshot(`
-      Array [
-        "https://my-workspace-5df34do.staging.xatabase.co/db/xata:main/foo",
-        Object {
-          "body": "{\\"a\\":1}",
-          "headers": Object {
-            "Accept": "*/*",
-            "Authorization": "Bearer 1234",
-            "Content-Type": "application/json",
-          },
-          "method": "POST",
-        },
-      ]
-    `);
-    }));
-    test('throws if the response is not ok', () => __awaiter(void 0, void 0, void 0, function* () {
-        fetch.mockImplementation(() => {
-            return {
-                ok: false,
-                status: 404,
-                statusText: 'Not Found'
-            };
-        });
-        expect(users.request('GET', '/foo')).rejects.toThrow(new _1.XataError('Not Found', 404));
-    }));
-    test('throws with the error from the server if the response is not ok', () => __awaiter(void 0, void 0, void 0, function* () {
-        fetch.mockImplementation(() => {
-            return {
-                ok: false,
-                status: 404,
-                statusText: 'Not Found',
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({ message: 'Resource not found' }); })
-            };
-        });
-        expect(users.request('GET', '/foo')).rejects.toThrow(new _1.XataError('Resource not found', 404));
-    }));
-    test('returns the json body if the response is ok', () => __awaiter(void 0, void 0, void 0, function* () {
-        const json = { a: 1 };
-        fetch.mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return json; })
-            };
-        });
-        const result = yield users.request('GET', '/foo');
-        expect(result).toEqual(json);
-    }));
-});
-function expectRequest(expectedRequest, callback, response) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const request = jest.fn(() => __awaiter(this, void 0, void 0, function* () { return response; }));
-        users.request = request;
-        yield callback();
-        const { calls } = request.mock;
-        expect(calls.length).toBe(1);
-        const [method, path, body] = calls[0];
-        expect(method).toBe(expectedRequest.method);
-        expect(path).toBe(expectedRequest.path);
-        expect(JSON.stringify(body)).toBe(JSON.stringify(expectedRequest.body));
-    });
-}
-describe('query', () => {
-    describe('getMany', () => {
-        test('simple query', () => __awaiter(void 0, void 0, void 0, function* () {
-            const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-            expectRequest(expected, () => users.getMany(), { records: [] });
-        }));
-        test('query with one filter', () => __awaiter(void 0, void 0, void 0, function* () {
-            const expected = { method: 'POST', path: '/tables/users/query', body: { filter: { $all: [{ name: 'foo' }] } } };
-            expectRequest(expected, () => users.filter('name', 'foo').getMany(), { records: [] });
-        }));
-    });
-    describe('getOne', () => {
-        test('returns a single object', () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = { records: [{ id: '1234' }] };
-            const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-            expectRequest(expected, () => __awaiter(void 0, void 0, void 0, function* () {
-                const first = yield users.select().getOne();
-                expect(first === null || first === void 0 ? void 0 : first.id).toBe(result.records[0].id);
-            }), result);
-        }));
-        test('returns null if no objects are returned', () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = { records: [] };
-            const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-            expectRequest(expected, () => __awaiter(void 0, void 0, void 0, function* () {
-                const first = yield users.getOne();
-                expect(first).toBeNull();
-            }), result);
-        }));
-    });
-});
-describe('read', () => {
-    test('reads an object by id successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-        const id = 'rec_1234';
-        const expected = { method: 'GET', path: `/tables/users/data/${id}`, body: undefined };
-        expectRequest(expected, () => users.read(id));
-    }));
-});
-describe('Repository.update', () => {
-    test('updates and object successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-        const object = { id: 'rec_1234', xata: { version: 1 }, name: 'Ada' };
-        const expected = { method: 'PUT', path: `/tables/users/data/${object.id}`, body: object };
-        expectRequest(expected, () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield users.update(object.id, object);
-            expect(result.id).toBe(object.id);
-        }), { id: object.id });
-    }));
-});
-describe('Repository.delete', () => {
-    test('deletes a record by id successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-        const id = 'rec_1234';
-        const expected = { method: 'DELETE', path: `/tables/users/data/${id}`, body: undefined };
-        expectRequest(expected, () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield users.delete(id);
-            expect(result).toBe(undefined);
-        }));
-    }));
-});
-describe('create', () => {
-    test('successful', () => __awaiter(void 0, void 0, void 0, function* () {
-        const created = { id: 'rec_1234', _version: 0 };
-        const object = { name: 'Ada' };
-        const expected = { method: 'POST', path: '/tables/users/data', body: object };
-        expectRequest(expected, () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield users.create(object);
-            expect(result.id).toBe(created.id);
-        }), created);
-    }));
-});