@xata.io/client 0.0.0-beta.09892c4 → 0.0.0-beta.09bfef8

package/.eslintrc.cjs

@@ -0,0 +1,13 @@
+module.exports = {
+  ignorePatterns: ["dist"],
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+    project: 'client/tsconfig.json'
+  },
+  rules: {
+    '@typescript-eslint/no-explicit-any': 'off',
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/no-floating-promises': 'error',
+  }
+};

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @xata.io/client
 
+## 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
+
+- 084f5df: Add type inference for columns
+- bb73c89: Unify create and insert in a single method overload
+
+### Patch Changes
+
+- 716c487: Forward nullable types on links
+- bb66bb2: Fix error handling with createMany
+- 084f5df: Fix circular dependencies on selectable column
+
 ## 0.5.1
 
 ### Patch 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

@@ -13,24 +13,24 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _XataApiClient_extraProps;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XataApiClient = void 0;
+const config_1 = require("../schema/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.`);
+        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() {
@@ -221,7 +221,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/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,13 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetch = void 0;
+exports.FetcherError = exports.fetch = void 0;
+const lang_1 = require("../util/lang");
 const resolveUrl = (url, queryParams = {}, pathParams = {}) => {
     const query = new URLSearchParams(queryParams).toString();
     const queryString = query.length > 0 ? `?${query}` : '';
     return url.replace(/\{\w*\}/g, (key) => pathParams[key.slice(1, -1)]) + queryString;
 };
-const fallbackError = { message: 'Network response was not ok' };
 function buildBaseUrl({ path, workspacesApiUrl, apiUrl, pathParams }) {
     if (!(pathParams === null || pathParams === void 0 ? void 0 : pathParams.workspace))
         return `${apiUrl}${path}`;
@@ -51,28 +51,29 @@ function fetch({ url: path, method, body, headers, pathParams, queryParams, fetc
             if (response.ok) {
                 return jsonResponse;
             }
-            if (jsonResponse.message) {
-                throw withStatus({ message: jsonResponse.message }, response.status);
-            }
-            else {
-                throw withStatus(fallbackError, response.status);
-            }
+            const { message = 'Unknown error', errors } = jsonResponse;
+            throw new FetcherError({ message, status: response.status, errors });
         }
-        catch (e) {
-            if (e instanceof Error) {
-                const error = {
-                    message: e.message
-                };
-                throw withStatus(error, response.status);
-            }
-            else if (typeof e === 'object' && typeof e.message === 'string') {
-                throw withStatus(e, response.status);
-            }
-            else {
-                throw withStatus(fallbackError, 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 withStatus = (error, status) => (Object.assign(Object.assign({}, error), { status }));
+const hasMessage = (error) => {
+    return (0, lang_1.isObject)(error) && (0, lang_1.isString)(error.message);
+};
+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/api/providers.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getHostUrl = void 0;
+const lang_1 = require("../util/lang");
 function getHostUrl(provider, type) {
     if (isValidAlias(provider)) {
         return providers[provider][type];
@@ -22,8 +23,8 @@ const providers = {
     }
 };
 function isValidAlias(alias) {
-    return typeof alias === 'string' && Object.keys(providers).includes(alias);
+    return (0, lang_1.isString)(alias) && Object.keys(providers).includes(alias);
 }
 function isValidBuilder(builder) {
-    return typeof builder === 'object' && typeof builder.main === 'string' && typeof builder.workspaces === 'string';
+    return (0, lang_1.isObject)(builder) && (0, lang_1.isString)(builder.main) && (0, lang_1.isString)(builder.workspaces);
 }

package/dist/api/responses.d.ts

@@ -19,6 +19,12 @@ export declare type AuthError = {
     id?: string;
     message: string;
 };
+export declare type BulkError = {
+    errors: {
+        message?: string;
+        status?: number;
+    }[];
+};
 export declare type BranchMigrationPlan = {
     version: number;
     migration: Schemas.BranchMigration;

package/dist/schema/config.d.ts

@@ -0,0 +1,4 @@
+import { FetcherExtraProps } from '../api/fetcher';
+export declare function getBranch(fetchProps: Omit<FetcherExtraProps, 'workspacesApiUrl'>): Promise<string | undefined>;
+export declare function getDatabaseUrl(): string | undefined;
+export declare function getAPIKey(): string | undefined;

package/dist/schema/config.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAPIKey = exports.getDatabaseUrl = exports.getBranch = void 0;
+const api_1 = require("../api");
+const environment_1 = require("../util/environment");
+const lang_1 = require("../util/lang");
+const envBranchNames = [
+    'XATA_BRANCH',
+    'VERCEL_GIT_COMMIT_REF',
+    'CF_PAGES_BRANCH',
+    'BRANCH' // Netlify. Putting it the last one because it is more ambiguous
+];
+function getBranch(fetchProps) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const env = getBranchByEnvVariable();
+        if (env)
+            return env;
+        const branch = yield (0, environment_1.getGitBranch)();
+        if (!branch)
+            return undefined;
+        // TODO: in the future, call /resolve endpoint
+        // For now, call API to see if the branch exists. If not, use a default value.
+        const [protocol, , host, , database] = fetchProps.apiUrl.split('/');
+        const [workspace] = host.split('.');
+        const dbBranchName = `${database}:${branch}`;
+        try {
+            yield (0, api_1.getBranchDetails)(Object.assign(Object.assign({}, fetchProps), { workspacesApiUrl: `${protocol}//${host}`, pathParams: {
+                    dbBranchName,
+                    workspace
+                } }));
+        }
+        catch (err) {
+            if ((0, lang_1.isObject)(err) && err.status === 404)
+                return 'main';
+            throw err;
+        }
+        return branch;
+    });
+}
+exports.getBranch = getBranch;
+function getBranchByEnvVariable() {
+    for (const name of envBranchNames) {
+        const value = (0, environment_1.getEnvVariable)(name);
+        if (value) {
+            return value;
+        }
+    }
+    try {
+        return XATA_BRANCH;
+    }
+    catch (err) {
+        // Ignore ReferenceError. Only CloudFlare workers set env variables as global variables
+    }
+}
+function getDatabaseUrl() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_DATABASE_URL')) !== null && _a !== void 0 ? _a : XATA_DATABASE_URL;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getDatabaseUrl = getDatabaseUrl;
+function getAPIKey() {
+    var _a;
+    try {
+        return (_a = (0, environment_1.getEnvVariable)('XATA_API_KEY')) !== null && _a !== void 0 ? _a : XATA_API_KEY;
+    }
+    catch (err) {
+        return undefined;
+    }
+}
+exports.getAPIKey = getAPIKey;

package/dist/schema/filters.d.ts

@@ -1,20 +1,96 @@
-export declare type SortDirection = 'asc' | 'desc';
-export declare type SortFilterExtended<T> = {
-    column: keyof 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> = 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 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,24 +1,2 @@
 "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/filters.spec.d.ts

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

package/dist/schema/filters.spec.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Single column with implicit is
+const singleColumnWithImplicitIs = { name: 'r2' };
+// Single column with explicit is
+const singleColumnWithExplicitIs = { name: { $is: 'r2' } };
+// Is string
+const isString = { string: 'string' };
+// Is true
+const isTrue = { boolean: true };
+// Is false
+const isFalse = { boolean: false };
+// Is pos int
+const isPosInt = { number: 1234567 };
+// Is neg int
+const isNegInt = { number: -42 };
+// Is float
+const isFloat = { number: 3.14 };
+//  with dots
+const withDots = { 'settings.plan': 'free' };
+// Nested columns
+const nestedColumns = { settings: { plan: 'free' } };
+// Nested columns array
+const nestedColumnsArray = { settings: [{ dark: false }, { plan: 'free' }] };
+// Nested columns any
+const nestedColumnsAny = { settings: { $any: [{ plan: 'free' }, { plan: 'trial' }] } };
+// Nested columns any value
+const nestedColumnsAnyValue = { settings: { plan: { $any: ['free', 'trial'] } } };
+// Or with $any
+const orWithAny = { 'settings.plan': { $any: ['free', 'paid'] } };
+// Multiple columns implicit and
+const multipleColumnsImplicitAnd = { 'settings.dark': true, 'settings.plan': 'free' };
+// Explicit $all with multi-key filter list
+const explicitAllWithMultiKeyFilterList = {
+    $all: { 'settings.dark': true, 'settings.plan': 'free' }
+};
+// Explicit $all with filter list
+const explicitAllWithFilterList = {
+    $all: [{ 'settings.dark': true }, { 'settings.plan': 'free' }]
+};
+// Explicit $any with multi-key filter list
+const explicitAnyWithMultiKeyFilterList = {
+    $all: { 'settings.dark': true, 'settings.plan': 'free' }
+};
+// Explicit $any with filter list
+const explicitAnyWithFilterList = {
+    $any: [{ 'settings.dark': true }, { 'settings.plan': 'free' }]
+};
+// $any with multiple values
+const anyWithMultipleValues = { number: { $any: [1, 2, 3] } };
+// $none with multiple values
+const noneWithMultipleValues = { number: { $none: [1, 2, 3] } };
+// Exists filter
+const existsFilter = { $exists: 'test' };
+// Not exists filter
+const notExistsFilter = { $notExists: 'test' };
+// Exists with all
+const existsWithAll = { $all: [{ $exists: 'settings' }, { $exists: 'name' }] };
+// Nest any with not
+const nestAnyWithNot = { $not: { $any: { 'settings.dark': true, 'settings.plan': 'free' } } };
+// Mix $all and $any with extra keys
+const mixAllAndAnyWithExtraKeys = {
+    $all: { $any: { 'settings.dark': false, 'settings.plan': 'free' }, name: 'r1' }
+};
+// Range query with less first
+const rangeQueryWithLessFirst = { age: { $lt: 30, $ge: 20 } };
+// Range query with greater first
+const rangeQueryWithGreaterFirst = { age: { $ge: 20, $lt: 30 } };
+// Ordered op
+const orderedOp = { age: { $lt: 30 } };
+// Simple includes
+const simpleIncludes = { labels: { $includes: 'test' } };
+// Simple includes with op
+const simpleIncludesWithOp = { labels: { $includes: { $contains: 'test' } } };
+// Simple includes multiple
+const simpleIncludesMultiple = { labels: { $includes: ['a', 'b', 'c'] } };
+// Simple includes multiple with op
+const simpleIncludesMultipleWithOp = {
+    labels: { $includes: [{ $is: 'a' }, { $is: 'b' }, { $is: 'c' }] }
+};
+// Includes with many comparisons
+const includesWithManyComparisons = {
+    labels: { $includes: { $all: [{ $contains: 'a' }, { $contains: 'b' }] } }
+};
+// Simple includes multiple op and value
+const simpleIncludesMultipleOpAndValue = { labels: { $includes: [{ $contains: 'a' }, 'b'] } };
+// Includes with mode and array of filters
+const includesWithModeAndArrayOfFilters = {
+    labels: { $includesNone: [{ $contains: 'test' }, 'abc', { $endsWith: 'bad' }] }
+};
+// Includes with mix of any and all in predicate position
+const includesWithMixOfAnyAndAllInPredicatePosition = {
+    labels: { $includes: { $any: { $all: [{ $startsWith: 'test' }, { $contains: 'x' }], $any: ['a', 'b'] } } }
+};
+// Simple $includesany
+const simpleIncludesAny = { labels: { $includesAny: 'test' } };
+// Simple $includesall
+const simpleIncludesAll = { labels: { $includesAll: 'test' } };
+// Simple $includesnone
+const simpleIncludesNone = { labels: { $includesNone: 'test' } };
+// Exists value must be string not int
+// @ts-expect-error
+const existsValueMustBeStringNotInt = { $exists: 42 };
+// Exists value must be string not objct
+// @ts-expect-error
+const existsValueMustBeStringNotObject = { $exists: { field: 'settings.unknown' } };
+// Filter by one column
+const filterByOneColumn = { name: 'r1' };
+// Filter with the $is operator
+const filterWithTheIsOperator = { name: { $is: 'r1' } };
+// Filter with dot notation
+const filterWithDotNotation = { 'settings.plan': 'free' };
+// Filter with nested object
+const filterWithNestedObject = { 'settings.plan': { $is: 'free' } };
+// Filter with $any operation
+const filterWithAnyOperation = { 'settings.plan': { $any: ['free', 'paid'] } };
+// Filter with and operations
+const filterWithAndOperations = { 'settings.dark': true, 'settings.plan': 'free' };
+// Filter with both and and any operations
+const filterWithBothAndAndAnyOperations = {
+    $any: { 'settings.dark': true, 'settings.plan': 'free' }
+};
+// Filter with both and and any operations in array
+const filterWithBothAndAndAnyOperationsInArray = { $any: [{ name: 'r1' }, { name: 'r2' }] };
+// Filter with exists operation
+const filterWithExistsOperation = { $exists: 'settings' };
+// Filter with exists, and and any operations
+const filterWithExistsAndAndAnyOperations = {
+    $all: [{ $exists: 'settings' }, { $exists: 'name' }]
+};
+// Filter with not exists operation
+const filterWithNotExistsOperation = { $notExists: 'settings' };
+// Filter with partial match
+const filterWithPartialMatch = { name: { $contains: 'value' } };
+// Filter with pattern operator
+const filterWithPatternOperator = { name: { $pattern: 'value' } };
+// Filter with $startsWith and $endsWith operators
+const filterWithStartsWithAndEndsWithOperators = {
+    name: { $startsWith: 'value', $endsWith: 'value' }
+};
+// Filter with numeric ranges
+const filterWithNumericRanges = { age: { $lt: 30, $ge: 20 } };
+// Filter with negations
+const filterWithNegations = { $not: { name: 'r1' } };
+// Filter with complex negations
+const filterWithComplexNegations = { $not: { $any: [{ name: 'r1' }, { name: 'r2' }] } };
+// Filter with arrays complex negations
+const filterWithArraysComplexNegations = {
+    labels: {
+        $includes: {
+            $all: [{ $contains: 'label' }, { $not: { $endsWith: '-debug' } }]
+        }
+    }
+};
+// Filters with $includesAll
+const filtersWithIncludesAll = {
+    'settings.labels': {
+        $includesAll: [{ $contains: 'label' }]
+    }
+};
+// Filter with invalid property type
+// @ts-expect-error
+const filterWithInvalidPropertyType = { name: 42 };
+// Filter with invalid dot notation property type
+// @ts-expect-error
+const filterWithInvalidNestedPropertyType = { 'settings.plan': 42 };
+// Filter with invalid nested object property type
+// @ts-expect-error
+const filterWithInvalidNestedObjectPropertyType = { settings: { plan: 42 } };
+// Filter with invalid property $is type
+// @ts-expect-error
+const filterWithInvalidOperator = { name: { $is: 42 } };
+test('fake test', () => {
+    // This is a fake test to make sure that the type definitions in this file are working
+});

package/dist/schema/index.d.ts

@@ -1,6 +1,7 @@
 export * from './operators';
 export * from './pagination';
 export { Query } from './query';
+export { isIdentifiable, isXataRecord } from './record';
 export type { Identifiable, XataRecord } from './record';
 export { BaseClient, Repository, RestRepository, RestRespositoryFactory } from './repository';
 export type { XataClientOptions } from './repository';

package/dist/schema/index.js

@@ -14,11 +14,14 @@ 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 });
-exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = exports.BaseClient = exports.Query = void 0;
+exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = exports.BaseClient = exports.isXataRecord = exports.isIdentifiable = exports.Query = void 0;
 __exportStar(require("./operators"), exports);
 __exportStar(require("./pagination"), exports);
 var query_1 = require("./query");
 Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return query_1.Query; } });
+var record_1 = require("./record");
+Object.defineProperty(exports, "isIdentifiable", { enumerable: true, get: function () { return record_1.isIdentifiable; } });
+Object.defineProperty(exports, "isXataRecord", { enumerable: true, get: function () { return record_1.isXataRecord; } });
 var repository_1 = require("./repository");
 Object.defineProperty(exports, "BaseClient", { enumerable: true, get: function () { return repository_1.BaseClient; } });
 Object.defineProperty(exports, "Repository", { enumerable: true, get: function () { return repository_1.Repository; } });