@xata.io/client 0.0.0-beta.d0bc5ad → 0.0.0-beta.f12621e

package/dist/index.d.ts

@@ -1,3 +1,6 @@
+import { Page } from './schema/pagination';
+import { Query, QueryOptions } from './schema/query';
+import { Selectable, SelectableColumn, Select } from './schema/selection';
 export interface XataRecord {
     id: string;
     xata: {
@@ -7,107 +10,33 @@ export interface XataRecord {
     update(data: Selectable<this>): Promise<this>;
     delete(): Promise<void>;
 }
-export declare type Queries<T> = {
-    [key in keyof T as T[key] extends Query<infer A, infer B> ? key : never]: T[key];
-};
-export declare type OmitQueries<T> = {
-    [key in keyof T as T[key] extends Query<infer A, infer B> ? never : key]: T[key];
-};
-export declare type OmitLinks<T> = {
-    [key in keyof T as T[key] extends XataRecord ? never : key]: T[key];
-};
-export 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 Select<T, K extends keyof T> = Pick<T, K> & Queries<T> & XataRecord;
-export declare type Include<T> = {
-    [key in keyof T as T[key] extends XataRecord ? key : never]?: boolean | Array<keyof Selectable<T[key]>>;
-};
-declare type SortDirection = 'asc' | 'desc';
-declare type Operator = '$gt' | '$lt' | '$ge' | '$le' | '$exists' | '$notExists' | '$endsWith' | '$startsWith' | '$pattern' | '$is' | '$isNot' | '$contains' | '$includes' | '$includesSubstring' | '$includesPattern' | '$includesAll';
-declare type Constraint<T> = {
-    [key in Operator]?: T;
-};
-declare type DeepConstraint<T> = T extends Record<string, any> ? {
-    [key in keyof T]?: T[key] | DeepConstraint<T[key]>;
-} : Constraint<T>;
-declare type ComparableType = number | Date;
-export declare const gt: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const ge: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const gte: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const lt: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const lte: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const le: <T extends ComparableType>(value: T) => Constraint<T>;
-export declare const exists: (column: string) => Constraint<string>;
-export declare const notExists: (column: string) => Constraint<string>;
-export declare const startsWith: (value: string) => Constraint<string>;
-export declare const endsWith: (value: string) => Constraint<string>;
-export declare const pattern: (value: string) => Constraint<string>;
-export declare const is: <T>(value: T) => Constraint<T>;
-export declare const isNot: <T>(value: T) => Constraint<T>;
-export declare const contains: <T>(value: T) => Constraint<T>;
-export declare const includes: (value: string) => Constraint<string>;
-export declare const includesSubstring: (value: string) => Constraint<string>;
-export declare const includesPattern: (value: string) => Constraint<string>;
-export declare const includesAll: (value: string) => Constraint<string>;
-declare type FilterConstraints<T> = {
-    [key in keyof T]?: T[key] extends Record<string, any> ? FilterConstraints<T[key]> : T[key] | DeepConstraint<T[key]>;
-};
-declare type BulkQueryOptions<T> = {
-    filter?: FilterConstraints<T>;
-    sort?: {
-        column: keyof T;
-        direction?: SortDirection;
-    } | keyof T;
-};
-declare type QueryOrConstraint<T, R> = Query<T, R> | Constraint<T>;
-export declare class Query<T, R = T> {
-    table: string;
-    repository: Repository<T>;
-    readonly $any?: QueryOrConstraint<T, R>[];
-    readonly $all?: QueryOrConstraint<T, R>[];
-    readonly $not?: QueryOrConstraint<T, R>[];
-    readonly $none?: QueryOrConstraint<T, R>[];
-    readonly $sort?: Record<string, SortDirection>;
-    constructor(repository: Repository<T> | null, table: string, data: Partial<Query<T, R>>, parent?: Query<T, R>);
-    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>;
-    getMany(options?: BulkQueryOptions<T>): Promise<R[]>;
-    getOne(options?: BulkQueryOptions<T>): Promise<R | null>;
-    deleteAll(): Promise<number>;
-    include(columns: Include<T>): this;
-}
-export declare abstract class Repository<T> extends Query<T, Selectable<T>> {
-    select<K extends keyof Selectable<T>>(...columns: K[]): Query<T, Select<T, K>>;
+export declare abstract class Repository<T extends XataRecord> extends Query<T> {
+    select<K extends SelectableColumn<T>>(columns: K[]): Query<T, Select<T, K>>;
     abstract create(object: Selectable<T>): Promise<T>;
+    abstract createMany(objects: Selectable<T>[]): Promise<T[]>;
     abstract read(id: string): Promise<T | null>;
     abstract update(id: string, object: Partial<T>): Promise<T>;
     abstract delete(id: string): void;
-    abstract query<R>(query: Query<T, R>): Promise<R[]>;
+    abstract _runQuery<R extends XataRecord, Options extends QueryOptions<T>>(query: Query<T, R>, options: Options): Promise<Page<T, typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R>>;
 }
-export declare class RestRepository<T> extends Repository<T> {
+export declare class RestRepository<T extends XataRecord> extends Repository<T> {
     client: BaseClient<any>;
     fetch: any;
     constructor(client: BaseClient<any>, table: string);
-    request(method: string, path: string, body?: unknown): Promise<any>;
-    select<K extends keyof T>(...columns: K[]): Query<T, Select<T, K>>;
+    request<T>(method: string, path: string, body?: unknown): Promise<T | undefined>;
+    select<K extends SelectableColumn<T>>(columns: K[]): Query<T, Select<T, K>>;
     create(object: T): Promise<T>;
+    createMany(objects: T[]): Promise<T[]>;
     read(id: string): Promise<T | null>;
     update(id: string, object: Partial<T>): Promise<T>;
     delete(id: string): Promise<void>;
-    query<R>(query: Query<T, R>): Promise<R[]>;
+    _runQuery<R extends XataRecord, Options extends QueryOptions<T>>(query: Query<T, R>, options: Options): Promise<Page<T, typeof options['columns'] extends SelectableColumn<T>[] ? Select<T, typeof options['columns'][number]> : R>>;
 }
 interface RepositoryFactory {
-    createRepository<T>(client: BaseClient<any>, table: string): Repository<T>;
+    createRepository<T extends XataRecord>(client: BaseClient<any>, table: string): Repository<T>;
 }
 export declare class RestRespositoryFactory implements RepositoryFactory {
-    createRepository<T>(client: BaseClient<any>, table: string): Repository<T>;
+    createRepository<T extends XataRecord>(client: BaseClient<any>, table: string): Repository<T>;
 }
 declare type BranchStrategyValue = string | undefined | null;
 declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;
@@ -115,7 +44,7 @@ declare type BranchStrategy = BranchStrategyValue | BranchStrategyBuilder;
 declare type BranchStrategyOption = NonNullable<BranchStrategy | BranchStrategy[]>;
 export declare type XataClientOptions = {
     fetch?: unknown;
-    databaseURL: string;
+    databaseURL?: string;
     branch: BranchStrategyOption;
     apiKey: string;
     repositoryFactory?: RepositoryFactory;
@@ -134,4 +63,4 @@ export declare class XataError extends Error {
     constructor(message: string, status: number);
 }
 export declare type Links = Record<string, Array<string[]>>;
-export {};
+export * from './schema';

package/dist/index.js

@@ -1,4 +1,14 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -16,148 +26,14 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XataError = exports.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = exports.Query = 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;
-class Query {
-    constructor(repository, table, data, parent) {
-        if (repository) {
-            this.repository = repository;
-        }
-        else {
-            this.repository = this;
-        }
-        this.table = table;
-        // For some reason Object.assign(this, parent) didn't work in this case
-        // so doing all this manually:
-        this.$any = parent === null || parent === void 0 ? void 0 : parent.$any;
-        this.$all = parent === null || parent === void 0 ? void 0 : parent.$all;
-        this.$not = parent === null || parent === void 0 ? void 0 : parent.$not;
-        this.$none = parent === null || parent === void 0 ? void 0 : parent.$none;
-        this.$sort = parent === null || parent === void 0 ? void 0 : parent.$sort;
-        Object.assign(this, data);
-        // These bindings are used to support deconstructing
-        // const { any, not, filter, sort } = xata.users.query()
-        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 });
-    }
-    any(...queries) {
-        return new Query(this.repository, this.table, {
-            $any: (this.$any || []).concat(queries)
-        }, this);
-    }
-    all(...queries) {
-        return new Query(this.repository, this.table, {
-            $all: (this.$all || []).concat(queries)
-        }, this);
-    }
-    not(...queries) {
-        return new Query(this.repository, this.table, {
-            $not: (this.$not || []).concat(queries)
-        }, this);
-    }
-    none(...queries) {
-        return new Query(this.repository, this.table, {
-            $none: (this.$none || []).concat(queries)
-        }, this);
-    }
-    filter(a, b) {
-        if (arguments.length === 1) {
-            const constraints = a;
-            const queries = [];
-            for (const [column, constraint] of Object.entries(constraints)) {
-                queries.push({ [column]: constraint });
-            }
-            return new Query(this.repository, this.table, {
-                $all: (this.$all || []).concat(queries)
-            }, this);
-        }
-        else {
-            const column = a;
-            const value = b;
-            return new Query(this.repository, this.table, {
-                $all: (this.$all || []).concat({ [column]: value })
-            }, this);
-        }
-    }
-    sort(column, direction) {
-        const sort = Object.assign(Object.assign({}, this.$sort), { [column]: direction });
-        const q = new Query(this.repository, this.table, {
-            $sort: sort
-        }, this);
-        return q;
-    }
-    // TODO: pagination. Maybe implement different methods for different type of paginations
-    // and one to simply get the first records returned by the query with no pagination.
-    getMany(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: use options
-            return this.repository.query(this);
-        });
-    }
-    getOne(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO: use options
-            const arr = yield this.getMany(); // TODO, limit to 1
-            return arr[0] || null;
-        });
-    }
-    deleteAll() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Return number of affected rows
-            return 0;
-        });
-    }
-    include(columns) {
-        // TODO
-        return this;
-    }
-}
-exports.Query = Query;
-class Repository extends Query {
-    select(...columns) {
-        return new Query(this.repository, this.table, {});
+exports.XataError = exports.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = void 0;
+const filters_1 = require("./schema/filters");
+const pagination_1 = require("./schema/pagination");
+const query_1 = require("./schema/query");
+const errors_1 = require("./util/errors");
+class Repository extends query_1.Query {
+    select(columns) {
+        return new query_1.Query(this.repository, this.table, { columns });
     }
 }
 exports.Repository = Repository;
@@ -165,25 +41,16 @@ class RestRepository extends Repository {
     constructor(client, table) {
         super(null, table, {});
         this.client = client;
-        const { fetch } = client.options;
-        if (fetch) {
+        const doWeHaveFetch = typeof fetch !== 'undefined';
+        const isInjectedFetchProblematic = !this.client.options.fetch;
+        if (doWeHaveFetch) {
             this.fetch = fetch;
         }
-        else if (typeof window === 'object') {
-            this.fetch = window.fetch;
+        else if (isInjectedFetchProblematic) {
+            throw new Error(errors_1.errors.falsyFetchImplementation);
         }
-        else if (typeof require === 'function') {
-            try {
-                this.fetch = require('node-fetch');
-            }
-            catch (err) {
-                try {
-                    this.fetch = require('cross-fetch');
-                }
-                catch (err) {
-                    throw new Error('No fetch implementation found. Please provide one in the constructor');
-                }
-            }
+        else {
+            this.fetch = this.client.options.fetch;
         }
         Object.defineProperty(this, 'client', { enumerable: false });
         Object.defineProperty(this, 'fetch', { enumerable: false });
@@ -193,7 +60,8 @@ class RestRepository extends Repository {
         return __awaiter(this, void 0, void 0, function* () {
             const { databaseURL, apiKey } = this.client.options;
             const branch = yield this.client.getBranch();
-            const resp = yield this.fetch(`${databaseURL}:${branch}${path}`, {
+            const fetchImpl = this.fetch;
+            const resp = yield fetchImpl(`${databaseURL}:${branch}${path}`, {
                 method,
                 headers: {
                     Accept: '*/*',
@@ -219,31 +87,49 @@ class RestRepository extends Repository {
                 throw new XataError(resp.statusText, resp.status);
             }
             if (resp.status === 204)
-                return;
+                return undefined;
             return resp.json();
         });
     }
-    select(...columns) {
-        return new Query(this.repository, this.table, {});
+    select(columns) {
+        return new query_1.Query(this.repository, this.table, { columns });
     }
     create(object) {
         return __awaiter(this, void 0, void 0, function* () {
-            const body = Object.assign({}, object);
-            for (const key of Object.keys(body)) {
-                const value = body[key];
-                if (value && typeof value === 'object' && typeof value.id === 'string') {
-                    body[key] = value.id;
-                }
+            const record = transformObjectLinks(object);
+            const response = yield this.request('POST', `/tables/${this.table}/data`, record);
+            if (!response) {
+                throw new Error("The server didn't return any data for the query");
             }
-            const obj = yield this.request('POST', `/tables/${this.table}/data`, body);
-            return this.client.initObject(this.table, obj);
+            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 records = objects.map((object) => transformObjectLinks(object));
+            const response = yield this.request('POST', `/tables/${this.table}/bulk`, { records });
+            if (!response) {
+                throw new Error("The server didn't return any data for the query");
+            }
+            // TODO: Use filer.$any() to get all the records
+            const finalObjects = yield Promise.all(response.recordIDs.map((id) => this.read(id)));
+            if (finalObjects.some((object) => !object)) {
+                throw new Error('The server failed to save the record');
+            }
+            return finalObjects;
         });
     }
     read(id) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                const obj = yield this.request('GET', `/tables/${this.table}/data/${id}`);
-                return this.client.initObject(this.table, obj);
+                const response = yield this.request('GET', `/tables/${this.table}/data/${id}`);
+                if (!response)
+                    return null;
+                return this.client.initObject(this.table, response);
             }
             catch (err) {
                 if (err.status === 404)
@@ -254,8 +140,12 @@ class RestRepository extends Repository {
     }
     update(id, object) {
         return __awaiter(this, void 0, void 0, function* () {
-            const obj = yield this.request('PUT', `/tables/${this.table}/data/${id}`, object);
-            return this.client.initObject(this.table, obj);
+            const response = yield this.request('PUT', `/tables/${this.table}/data/${id}`, object);
+            if (!response) {
+                throw new Error("The server didn't return any data for the query");
+            }
+            // TODO: Review this, not sure we are properly initializing the object
+            return this.client.initObject(this.table, response);
         });
     }
     delete(id) {
@@ -263,7 +153,8 @@ class RestRepository extends Repository {
             yield this.request('DELETE', `/tables/${this.table}/data/${id}`);
         });
     }
-    query(query) {
+    _runQuery(query, options) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const filter = {
                 $any: query.$any,
@@ -273,10 +164,18 @@ class RestRepository extends Repository {
             };
             const body = {
                 filter: Object.values(filter).some(Boolean) ? filter : undefined,
-                sort: query.$sort
+                sort: (_a = (0, filters_1.buildSortFilter)(options === null || options === void 0 ? void 0 : options.sort)) !== null && _a !== void 0 ? _a : query.$sort,
+                page: options === null || options === void 0 ? void 0 : options.page,
+                columns: (_b = options === null || options === void 0 ? void 0 : options.columns) !== null && _b !== void 0 ? _b : query.columns
             };
-            const result = yield this.request('POST', `/tables/${this.table}/query`, body);
-            return result.records.map((record) => this.client.initObject(this.table, record));
+            const response = yield this.request('POST', `/tables/${this.table}/query`, body);
+            if (!response) {
+                throw new Error("The server didn't return any data for the query");
+            }
+            const { meta, records: objects } = response;
+            const records = objects.map((record) => this.client.initObject(this.table, record));
+            // TODO: We should properly type this any
+            return new pagination_1.Page(query, meta, records);
         });
     }
 }
@@ -376,3 +275,13 @@ exports.XataError = XataError;
 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 });
+    }, {});
+};
+__exportStar(require("./schema"), exports);

package/dist/schema/filters.d.ts

@@ -0,0 +1,20 @@
+export declare type SortDirection = 'asc' | 'desc';
+export declare type SortFilterExtended<T> = {
+    column: keyof T;
+    direction?: SortDirection;
+};
+export declare type SortFilter<T> = SortFilterExtended<T> | keyof T;
+export declare function isSortFilterObject<T>(filter: SortFilter<T>): filter is SortFilterExtended<T>;
+export declare type FilterOperator = '$gt' | '$lt' | '$ge' | '$le' | '$exists' | '$notExists' | '$endsWith' | '$startsWith' | '$pattern' | '$is' | '$isNot' | '$contains' | '$includes' | '$includesSubstring' | '$includesPattern' | '$includesAll';
+export declare function buildSortFilter<T>(filter?: SortFilter<T> | SortFilter<T>[]): {
+    [key: string]: SortDirection;
+} | undefined;
+export declare type Constraint<T> = {
+    [key in FilterOperator]?: T;
+};
+export declare type DeepConstraint<T> = T extends Record<string, any> ? {
+    [key in keyof T]?: T[key] | DeepConstraint<T[key]>;
+} : Constraint<T>;
+export declare type FilterConstraints<T> = {
+    [key in keyof T]?: T[key] extends Record<string, any> ? FilterConstraints<T[key]> : T[key] | DeepConstraint<T[key]>;
+};

package/dist/schema/filters.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSortFilter = exports.isSortFilterObject = void 0;
+function isSortFilterObject(filter) {
+    return typeof filter === 'object' && filter.column !== undefined;
+}
+exports.isSortFilterObject = isSortFilterObject;
+function buildSortFilter(filter) {
+    if (!filter)
+        return undefined;
+    const filters = Array.isArray(filter) ? filter : [filter];
+    return filters.reduce((acc, item) => {
+        if (typeof item === 'string') {
+            return Object.assign(Object.assign({}, acc), { [item]: 'asc' });
+        }
+        else if (isSortFilterObject(item)) {
+            return Object.assign(Object.assign({}, acc), { [item.column]: item.direction });
+        }
+        else {
+            return acc;
+        }
+    }, {});
+}
+exports.buildSortFilter = buildSortFilter;

package/dist/schema/index.d.ts

@@ -0,0 +1 @@
+export * from './operators';

package/dist/schema/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operators"), exports);

package/dist/schema/operators.d.ts

@@ -0,0 +1,21 @@
+import { Constraint } from './filters';
+declare type ComparableType = number | Date;
+export declare const gt: <T extends ComparableType>(value: T) => Constraint<T>;
+export declare const ge: <T extends ComparableType>(value: T) => Constraint<T>;
+export declare const gte: <T extends ComparableType>(value: T) => Constraint<T>;
+export declare const lt: <T extends ComparableType>(value: T) => Constraint<T>;
+export declare const lte: <T extends ComparableType>(value: T) => Constraint<T>;
+export declare const le: <T extends ComparableType>(value: T) => Constraint<T>;
+export declare const exists: (column: string) => Constraint<string>;
+export declare const notExists: (column: string) => Constraint<string>;
+export declare const startsWith: (value: string) => Constraint<string>;
+export declare const endsWith: (value: string) => Constraint<string>;
+export declare const pattern: (value: string) => Constraint<string>;
+export declare const is: <T>(value: T) => Constraint<T>;
+export declare const isNot: <T>(value: T) => Constraint<T>;
+export declare const contains: <T>(value: T) => Constraint<T>;
+export declare const includes: (value: string) => Constraint<string>;
+export declare const includesSubstring: (value: string) => Constraint<string>;
+export declare const includesPattern: (value: string) => Constraint<string>;
+export declare const includesAll: (value: string) => Constraint<string>;
+export {};

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,42 @@
+import { XataRecord } from '..';
+import { Query } from './query';
+export declare type PaginationQueryMeta = {
+    page: {
+        cursor: string;
+        more: boolean;
+    };
+};
+export interface BasePage<T extends XataRecord, R extends XataRecord> {
+    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 class Page<T extends XataRecord, R extends XataRecord> implements BasePage<T, R> {
+    readonly query: Query<T, R>;
+    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;