@xata.io/client 0.0.0-beta.d2e2306 → 0.0.0-beta.d76c443

package/dist/schema/sorting.spec.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Simple sorting
+const simpleSorting = { name: 'asc' };
+// Array of simple sorting
+const arrayOfSimpleSorting = [{ name: 'asc' }, { age: 'desc' }];
+test('fake test', () => {
+    // This is a fake test to make sure that the type definitions in this file are working
+});

package/dist/util/config.d.ts

@@ -0,0 +1,11 @@
+import { FetchImpl } from '../api/fetcher';
+declare type BranchResolutionOptions = {
+    databaseURL?: string;
+    apiKey?: string;
+    fetchImpl?: FetchImpl;
+};
+export declare function getCurrentBranchName(options?: BranchResolutionOptions): Promise<string | undefined>;
+export declare function getCurrentBranchDetails(options?: BranchResolutionOptions): Promise<import("../api/schemas").DBBranch | null>;
+export declare function getDatabaseURL(): string | undefined;
+export declare function getAPIKey(): string | undefined;
+export {};

package/dist/util/config.js

@@ -0,0 +1,121 @@
+"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 });
+exports.getAPIKey = exports.getDatabaseURL = exports.getCurrentBranchDetails = exports.getCurrentBranchName = void 0;
+const api_1 = require("../api");
+const environment_1 = require("./environment");
+const fetch_1 = require("./fetch");
+const lang_1 = require("./lang");
+const envBranchNames = [
+    'XATA_BRANCH',
+    'VERCEL_GIT_COMMIT_REF',
+    'CF_PAGES_BRANCH',
+    'BRANCH' // Netlify. Putting it the last one because it is more ambiguous
+];
+const defaultBranch = 'main';
+function getCurrentBranchName(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const env = yield getBranchByEnvVariable();
+        if (env)
+            return env;
+        const branch = yield (0, environment_1.getGitBranch)();
+        if (!branch)
+            return defaultBranch;
+        // TODO: in the future, call /resolve endpoint
+        // For now, call API to see if the branch exists. If not, use a default value.
+        const details = yield getDatabaseBranch(branch, options);
+        if (details)
+            return branch;
+        return defaultBranch;
+    });
+}
+exports.getCurrentBranchName = getCurrentBranchName;
+function getCurrentBranchDetails(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const env = yield getBranchByEnvVariable();
+        if (env)
+            return getDatabaseBranch(env, options);
+        const branch = yield (0, environment_1.getGitBranch)();
+        if (!branch)
+            return getDatabaseBranch(defaultBranch, options);
+        // TODO: in the future, call /resolve endpoint
+        // For now, call API to see if the branch exists. If not, use a default value.
+        const details = yield getDatabaseBranch(branch, options);
+        if (details)
+            return details;
+        return getDatabaseBranch(defaultBranch, options);
+    });
+}
+exports.getCurrentBranchDetails = getCurrentBranchDetails;
+function getDatabaseBranch(branch, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const databaseURL = (options === null || options === void 0 ? void 0 : options.databaseURL) || getDatabaseURL();
+        const apiKey = (options === null || options === void 0 ? void 0 : options.apiKey) || getAPIKey();
+        if (!databaseURL)
+            throw new Error('A databaseURL was not defined. Either set the XATA_DATABASE_URL env variable or pass the argument explicitely');
+        if (!apiKey)
+            throw new Error('An API key was not defined. Either set the XATA_API_KEY env variable or pass the argument explicitely');
+        const [protocol, , host, , database] = databaseURL.split('/');
+        const [workspace] = host.split('.');
+        const dbBranchName = `${database}:${branch}`;
+        try {
+            return yield (0, api_1.getBranchDetails)({
+                apiKey,
+                apiUrl: databaseURL,
+                fetchImpl: (0, fetch_1.getFetchImplementation)(options === null || options === void 0 ? void 0 : options.fetchImpl),
+                workspacesApiUrl: `${protocol}//${host}`,
+                pathParams: {
+                    dbBranchName,
+                    workspace
+                }
+            });
+        }
+        catch (err) {
+            if ((0, lang_1.isObject)(err) && err.status === 404)
+                return null;
+            throw err;
+        }
+    });
+}
+function getBranchByEnvVariable() {
+    for (const name of envBranchNames) {
+        const value = (0, environment_1.getEnvVariable)(name);
+        if (value) {
+            return value;
+        }
+    }
+    try {
+        return XATA_BRANCH;
+    }
+    catch (err) {
+        // Ignore ReferenceError. Only CloudFlare workers set env variables as global variables
+    }
+}
+function getDatabaseURL() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_DATABASE_URL')) !== null && _a !== void 0 ? _a : XATA_DATABASE_URL;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getDatabaseURL = getDatabaseURL;
+function getAPIKey() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_API_KEY')) !== null && _a !== void 0 ? _a : XATA_API_KEY;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getAPIKey = getAPIKey;

package/dist/util/environment.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../../src/types/global-node.d.ts" />
+/// <reference path="../../src/types/global-variables.d.ts" />
+/// <reference path="../../src/types/global-deno.d.ts" />
+export declare function getEnvVariable(name: string): string | undefined;
+export declare function getGitBranch(): Promise<string | undefined>;

package/dist/util/environment.js

@@ -0,0 +1,68 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+///<reference path="../types/global-node.d.ts"/>
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+///<reference path="../types/global-variables.d.ts"/>
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+///<reference path="../types/global-deno.d.ts"/>
+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.getGitBranch = exports.getEnvVariable = void 0;
+const lang_1 = require("./lang");
+function getEnvVariable(name) {
+    var _a, _b;
+    // Node.js: process.env
+    try {
+        if ((0, lang_1.isObject)(process) && (0, lang_1.isString)((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a[name])) {
+            return process.env[name];
+        }
+    }
+    catch (err) {
+        // Ignore: Should never happen
+    }
+    try {
+        // Deno: Deno.env.get
+        if ((0, lang_1.isObject)(Deno) && (0, lang_1.isString)((_b = Deno === null || Deno === void 0 ? void 0 : Deno.env) === null || _b === void 0 ? void 0 : _b.get(name))) {
+            return Deno.env.get(name);
+        }
+    }
+    catch (err) {
+        // Ignore: Will fail if not using --allow-env
+    }
+}
+exports.getEnvVariable = getEnvVariable;
+function getGitBranch() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Node.js: child_process.execSync
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            return require('child_process').execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
+        }
+        catch (err) {
+            // Ignore
+        }
+        // Deno: Deno.run
+        try {
+            if ((0, lang_1.isObject)(Deno)) {
+                const process = Deno.run({
+                    cmd: ['git', 'branch', '--show-current'],
+                    stdout: 'piped',
+                    stderr: 'piped'
+                });
+                return new TextDecoder().decode(yield process.output()).trim();
+            }
+        }
+        catch (err) {
+            // Ignore: Will fail if not using --allow-run
+        }
+    });
+}
+exports.getGitBranch = getGitBranch;

package/dist/util/fetch.d.ts

@@ -0,0 +1,2 @@
+import { FetchImpl } from '../api/fetcher';
+export declare function getFetchImplementation(userFetch?: FetchImpl): FetchImpl | typeof fetch;

package/dist/util/fetch.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFetchImplementation = void 0;
+function getFetchImplementation(userFetch) {
+    const globalFetch = typeof fetch !== 'undefined' ? fetch : undefined;
+    const fetchImpl = userFetch !== null && userFetch !== void 0 ? userFetch : 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.`);
+    }
+    return fetchImpl;
+}
+exports.getFetchImplementation = getFetchImplementation;

package/dist/util/lang.d.ts

@@ -0,0 +1,5 @@
+export declare function compact<T>(arr: Array<T | null | undefined>): T[];
+export declare function compactObject<T>(obj: Record<string, T | null | undefined>): Record<string, T>;
+export declare type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare function isObject(value: any): value is Record<string, unknown>;
+export declare function isString(value: any): value is string;

package/dist/util/lang.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isString = exports.isObject = exports.compactObject = exports.compact = void 0;
+function notEmpty(value) {
+    return value !== null && value !== undefined;
+}
+function compact(arr) {
+    return arr.filter(notEmpty);
+}
+exports.compact = compact;
+function compactObject(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => notEmpty(value)));
+}
+exports.compactObject = compactObject;
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+exports.isObject = isObject;
+function isString(value) {
+    return value !== undefined && value !== null && typeof value === 'string';
+}
+exports.isString = isString;

package/dist/util/types.d.ts

@@ -0,0 +1,24 @@
+export declare type StringKeys<O> = Extract<keyof O, string>;
+export declare type NumberKeys<O> = Extract<keyof O, number>;
+export declare type Values<O> = O[StringKeys<O>];
+export declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+export declare type If<Condition, Then, Else> = Condition extends true ? Then : Else;
+export declare type IsObject<T> = T extends Record<string, any> ? true : false;
+export declare type IsArray<T> = T extends Array<any> ? true : false;
+export declare type NonEmptyArray<T> = T[] & {
+    0: T;
+};
+export declare type RequiredBy<T, K extends keyof T> = T & {
+    [P in K]-?: NonNullable<T[P]>;
+};
+export declare type GetArrayInnerType<T extends readonly any[]> = T[number];
+export declare type NonNullableValues<Obj> = {
+    [K in keyof Obj]: NonNullable<Obj[K]>;
+};
+export declare type KeysOfUnion<T> = T extends T ? keyof T : never;
+declare type Impossible<K extends keyof any> = {
+    [P in K]: never;
+};
+export declare type Exactly<T, U extends T = T> = U & Impossible<Exclude<keyof U, keyof T>>;
+export declare type SingleOrArray<T> = T | T[];
+export {};

package/dist/util/types.js

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

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@xata.io/client",
-  "version": "0.0.0-beta.d2e2306",
+  "version": "0.0.0-beta.d76c443",
   "description": "Xata.io SDK for TypeScript and JavaScript",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "browser": {
+    "child_process": false
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json",
     "prepack": "npm run build"
   },
   "repository": {
@@ -20,5 +23,5 @@
     "url": "https://github.com/xataio/client-ts/issues"
   },
   "homepage": "https://github.com/xataio/client-ts/blob/main/client/README.md",
-  "gitHead": "d2e2306e25dd2d99427d4357f13ad4a2dd420511"
+  "gitHead": "d76c443e4769df5339ab46ecd2714a8613dd9084"
 }

package/dist/index.test.js

@@ -1,304 +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 buildClient = (options = {}) => {
-    const { apiKey = '1234', databaseURL = 'https://my-workspace-5df34do.staging.xatabase.co/db/xata', branch = 'main' } = options;
-    const fetch = jest.fn();
-    const client = new _1.BaseClient({ fetch, apiKey, databaseURL, branch }, {});
-    const users = new _1.RestRepository(client, 'users');
-    return { fetch, client, users };
-};
-describe('client options', () => {
-    test('option parameters are set', () => {
-        const { client } = buildClient({ apiKey: 'apiKey', databaseURL: 'url' });
-        expect(client.options.apiKey).toBe('apiKey');
-        expect(client.options.databaseURL).toBe('url');
-    });
-    test('throws if mandatory options are missing', () => {
-        // @ts-expect-error Options are mandatory in TypeScript
-        expect(() => buildClient({ apiKey: null }, {})).toThrow('Options databaseURL, apiKey and branch are required');
-        // @ts-expect-error Options are mandatory in TypeScript
-        expect(() => buildClient({ databaseURL: null }, {})).toThrow('Options databaseURL, apiKey and branch are required');
-        // @ts-expect-error Options are mandatory in TypeScript
-        expect(() => buildClient({ branch: null }, {})).toThrow('Options databaseURL, apiKey and branch are required');
-    });
-    test('throws if branch cannot be resolved', () => {
-        const { users } = buildClient({ branch: () => null });
-        expect(users.request('GET', '/foo')).rejects.toThrow('Unable to resolve branch value');
-    });
-    test('provide branch as a string', () => __awaiter(void 0, void 0, void 0, function* () {
-        const { fetch, users } = buildClient({ branch: 'branch' });
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        yield users.request('GET', '/foo');
-        expect(fetch).toHaveBeenCalledTimes(1);
-        expect(fetch.mock.calls[0]).toMatchInlineSnapshot(`
-      Array [
-        "https://my-workspace-5df34do.staging.xatabase.co/db/xata:branch/foo",
-        Object {
-          "body": undefined,
-          "headers": Object {
-            "Accept": "*/*",
-            "Authorization": "Bearer 1234",
-            "Content-Type": "application/json",
-          },
-          "method": "GET",
-        },
-      ]
-    `);
-    }));
-    test('provide branch as an array', () => __awaiter(void 0, void 0, void 0, function* () {
-        const { fetch, users } = buildClient({
-            branch: [process.env.NOT_DEFINED_VARIABLE, () => __awaiter(void 0, void 0, void 0, function* () { return null; }), 'branch', 'main']
-        });
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        yield users.request('GET', '/foo');
-        expect(fetch).toHaveBeenCalledTimes(1);
-        expect(fetch.mock.calls[0]).toMatchInlineSnapshot(`
-      Array [
-        "https://my-workspace-5df34do.staging.xatabase.co/db/xata:branch/foo",
-        Object {
-          "body": undefined,
-          "headers": Object {
-            "Accept": "*/*",
-            "Authorization": "Bearer 1234",
-            "Content-Type": "application/json",
-          },
-          "method": "GET",
-        },
-      ]
-    `);
-    }));
-    test('provide branch as a function', () => __awaiter(void 0, void 0, void 0, function* () {
-        const { fetch, users } = buildClient({ branch: () => 'branch' });
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        yield users.request('GET', '/foo');
-        expect(fetch).toHaveBeenCalledTimes(1);
-        expect(fetch.mock.calls[0]).toMatchInlineSnapshot(`
-      Array [
-        "https://my-workspace-5df34do.staging.xatabase.co/db/xata:branch/foo",
-        Object {
-          "body": undefined,
-          "headers": Object {
-            "Accept": "*/*",
-            "Authorization": "Bearer 1234",
-            "Content-Type": "application/json",
-          },
-          "method": "GET",
-        },
-      ]
-    `);
-    }));
-    test('ensure branch resolution is memoized', () => __awaiter(void 0, void 0, void 0, function* () {
-        const branchGetter = jest.fn(() => 'branch');
-        const { fetch, users } = buildClient({ branch: branchGetter });
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        yield users.request('GET', '/foo');
-        yield users.request('GET', '/foo');
-        expect(branchGetter).toHaveBeenCalledTimes(1);
-    }));
-});
-describe('request', () => {
-    test('builds the right arguments for a GET request', () => __awaiter(void 0, void 0, void 0, function* () {
-        const { fetch, users } = buildClient();
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        yield 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* () {
-        const { fetch, users } = buildClient();
-        fetch.mockReset().mockImplementation(() => {
-            return {
-                ok: true,
-                json: () => __awaiter(void 0, void 0, void 0, function* () { return ({}); })
-            };
-        });
-        yield 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* () {
-        const { fetch, users } = buildClient();
-        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* () {
-        const { fetch, users } = buildClient();
-        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 { fetch, users } = buildClient();
-        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(users, 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 { users } = buildClient();
-            const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-            expectRequest(users, expected, () => users.getMany(), { records: [] });
-        }));
-        test('query with one filter', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { users } = buildClient();
-            const expected = { method: 'POST', path: '/tables/users/query', body: { filter: { $all: [{ name: 'foo' }] } } };
-            expectRequest(users, expected, () => users.filter('name', 'foo').getMany(), { records: [] });
-        }));
-    });
-    describe('getOne', () => {
-        test('returns a single object', () => __awaiter(void 0, void 0, void 0, function* () {
-            const { users } = buildClient();
-            const result = { records: [{ id: '1234' }] };
-            const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-            expectRequest(users, 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 { users } = buildClient();
-            const result = { records: [] };
-            const expected = { method: 'POST', path: '/tables/users/query', body: {} };
-            expectRequest(users, 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 { users } = buildClient();
-        const id = 'rec_1234';
-        const expected = { method: 'GET', path: `/tables/users/data/${id}`, body: undefined };
-        expectRequest(users, expected, () => users.read(id));
-    }));
-});
-describe('Repository.update', () => {
-    test('updates and object successfully', () => __awaiter(void 0, void 0, void 0, function* () {
-        const { users } = buildClient();
-        const object = { id: 'rec_1234', xata: { version: 1 }, name: 'Ada' };
-        const expected = { method: 'PUT', path: `/tables/users/data/${object.id}`, body: object };
-        expectRequest(users, 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 { users } = buildClient();
-        const id = 'rec_1234';
-        const expected = { method: 'DELETE', path: `/tables/users/data/${id}`, body: undefined };
-        expectRequest(users, 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 { users } = buildClient();
-        const created = { id: 'rec_1234', _version: 0 };
-        const object = { name: 'Ada' };
-        const expected = { method: 'POST', path: '/tables/users/data', body: object };
-        expectRequest(users, expected, () => __awaiter(void 0, void 0, void 0, function* () {
-            const result = yield users.create(object);
-            expect(result.id).toBe(created.id);
-        }), created);
-    }));
-});