@xata.io/client 0.0.0-beta.f46df88 → 0.0.0-beta.f65b504

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @xata.io/client
 
+## 0.7.2
+
+### Patch Changes
+
+- 4803b6f: Memoize ApiClient namespaces
+- 1f268d7: Add search in XataClient
+- d58c3d9: Hide private helper utilities
+- f3b731b: Expose branch resolution API
+
+## 0.7.1
+
+### Patch Changes
+
+- 01aef78: Fix bundle for browsers
+- 56be1fd: Allow sending updates with link object
+- fc51771: Add includes operator helper methods
+
+## 0.7.0
+
+### Minor Changes
+
+- 6ce5512: Add bulk operations for all methods
+- 2a1fa4f: Introduced automatic branch resolution mechanism
+
+### Patch Changes
+
+- d033f3a: Improve column selection output type with non-nullable columns
+- b1e92db: Include stack trace with errors
+- deed570: Improve sorting with multiple properties
+- 80b5417: Improve filtering types
+
 ## 0.6.0
 
 ### Minor Changes

package/dist/api/client.d.ts

@@ -5,7 +5,7 @@ import type * as Responses from './responses';
 import type * as Schemas from './schemas';
 export interface XataApiClientOptions {
     fetch?: FetchImpl;
-    apiKey: string;
+    apiKey?: string;
     host?: HostProvider;
 }
 export declare class XataApiClient {

package/dist/api/client.js

@@ -10,50 +10,63 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _XataApiClient_extraProps;
+var _XataApiClient_extraProps, _XataApiClient_namespaces;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XataApiClient = void 0;
+const config_1 = require("../util/config");
+const fetch_1 = require("../util/fetch");
 const components_1 = require("./components");
 const providers_1 = require("./providers");
 class XataApiClient {
     constructor(options) {
         var _a, _b;
         _XataApiClient_extraProps.set(this, void 0);
-        const globalFetch = typeof fetch !== 'undefined' ? fetch : undefined;
-        const fetchImpl = (_a = options.fetch) !== null && _a !== void 0 ? _a : 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.`);
+        _XataApiClient_namespaces.set(this, {});
+        const provider = (_a = options.host) !== null && _a !== void 0 ? _a : 'production';
+        const apiKey = (_b = options === null || options === void 0 ? void 0 : options.apiKey) !== null && _b !== void 0 ? _b : (0, config_1.getAPIKey)();
+        if (!apiKey) {
+            throw new Error('Could not resolve a valid apiKey');
         }
-        const provider = (_b = options.host) !== null && _b !== void 0 ? _b : 'production';
         __classPrivateFieldSet(this, _XataApiClient_extraProps, {
             apiUrl: (0, providers_1.getHostUrl)(provider, 'main'),
             workspacesApiUrl: (0, providers_1.getHostUrl)(provider, 'workspaces'),
-            fetchImpl,
-            apiKey: options.apiKey
+            fetchImpl: (0, fetch_1.getFetchImplementation)(options.fetch),
+            apiKey
         }, "f");
     }
     get user() {
-        return new UserApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user = new UserApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").user;
     }
     get workspaces() {
-        return new WorkspaceApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces = new WorkspaceApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").workspaces;
     }
     get databases() {
-        return new DatabaseApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases = new DatabaseApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").databases;
     }
     get branches() {
-        return new BranchApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches = new BranchApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").branches;
     }
     get tables() {
-        return new TableApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables = new TableApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").tables;
     }
     get records() {
-        return new RecordsApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        if (!__classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records)
+            __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records = new RecordsApi(__classPrivateFieldGet(this, _XataApiClient_extraProps, "f"));
+        return __classPrivateFieldGet(this, _XataApiClient_namespaces, "f").records;
     }
 }
 exports.XataApiClient = XataApiClient;
-_XataApiClient_extraProps = new WeakMap();
+_XataApiClient_extraProps = new WeakMap(), _XataApiClient_namespaces = new WeakMap();
 class UserApi {
     constructor(extraProps) {
         this.extraProps = extraProps;
@@ -221,7 +234,9 @@ class RecordsApi {
     deleteRecord(workspace, database, branch, tableName, recordId) {
         return components_1.operationsByTag.records.deleteRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId } }, this.extraProps));
     }
-    getRecord(workspace, database, branch, tableName, recordId, options = {}) {
+    getRecord(workspace, database, branch, tableName, recordId, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    options = {}) {
         return components_1.operationsByTag.records.getRecord(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}`, tableName, recordId } }, this.extraProps));
     }
     bulkInsertTableRecords(workspace, database, branch, tableName, records) {

package/dist/api/components.d.ts

@@ -990,8 +990,9 @@ export declare type QueryTableVariables = {
  *       },
  *       {
  *         "name": "r2",
- *       },
- *     ],
+ *       }
+ *     ]
+ *   }
  * }
  * ```
  *
@@ -1001,7 +1002,7 @@ export declare type QueryTableVariables = {
  * {
  *   "filter": {
  *     "$exists": "settings",
- *   },
+ *   }
  * }
  * ```
  *
@@ -1016,8 +1017,8 @@ export declare type QueryTableVariables = {
  *       },
  *       {
  *         "$exists": "name",
- *       },
- *     ],
+ *       }
+ *     ]
  *   }
  * }
  * ```
@@ -1028,7 +1029,7 @@ export declare type QueryTableVariables = {
  * {
  *   "filter": {
  *     "$notExists": "settings",
- *   },
+ *   }
  * }
  * ```
  *

package/dist/api/components.js

@@ -573,8 +573,9 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  *       },
  *       {
  *         "name": "r2",
- *       },
- *     ],
+ *       }
+ *     ]
+ *   }
  * }
  * ```
  *
@@ -584,7 +585,7 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * {
  *   "filter": {
  *     "$exists": "settings",
- *   },
+ *   }
  * }
  * ```
  *
@@ -599,8 +600,8 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  *       },
  *       {
  *         "$exists": "name",
- *       },
- *     ],
+ *       }
+ *     ]
  *   }
  * }
  * ```
@@ -611,7 +612,7 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * {
  *   "filter": {
  *     "$notExists": "settings",
- *   },
+ *   }
  * }
  * ```
  *

package/dist/api/fetcher.d.ts

@@ -23,3 +23,18 @@ export declare type FetcherOptions<TBody, THeaders, TQueryParams, TPathParams> =
     pathParams?: TPathParams;
 };
 export declare function fetch<TData, TBody extends Record<string, unknown> | undefined, THeaders extends Record<string, unknown>, TQueryParams extends Record<string, unknown>, TPathParams extends Record<string, string>>({ url: path, method, body, headers, pathParams, queryParams, fetchImpl, apiKey, apiUrl, workspacesApiUrl }: FetcherOptions<TBody, THeaders, TQueryParams, TPathParams> & FetcherExtraProps): Promise<TData>;
+export declare class FetcherError extends Error {
+    status: number;
+    errors: Array<{
+        status: number;
+        message?: string;
+    }> | undefined;
+    constructor(data: {
+        message: string;
+        status: number;
+        errors?: Array<{
+            status: number;
+            message?: string;
+        }>;
+    }, parent?: Error);
+}

package/dist/api/fetcher.js

@@ -9,9 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = void 0;
-/* eslint-disable @typescript-eslint/no-throw-literal */
-/* eslint-disable @typescript-eslint/ban-types */
+exports.FetcherError = exports.fetch = void 0;
 const lang_1 = require("../util/lang");
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
     const query = new URLSearchParams(queryParams).toString();
@@ -54,20 +52,28 @@ function fetch({ url: path, method, body, headers, pathParams, queryParams, fetc
                 return jsonResponse;
             }
             const { message = 'Unknown error', errors } = jsonResponse;
-            throw withStatus({ message, errors }, response.status);
+            throw new FetcherError({ message, status: response.status, errors });
         }
-        catch (e) {
-            if (isError(e)) {
-                throw withStatus(e, response.status);
-            }
-            else {
-                throw withStatus({ message: 'Network response was not ok' }, response.status);
-            }
+        catch (error) {
+            const message = hasMessage(error) ? error.message : 'Unknown network error';
+            const parent = error instanceof Error ? error : undefined;
+            throw new FetcherError({ message, status: response.status }, parent);
         }
     });
 }
 exports.fetch = fetch;
-const isError = (error) => {
+const hasMessage = (error) => {
     return (0, lang_1.isObject)(error) && (0, lang_1.isString)(error.message);
 };
-const withStatus = (error, status) => (0, lang_1.compactObject)(Object.assign(Object.assign({}, error), { status }));
+class FetcherError extends Error {
+    constructor(data, parent) {
+        super(data.message);
+        this.status = data.status;
+        this.errors = data.errors;
+        if (parent) {
+            this.stack = parent.stack;
+            this.cause = parent.cause;
+        }
+    }
+}
+exports.FetcherError = FetcherError;

package/dist/client.d.ts

@@ -0,0 +1,39 @@
+import { FetchImpl } from './api/fetcher';
+import { Namespace } from './namespace';
+import { SchemaNamespace } from './schema';
+import { BaseData } from './schema/record';
+import { LinkDictionary } from './schema/repository';
+import { SearchNamespace } from './search';
+import { BranchStrategyOption } from './util/branches';
+import { StringKeys } from './util/types';
+export declare type BaseClientOptions = {
+    fetch?: FetchImpl;
+    apiKey?: string;
+    databaseURL?: string;
+    branch?: BranchStrategyOption;
+};
+export declare const buildClientWithNamespaces: <ExternalNamespaces extends Record<string, Namespace>>(namespaces: ExternalNamespaces) => <Schemas extends Record<string, BaseData>>() => WrapperConstructor<Schemas, {
+    db: SchemaNamespace<Schemas>;
+    search: SearchNamespace<Schemas>;
+}, ExternalNamespaces>;
+export declare const buildClient: <Schemas extends Record<string, BaseData>, ExternalNamespaces extends Record<string, Namespace> = {}, Namespaces extends Record<string, Namespace> = {
+    db: SchemaNamespace<Schemas>;
+    search: SearchNamespace<Schemas>;
+}>(external?: ExternalNamespaces | undefined) => WrapperConstructor<Schemas, Namespaces, ExternalNamespaces>;
+export interface WrapperConstructor<Schemas extends Record<string, BaseData> = Record<string, any>, Namespaces extends Record<string, Namespace> = {
+    db: SchemaNamespace<Schemas>;
+    search: SearchNamespace<Schemas>;
+}, ExternalNamespaces extends Record<string, Namespace> = Record<string, Namespace>> {
+    new (options?: Partial<BaseClientOptions>, links?: LinkDictionary): {
+        [Key in StringKeys<Namespaces>]: ReturnType<Namespaces[Key]['build']>;
+    } & {
+        [Key in StringKeys<NonNullable<ExternalNamespaces>>]: ReturnType<NonNullable<ExternalNamespaces>[Key]['build']>;
+    };
+}
+declare const BaseClient_base: WrapperConstructor<Record<string, any>, {
+    db: SchemaNamespace<Record<string, any>>;
+    search: SearchNamespace<Record<string, any>>;
+}, {}>;
+export declare class BaseClient extends BaseClient_base {
+}
+export {};

package/dist/client.js

@@ -0,0 +1,124 @@
+"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 __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 __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 __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); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseClient = exports.buildClient = exports.buildClientWithNamespaces = void 0;
+const schema_1 = require("./schema");
+const search_1 = require("./search");
+const branches_1 = require("./util/branches");
+const config_1 = require("./util/config");
+const fetch_1 = require("./util/fetch");
+const buildClientWithNamespaces = (namespaces) => () => (0, exports.buildClient)(namespaces);
+exports.buildClientWithNamespaces = buildClientWithNamespaces;
+const buildClient = (external) => {
+    var _instances, _branch, _parseOptions, _getFetchProps, _evaluateBranch, _a;
+    return _a = class {
+            constructor(options = {}, links) {
+                _instances.add(this);
+                _branch.set(this, void 0);
+                const safeOptions = __classPrivateFieldGet(this, _instances, "m", _parseOptions).call(this, options);
+                const namespaces = Object.assign({ db: new schema_1.SchemaNamespace(links), search: new search_1.SearchNamespace() }, external);
+                for (const [key, namespace] of Object.entries(namespaces)) {
+                    if (!namespace)
+                        continue;
+                    // @ts-ignore
+                    this[key] = namespace.build({ getFetchProps: () => __classPrivateFieldGet(this, _instances, "m", _getFetchProps).call(this, safeOptions) });
+                }
+            }
+        },
+        _branch = new WeakMap(),
+        _instances = new WeakSet(),
+        _parseOptions = function _parseOptions(options) {
+            const fetch = (0, fetch_1.getFetchImplementation)(options === null || options === void 0 ? void 0 : options.fetch);
+            const databaseURL = (options === null || options === void 0 ? void 0 : options.databaseURL) || (0, config_1.getDatabaseURL)();
+            const apiKey = (options === null || options === void 0 ? void 0 : options.apiKey) || (0, config_1.getAPIKey)();
+            const branch = () => __awaiter(this, void 0, void 0, function* () {
+                return (options === null || options === void 0 ? void 0 : options.branch)
+                    ? yield __classPrivateFieldGet(this, _instances, "m", _evaluateBranch).call(this, options.branch)
+                    : yield (0, config_1.getCurrentBranchName)({ apiKey, databaseURL, fetchImpl: options === null || options === void 0 ? void 0 : options.fetch });
+            });
+            if (!databaseURL || !apiKey) {
+                throw new Error('Options databaseURL and apiKey are required');
+            }
+            return { fetch, databaseURL, apiKey, branch };
+        },
+        _getFetchProps = function _getFetchProps({ fetch, apiKey, databaseURL, branch }) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const branchValue = yield __classPrivateFieldGet(this, _instances, "m", _evaluateBranch).call(this, branch);
+                if (!branchValue)
+                    throw new Error('Unable to resolve branch value');
+                return {
+                    fetchImpl: fetch,
+                    apiKey,
+                    apiUrl: '',
+                    // Instead of using workspace and dbBranch, we inject a probably CNAME'd URL
+                    workspacesApiUrl: (path, params) => {
+                        var _a;
+                        const hasBranch = (_a = params.dbBranchName) !== null && _a !== void 0 ? _a : params.branch;
+                        const newPath = path.replace(/^\/db\/[^/]+/, hasBranch ? `:${branchValue}` : '');
+                        return databaseURL + newPath;
+                    }
+                };
+            });
+        },
+        _evaluateBranch = function _evaluateBranch(param) {
+            var e_1, _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                if (__classPrivateFieldGet(this, _branch, "f"))
+                    return __classPrivateFieldGet(this, _branch, "f");
+                if (!param)
+                    return undefined;
+                const strategies = Array.isArray(param) ? [...param] : [param];
+                const evaluateBranch = (strategy) => __awaiter(this, void 0, void 0, function* () {
+                    return (0, branches_1.isBranchStrategyBuilder)(strategy) ? yield strategy() : strategy;
+                });
+                try {
+                    for (var strategies_1 = __asyncValues(strategies), strategies_1_1; strategies_1_1 = yield strategies_1.next(), !strategies_1_1.done;) {
+                        const strategy = strategies_1_1.value;
+                        const branch = yield evaluateBranch(strategy);
+                        if (branch) {
+                            __classPrivateFieldSet(this, _branch, branch, "f");
+                            return branch;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (strategies_1_1 && !strategies_1_1.done && (_a = strategies_1.return)) yield _a.call(strategies_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            });
+        },
+        _a;
+};
+exports.buildClient = buildClient;
+class BaseClient extends (0, exports.buildClient)() {
+}
+exports.BaseClient = BaseClient;

package/dist/index.d.ts

@@ -3,4 +3,7 @@ export declare class XataError extends Error {
     constructor(message: string, status: number);
 }
 export * from './api';
+export * from './client';
 export * from './schema';
+export * from './search';
+export * from './util/config';

package/dist/index.js

@@ -23,4 +23,7 @@ class XataError extends Error {
 }
 exports.XataError = XataError;
 __exportStar(require("./api"), exports);
+__exportStar(require("./client"), exports);
 __exportStar(require("./schema"), exports);
+__exportStar(require("./search"), exports);
+__exportStar(require("./util/config"), exports);

package/dist/namespace.d.ts

@@ -0,0 +1,7 @@
+import { FetcherExtraProps } from './api/fetcher';
+export declare abstract class Namespace {
+    abstract build(options: NamespaceBuildOptions): unknown;
+}
+export declare type NamespaceBuildOptions = {
+    getFetchProps: () => Promise<FetcherExtraProps>;
+};

package/dist/namespace.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Namespace = void 0;
+class Namespace {
+}
+exports.Namespace = Namespace;

package/dist/schema/filters.d.ts

@@ -1,22 +1,96 @@
-import { XataRecord } from './record';
-import { SelectableColumn } from './selection';
-export declare type SortDirection = 'asc' | 'desc';
-export declare type SortFilterExtended<T extends XataRecord> = {
-    column: SelectableColumn<T>;
-    direction?: SortDirection;
+import { SingleOrArray } from '../util/types';
+import { SelectableColumn, ValueAtColumn } from './selection';
+/**
+ * PropertyMatchFilter
+ * Example:
+{
+  "filter": {
+    "name": "value",
+    "name": {
+       "$is":  "value",
+       "$any": [ "value1", "value2" ],
+    },
+    "settings.plan": {"$any": ["free", "paid"]},
+    "settings.plan": "free",
+    "settings": {
+      "plan": "free"
+    },
+  }
+}
+*/
+declare type PropertyAccessFilter<Record> = {
+    [key in SelectableColumn<Record>]?: NestedApiFilter<ValueAtColumn<Record, key>> | PropertyFilter<ValueAtColumn<Record, key>>;
 };
-export declare type SortFilter<T extends XataRecord> = SelectableColumn<T> | SortFilterExtended<T>;
-export declare function isSortFilterObject<T extends XataRecord>(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 extends XataRecord>(filter?: SortFilter<T> | SortFilter<T>[]): {
-    [key: string]: SortDirection;
-} | undefined;
-export declare type Constraint<T> = {
-    [key in FilterOperator]?: T;
+export declare type PropertyFilter<T> = T | {
+    $is: T;
+} | {
+    $isNot: T;
+} | {
+    $any: T[];
+} | {
+    $none: T[];
+} | ValueTypeFilters<T>;
+declare type IncludesFilter<T> = PropertyFilter<T> | {
+    [key in '$all' | '$none' | '$any']?: IncludesFilter<T> | Array<IncludesFilter<T> | {
+        $not: IncludesFilter<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]>;
+export declare type StringTypeFilter = {
+    [key in '$contains' | '$pattern' | '$startsWith' | '$endsWith']?: string;
 };
+export declare type ComparableType = number | Date;
+export declare type ComparableTypeFilter<T extends ComparableType> = {
+    [key in '$gt' | '$lt' | '$ge' | '$le']?: T;
+};
+export declare type ArrayFilter<T> = {
+    [key in '$includes']?: SingleOrArray<PropertyFilter<T> | ValueTypeFilters<T>> | IncludesFilter<T>;
+} | {
+    [key in '$includesAll' | '$includesNone' | '$includesAny']?: T | Array<PropertyFilter<T> | {
+        $not: PropertyFilter<T>;
+    }>;
+};
+declare type ValueTypeFilters<T> = T | T extends string ? StringTypeFilter : T extends number ? ComparableTypeFilter<number> : T extends Date ? ComparableTypeFilter<Date> : T extends Array<infer T> ? ArrayFilter<T> : never;
+/**
+ * AggregatorFilter
+ * Example:
+{
+  "filter": {
+      "$any": {
+        "settings.dark": true,
+        "settings.plan": "free"
+      }
+  },
+}
+{
+  "filter": {
+    "$any": [
+      {
+        "name": "r1",
+      },
+      {
+        "name": "r2",
+      },
+    ],
+}
+*/
+declare type AggregatorFilter<Record> = {
+    [key in '$all' | '$any' | '$not' | '$none']?: SingleOrArray<Filter<Record>>;
+};
+/**
+ * Existance filter
+ * Example: { filter: { $exists: "settings" } }
+ */
+export declare type ExistanceFilter<Record> = {
+    [key in '$exists' | '$notExists']?: SelectableColumn<Record>;
+};
+declare type BaseApiFilter<Record> = PropertyAccessFilter<Record> | AggregatorFilter<Record> | ExistanceFilter<Record>;
+/**
+ * Nested filter
+ * Injects the Api filters on nested properties
+ * Example: { filter: { settings: { plan: { $any: ['free', 'trial'] } } } }
+ */
+declare type NestedApiFilter<T> = T extends Record<string, any> ? {
+    [key in keyof T]?: T[key] extends Record<string, any> ? SingleOrArray<Filter<T[key]>> : PropertyFilter<T[key]>;
+} : PropertyFilter<T>;
+export declare type Filter<Record> = BaseApiFilter<Record> | NestedApiFilter<Record>;
+export {};

package/dist/schema/filters.js

@@ -1,25 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildSortFilter = exports.isSortFilterObject = void 0;
-const lang_1 = require("../util/lang");
-function isSortFilterObject(filter) {
-    return (0, lang_1.isObject)(filter) && 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/filters.spec.d.ts

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