@xata.io/client 0.0.0-beta.c9e08d0 → 0.0.0-beta.cae436d

package/dist/schema/operators.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.includesAll = exports.includesPattern = exports.includesSubstring = exports.includes = exports.contains = exports.isNot = exports.is = exports.pattern = exports.endsWith = exports.startsWith = exports.notExists = exports.exists = exports.le = exports.lte = exports.lt = exports.gte = exports.ge = exports.gt = void 0;
+const gt = (value) => ({ $gt: value });
+exports.gt = gt;
+const ge = (value) => ({ $ge: value });
+exports.ge = ge;
+const gte = (value) => ({ $ge: value });
+exports.gte = gte;
+const lt = (value) => ({ $lt: value });
+exports.lt = lt;
+const lte = (value) => ({ $le: value });
+exports.lte = lte;
+const le = (value) => ({ $le: value });
+exports.le = le;
+const exists = (column) => ({ $exists: column });
+exports.exists = exists;
+const notExists = (column) => ({ $notExists: column });
+exports.notExists = notExists;
+const startsWith = (value) => ({ $startsWith: value });
+exports.startsWith = startsWith;
+const endsWith = (value) => ({ $endsWith: value });
+exports.endsWith = endsWith;
+const pattern = (value) => ({ $pattern: value });
+exports.pattern = pattern;
+const is = (value) => ({ $is: value });
+exports.is = is;
+const isNot = (value) => ({ $isNot: value });
+exports.isNot = isNot;
+const contains = (value) => ({ $contains: value });
+exports.contains = contains;
+// TODO: these can only be applied to columns of type "multiple"
+const includes = (value) => ({ $includes: value });
+exports.includes = includes;
+const includesSubstring = (value) => ({ $includesSubstring: value });
+exports.includesSubstring = includesSubstring;
+const includesPattern = (value) => ({ $includesPattern: value });
+exports.includesPattern = includesPattern;
+const includesAll = (value) => ({ $includesAll: value });
+exports.includesAll = includesAll;

package/dist/schema/pagination.d.ts

@@ -0,0 +1,41 @@
+import { XataRecord } from '..';
+import { Query } from './query';
+export declare type PaginationQueryMeta = {
+    page: {
+        cursor: string;
+        more: boolean;
+    };
+};
+export interface Paginable<T extends XataRecord, R extends XataRecord = T> {
+    meta: PaginationQueryMeta;
+    records: R[];
+    nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    hasNextPage(): boolean;
+}
+export declare class Page<T extends XataRecord, R extends XataRecord> implements Paginable<T, R> {
+    #private;
+    readonly meta: PaginationQueryMeta;
+    readonly records: R[];
+    constructor(query: Query<T, R>, meta: PaginationQueryMeta, records?: R[]);
+    nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    hasNextPage(): boolean;
+}
+export declare type CursorNavigationOptions = {
+    first?: string;
+} | {
+    last?: string;
+} | {
+    after?: string;
+    before?: string;
+};
+export declare type OffsetNavigationOptions = {
+    size?: number;
+    offset?: number;
+};
+export declare type PaginationOptions = CursorNavigationOptions & OffsetNavigationOptions;

package/dist/schema/pagination.js

@@ -0,0 +1,58 @@
+"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 _Page_query;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+class Page {
+    constructor(query, meta, records = []) {
+        _Page_query.set(this, void 0);
+        __classPrivateFieldSet(this, _Page_query, query, "f");
+        this.meta = meta;
+        this.records = records;
+    }
+    nextPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Page_query, "f").getPaginated({ page: { size, offset, after: this.meta.page.cursor } });
+        });
+    }
+    previousPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Page_query, "f").getPaginated({ page: { size, offset, before: this.meta.page.cursor } });
+        });
+    }
+    firstPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Page_query, "f").getPaginated({ page: { size, offset, first: this.meta.page.cursor } });
+        });
+    }
+    lastPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Page_query, "f").getPaginated({ page: { size, offset, last: this.meta.page.cursor } });
+        });
+    }
+    // TODO: We need to add something on the backend if we want a hasPreviousPage
+    hasNextPage() {
+        return this.meta.page.more;
+    }
+}
+exports.Page = Page;
+_Page_query = new WeakMap();

package/dist/schema/query.d.ts

@@ -0,0 +1,45 @@
+import { XataRecord, Repository } from '..';
+import { FilterExpression, SortExpression, PageConfig, ColumnsFilter } from '../api/schemas';
+import { DeepConstraint, FilterConstraints, SortDirection, SortFilter } from './filters';
+import { PaginationOptions, Page, Paginable, PaginationQueryMeta } from './pagination';
+import { Selectable, SelectableColumn, Select } from './selection';
+export declare type QueryOptions<T> = {
+    page?: PaginationOptions;
+    columns?: Extract<keyof Selectable<T>, string>[];
+    sort?: SortFilter<T> | SortFilter<T>[];
+};
+export declare type QueryTableOptions = {
+    filter: FilterExpression;
+    sort?: SortExpression;
+    page?: PageConfig;
+    columns?: ColumnsFilter;
+};
+export declare class Query<T extends XataRecord, R extends XataRecord = T> implements Paginable<T, R> {
+    #private;
+    readonly meta: PaginationQueryMeta;
+    readonly records: R[];
+    constructor(repository: Repository<T> | null, table: string, data: Partial<QueryTableOptions>, parent?: Partial<QueryTableOptions>);
+    getQueryOptions(): QueryTableOptions;
+    any(...queries: Query<T, R>[]): Query<T, R>;
+    all(...queries: Query<T, R>[]): Query<T, R>;
+    not(...queries: Query<T, R>[]): Query<T, R>;
+    none(...queries: Query<T, R>[]): Query<T, R>;
+    filter(constraints: FilterConstraints<T>): Query<T, R>;
+    filter<F extends keyof T>(column: F, value: FilterConstraints<T[F]> | DeepConstraint<T[F]>): Query<T, R>;
+    sort<F extends keyof T>(column: F, direction: SortDirection): Query<T, R>;
+    select<K extends SelectableColumn<T>>(columns: K[]): Query<T, Select<T, K>>;
+    getPaginated<Options extends QueryOptions<T>>(options?: Options): Promise<Page<T, typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R>>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+    getIterator(chunk: number, options?: Omit<QueryOptions<T>, 'page'>): AsyncGenerator<R[]>;
+    getMany<Options extends QueryOptions<T>>(options?: Options): Promise<(typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R)[]>;
+    getOne<Options extends Omit<QueryOptions<T>, 'page'>>(options?: Options): Promise<(typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R) | null>;
+    /**async deleteAll(): Promise<number> {
+      // TODO: Return number of affected rows
+      return 0;
+    }**/
+    nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    hasNextPage(): boolean;
+}

package/dist/schema/query.js

@@ -0,0 +1,190 @@
+"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 __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var _Query_table, _Query_repository, _Query_data;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const lang_1 = require("../util/lang");
+class Query {
+    constructor(repository, table, data, parent) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        _Query_table.set(this, void 0);
+        _Query_repository.set(this, void 0);
+        _Query_data.set(this, { filter: {} });
+        // Implements pagination
+        this.meta = { page: { cursor: 'start', more: true } };
+        this.records = [];
+        __classPrivateFieldSet(this, _Query_table, table, "f");
+        if (repository) {
+            __classPrivateFieldSet(this, _Query_repository, repository, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Query_repository, this, "f");
+        }
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$any = (_b = (_a = data.filter) === null || _a === void 0 ? void 0 : _a.$any) !== null && _b !== void 0 ? _b : (_c = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _c === void 0 ? void 0 : _c.$any;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$all = (_e = (_d = data.filter) === null || _d === void 0 ? void 0 : _d.$all) !== null && _e !== void 0 ? _e : (_f = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _f === void 0 ? void 0 : _f.$all;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$not = (_h = (_g = data.filter) === null || _g === void 0 ? void 0 : _g.$not) !== null && _h !== void 0 ? _h : (_j = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _j === void 0 ? void 0 : _j.$not;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$none = (_l = (_k = data.filter) === null || _k === void 0 ? void 0 : _k.$none) !== null && _l !== void 0 ? _l : (_m = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _m === void 0 ? void 0 : _m.$none;
+        __classPrivateFieldGet(this, _Query_data, "f").sort = (_o = data.sort) !== null && _o !== void 0 ? _o : parent === null || parent === void 0 ? void 0 : parent.sort;
+        __classPrivateFieldGet(this, _Query_data, "f").columns = (_q = (_p = data.columns) !== null && _p !== void 0 ? _p : parent === null || parent === void 0 ? void 0 : parent.columns) !== null && _q !== void 0 ? _q : ['*'];
+        this.any = this.any.bind(this);
+        this.all = this.all.bind(this);
+        this.not = this.not.bind(this);
+        this.filter = this.filter.bind(this);
+        this.sort = this.sort.bind(this);
+        this.none = this.none.bind(this);
+        Object.defineProperty(this, 'table', { enumerable: false });
+        Object.defineProperty(this, 'repository', { enumerable: false });
+    }
+    getQueryOptions() {
+        return __classPrivateFieldGet(this, _Query_data, "f");
+    }
+    any(...queries) {
+        const $any = (0, lang_1.compact)(queries.map((query) => query.getQueryOptions().filter.$any)).flat();
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $any } }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    all(...queries) {
+        const $all = (0, lang_1.compact)(queries.map((query) => query.getQueryOptions().filter.$all)).flat();
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    not(...queries) {
+        const $not = (0, lang_1.compact)(queries.map((query) => query.getQueryOptions().filter.$not)).flat();
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $not } }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    none(...queries) {
+        const $none = (0, lang_1.compact)(queries.map((query) => query.getQueryOptions().filter.$none)).flat();
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $none } }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    filter(a, b) {
+        if (arguments.length === 1) {
+            const constraints = Object.entries(a).map(([column, constraint]) => ({ [column]: constraint }));
+            const $all = (0, lang_1.compact)([__classPrivateFieldGet(this, _Query_data, "f").filter.$all].flat().concat(constraints));
+            return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
+        }
+        else {
+            const column = a;
+            const value = b;
+            const $all = (0, lang_1.compact)([__classPrivateFieldGet(this, _Query_data, "f").filter.$all].flat().concat({ [column]: value }));
+            return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
+        }
+    }
+    sort(column, direction) {
+        const sort = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Query_data, "f").sort), { [column]: direction });
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { sort }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    select(columns) {
+        return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { columns }, __classPrivateFieldGet(this, _Query_data, "f"));
+    }
+    getPaginated(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Query_repository, "f").query(this, options);
+        });
+    }
+    [(_Query_table = new WeakMap(), _Query_repository = new WeakMap(), _Query_data = new WeakMap(), Symbol.asyncIterator)]() {
+        return __asyncGenerator(this, arguments, function* _a() {
+            var e_1, _b;
+            try {
+                for (var _c = __asyncValues(this.getIterator(1)), _d; _d = yield __await(_c.next()), !_d.done;) {
+                    const [record] = _d.value;
+                    yield yield __await(record);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_b = _c.return)) yield __await(_b.call(_c));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    getIterator(chunk, options = {}) {
+        return __asyncGenerator(this, arguments, function* getIterator_1() {
+            let offset = 0;
+            let end = false;
+            while (!end) {
+                const { records, meta } = yield __await(this.getPaginated(Object.assign(Object.assign({}, options), { page: { size: chunk, offset } })));
+                yield yield __await(records);
+                offset += chunk;
+                end = !meta.page.more;
+            }
+        });
+    }
+    getMany(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { records } = yield this.getPaginated(options);
+            return records;
+        });
+    }
+    getOne(options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const records = yield this.getMany(Object.assign(Object.assign({}, options), { page: { size: 1 } }));
+            return records[0] || null;
+        });
+    }
+    /**async deleteAll(): Promise<number> {
+      // TODO: Return number of affected rows
+      return 0;
+    }**/
+    nextPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.firstPage(size, offset);
+        });
+    }
+    previousPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.firstPage(size, offset);
+        });
+    }
+    firstPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPaginated({ page: { size, offset } });
+        });
+    }
+    lastPage(size, offset) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getPaginated({ page: { size, offset, before: 'end' } });
+        });
+    }
+    hasNextPage() {
+        return this.meta.page.more;
+    }
+}
+exports.Query = Query;

package/dist/schema/selection.d.ts

@@ -0,0 +1,18 @@
+import { XataRecord } from '..';
+import { StringKeys, UnionToIntersection, Values } from '../util/types';
+import { Query } from './query';
+declare type Queries<T> = {
+    [key in keyof T as T[key] extends Query<any> ? key : never]: T[key];
+};
+declare type OmitQueries<T> = {
+    [key in keyof T as T[key] extends Query<any> ? never : key]: T[key];
+};
+declare type OmitMethods<T> = {
+    [key in keyof T as T[key] extends Function ? never : key]: T[key];
+};
+export declare type Selectable<T> = Omit<OmitQueries<OmitMethods<T>>, 'id' | 'xata'>;
+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 @@
+export declare function compact<T>(arr: Array<T | null | undefined>): T[];

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,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.0.0-beta.c9e08d0",
+  "version": "0.0.0-beta.cae436d",
   "description": "Xata.io SDK for TypeScript and JavaScript",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,5 +20,5 @@
     "url": "https://github.com/xataio/client-ts/issues"
   },
   "homepage": "https://github.com/xataio/client-ts/blob/main/client/README.md",
-  "gitHead": "c9e08d07e1a7e7b07d118b2b459b9843edb341c3"
+  "gitHead": "cae436d55b8fc4484cc90bba98563e225af8d1a8"
 }

package/dist/util/errors.d.ts

@@ -1,3 +0,0 @@
-export declare const errors: {
-    falsyFetchImplementation: string; /** @todo add a link after docs exist */
-};

package/dist/util/errors.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.errors = void 0;
-exports.errors = {
-    falsyFetchImplementation: `The \`fetch\` option passed to the Xata client is resolving to a falsy value and may not be correctly imported.
-  
-More in the docs: 
-` /** @todo add a link after docs exist */
-};