@xata.io/client 0.2.2 → 0.3.0

package/dist/schema/operators.d.ts

@@ -0,0 +1,72 @@
+import { Constraint } from './filters';
+declare type ComparableType = number | Date;
+/**
+ * Operator to restrict results to only values that are greater than the given value.
+ */
+export declare const gt: <T extends ComparableType>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that are greater than or equal to the given value.
+ */
+export declare const ge: <T extends ComparableType>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that are greater than or equal to the given value.
+ */
+export declare const gte: <T extends ComparableType>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that are lower than the given value.
+ */
+export declare const lt: <T extends ComparableType>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that are lower than or equal to the given value.
+ */
+export declare const lte: <T extends ComparableType>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that are lower than or equal to the given value.
+ */
+export declare const le: <T extends ComparableType>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that are not null.
+ */
+export declare const exists: (column: string) => Constraint<string>;
+/**
+ * Operator to restrict results to only values that are null.
+ */
+export declare const notExists: (column: string) => Constraint<string>;
+/**
+ * Operator to restrict results to only values that start with the given prefix.
+ */
+export declare const startsWith: (value: string) => Constraint<string>;
+/**
+ * Operator to restrict results to only values that end with the given suffix.
+ */
+export declare const endsWith: (value: string) => Constraint<string>;
+/**
+ * Operator to restrict results to only values that match the given pattern.
+ */
+export declare const pattern: (value: string) => Constraint<string>;
+/**
+ * Operator to restrict results to only values that are equal to the given value.
+ */
+export declare const is: <T>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that are not equal to the given value.
+ */
+export declare const isNot: <T>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only values that contain the given value.
+ */
+export declare const contains: <T>(value: T) => Constraint<T>;
+/**
+ * Operator to restrict results to only arrays that include the given value.
+ */
+export declare const includes: (value: string) => Constraint<string>;
+/**
+ * Operator to restrict results to only arrays that include a value matching the given substring.
+ */
+export declare const includesSubstring: (value: string) => Constraint<string>;
+/**
+ * Operator to restrict results to only arrays that include a value matching the given pattern.
+ */
+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,91 @@
+"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;
+/**
+ * Operator to restrict results to only values that are greater than the given value.
+ */
+const gt = (value) => ({ $gt: value });
+exports.gt = gt;
+/**
+ * Operator to restrict results to only values that are greater than or equal to the given value.
+ */
+const ge = (value) => ({ $ge: value });
+exports.ge = ge;
+/**
+ * Operator to restrict results to only values that are greater than or equal to the given value.
+ */
+const gte = (value) => ({ $ge: value });
+exports.gte = gte;
+/**
+ * Operator to restrict results to only values that are lower than the given value.
+ */
+const lt = (value) => ({ $lt: value });
+exports.lt = lt;
+/**
+ * Operator to restrict results to only values that are lower than or equal to the given value.
+ */
+const lte = (value) => ({ $le: value });
+exports.lte = lte;
+/**
+ * Operator to restrict results to only values that are lower than or equal to the given value.
+ */
+const le = (value) => ({ $le: value });
+exports.le = le;
+/**
+ * Operator to restrict results to only values that are not null.
+ */
+const exists = (column) => ({ $exists: column });
+exports.exists = exists;
+/**
+ * Operator to restrict results to only values that are null.
+ */
+const notExists = (column) => ({ $notExists: column });
+exports.notExists = notExists;
+/**
+ * Operator to restrict results to only values that start with the given prefix.
+ */
+const startsWith = (value) => ({ $startsWith: value });
+exports.startsWith = startsWith;
+/**
+ * Operator to restrict results to only values that end with the given suffix.
+ */
+const endsWith = (value) => ({ $endsWith: value });
+exports.endsWith = endsWith;
+/**
+ * Operator to restrict results to only values that match the given pattern.
+ */
+const pattern = (value) => ({ $pattern: value });
+exports.pattern = pattern;
+/**
+ * Operator to restrict results to only values that are equal to the given value.
+ */
+const is = (value) => ({ $is: value });
+exports.is = is;
+/**
+ * Operator to restrict results to only values that are not equal to the given value.
+ */
+const isNot = (value) => ({ $isNot: value });
+exports.isNot = isNot;
+/**
+ * Operator to restrict results to only values that contain the given value.
+ */
+const contains = (value) => ({ $contains: value });
+exports.contains = contains;
+// TODO: these can only be applied to columns of type "multiple"
+/**
+ * Operator to restrict results to only arrays that include the given value.
+ */
+const includes = (value) => ({ $includes: value });
+exports.includes = includes;
+/**
+ * Operator to restrict results to only arrays that include a value matching the given substring.
+ */
+const includesSubstring = (value) => ({ $includesSubstring: value });
+exports.includesSubstring = includesSubstring;
+/**
+ * Operator to restrict results to only arrays that include a value matching the given pattern.
+ */
+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,79 @@
+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;
+}
+/**
+ * A Page contains a set of results from a query plus metadata about the retrieved
+ * set of values such as the cursor, required to retrieve additional records.
+ */
+export declare class Page<T extends XataRecord, R extends XataRecord> implements Paginable<T, R> {
+    #private;
+    /**
+     * Page metadata, required to retrieve additional records.
+     */
+    readonly meta: PaginationQueryMeta;
+    /**
+     * The set of results for this page.
+     */
+    readonly records: R[];
+    constructor(query: Query<T, R>, meta: PaginationQueryMeta, records?: R[]);
+    /**
+     * Retrieves the next page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The next page or results.
+     */
+    nextPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    /**
+     * Retrieves the previous page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The previous page or results.
+     */
+    previousPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    /**
+     * Retrieves the first page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The first page or results.
+     */
+    firstPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    /**
+     * Retrieves the last page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The last page or results.
+     */
+    lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
+    /**
+     * Shortcut method to check if there will be additional results if the next page of results is retrieved.
+     * @returns Whether or not there will be additional results in the next page of results.
+     */
+    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,90 @@
+"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;
+/**
+ * A Page contains a set of results from a query plus metadata about the retrieved
+ * set of values such as the cursor, required to retrieve additional records.
+ */
+class Page {
+    constructor(query, meta, records = []) {
+        _Page_query.set(this, void 0);
+        __classPrivateFieldSet(this, _Page_query, query, "f");
+        this.meta = meta;
+        this.records = records;
+    }
+    /**
+     * Retrieves the next page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The next page or results.
+     */
+    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 } });
+        });
+    }
+    /**
+     * Retrieves the previous page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The previous page or results.
+     */
+    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 } });
+        });
+    }
+    /**
+     * Retrieves the first page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The first page or results.
+     */
+    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 } });
+        });
+    }
+    /**
+     * Retrieves the last page of results.
+     * @param size Maximum number of results to be retrieved.
+     * @param offset Number of results to skip when retrieving the results.
+     * @returns The last page or results.
+     */
+    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
+    /**
+     * Shortcut method to check if there will be additional results if the next page of results is retrieved.
+     * @returns Whether or not there will be additional results in the next page of results.
+     */
+    hasNextPage() {
+        return this.meta.page.more;
+    }
+}
+exports.Page = Page;
+_Page_query = new WeakMap();

package/dist/schema/query.d.ts

@@ -0,0 +1,114 @@
+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 extends XataRecord> = {
+    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;
+};
+/**
+ * Query objects contain the information of all filters, sorting, etc. to be included in the database query.
+ *
+ * Query objects are immutable. Any method that adds more constraints or options to the query will return
+ * a new Query object containing the both the previous and the new constraints and options.
+ */
+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;
+    /**
+     * Builds a new query object representing a logical OR between the given subqueries.
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
+    any(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object representing a logical AND between the given subqueries.
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
+    all(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object representing a logical OR negating each subquery. In pseudo-code: !q1 OR !q2
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
+    not(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object representing a logical AND negating each subquery. In pseudo-code: !q1 AND !q2
+     * @param queries An array of subqueries.
+     * @returns A new Query object.
+     */
+    none(...queries: Query<T, R>[]): Query<T, R>;
+    /**
+     * Builds a new query object adding one or more constraints. Examples:
+     *
+     * ```
+     * query.filter("columnName", columnValue)
+     * query.filter({
+     *   "columnName": columnValue
+     * })
+     * query.filter({
+     *   "columnName": operator(columnValue) // Use gt, gte, lt, lte, startsWith,...
+     * })
+     * ```
+     *
+     * @param constraints
+     * @returns A new Query object.
+     */
+    filter(constraints: FilterConstraints<T>): Query<T, R>;
+    filter<F extends keyof Selectable<T>>(column: F, value: FilterConstraints<T[F]> | DeepConstraint<T[F]>): Query<T, R>;
+    /**
+     * Builds a new query with a new sort option.
+     * @param column The column name.
+     * @param direction The direction. Either ascending or descending.
+     * @returns A new Query object.
+     */
+    sort<F extends keyof T>(column: F, direction: SortDirection): Query<T, R>;
+    /**
+     * Builds a new query specifying the set of columns to be returned in the query response.
+     * @param columns Array of column names to be returned by the query.
+     * @returns A new Query object.
+     */
+    select<K extends SelectableColumn<T>>(columns: K[]): Query<T, Select<T, K>>;
+    getPaginated<Options extends QueryOptions<T>>(options?: Options): Promise<Page<T, typeof options extends {
+        columns: SelectableColumn<T>[];
+    } ? Select<T, typeof options['columns'][number]> : R>>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<R>;
+    getIterator(chunk: number, options?: Omit<QueryOptions<T>, 'page'>): AsyncGenerator<R[]>;
+    /**
+     * Performs the query in the database and returns a set of results.
+     * @param options Additional options to be used when performing the query.
+     * @returns An array of records from the database.
+     */
+    getMany<Options extends QueryOptions<T>>(options?: Options): Promise<(typeof options extends {
+        columns: SelectableColumn<T>[];
+    } ? Select<T, typeof options['columns'][number]> : R)[]>;
+    /**
+     * Performs the query in the database and returns the first result.
+     * @param options Additional options to be used when performing the query.
+     * @returns The first record that matches the query, or null if no record matched the query.
+     */
+    getOne<Options extends Omit<QueryOptions<T>, 'page'>>(options?: Options): Promise<(typeof options extends {
+        columns: 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;
+}