@xata.io/client 0.5.1 → 0.6.0

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,18 @@
 # @xata.io/client
 
+## 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/fetcher.js

@@ -10,12 +10,14 @@ 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 */
+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 +53,21 @@ 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 withStatus({ message, errors }, response.status);
         }
         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') {
+            if (isError(e)) {
                 throw withStatus(e, response.status);
             }
             else {
-                throw withStatus(fallbackError, response.status);
+                throw withStatus({ message: 'Network response was not ok' }, response.status);
             }
         }
     });
 }
 exports.fetch = fetch;
-const withStatus = (error, status) => (Object.assign(Object.assign({}, error), { status }));
+const isError = (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 }));

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/filters.d.ts

@@ -1,12 +1,14 @@
+import { XataRecord } from './record';
+import { SelectableColumn } from './selection';
 export declare type SortDirection = 'asc' | 'desc';
-export declare type SortFilterExtended<T> = {
-    column: keyof T;
+export declare type SortFilterExtended<T extends XataRecord> = {
+    column: SelectableColumn<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 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>(filter?: SortFilter<T> | SortFilter<T>[]): {
+export declare function buildSortFilter<T extends XataRecord>(filter?: SortFilter<T> | SortFilter<T>[]): {
     [key: string]: SortDirection;
 } | undefined;
 export declare type Constraint<T> = {

package/dist/schema/filters.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildSortFilter = exports.isSortFilterObject = void 0;
+const lang_1 = require("../util/lang");
 function isSortFilterObject(filter) {
-    return typeof filter === 'object' && filter.column !== undefined;
+    return (0, lang_1.isObject)(filter) && filter.column !== undefined;
 }
 exports.isSortFilterObject = isSortFilterObject;
 function buildSortFilter(filter) {

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; } });

package/dist/schema/pagination.d.ts

@@ -6,20 +6,20 @@ export declare type PaginationQueryMeta = {
         more: boolean;
     };
 };
-export interface Paginable<T extends XataRecord, R extends XataRecord = T> {
+export interface Paginable<Record extends XataRecord, Result extends XataRecord = Record> {
     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>>;
+    records: Result[];
+    nextPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
+    previousPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
+    firstPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
+    lastPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
     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 = T> implements Paginable<T, R> {
+export declare class Page<Record extends XataRecord, Result extends XataRecord = Record> implements Paginable<Record, Result> {
     #private;
     /**
      * Page metadata, required to retrieve additional records.
@@ -28,36 +28,36 @@ export declare class Page<T extends XataRecord, R extends XataRecord = T> implem
     /**
      * The set of results for this page.
      */
-    readonly records: R[];
-    constructor(query: Query<T, R>, meta: PaginationQueryMeta, records?: R[]);
+    readonly records: Result[];
+    constructor(query: Query<Record, Result>, meta: PaginationQueryMeta, records?: Result[]);
     /**
      * 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>>;
+    nextPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
     /**
      * 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>>;
+    previousPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
     /**
      * 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>>;
+    firstPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
     /**
      * 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>>;
+    lastPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
     /**
      * 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.

package/dist/schema/pagination.js

@@ -77,7 +77,6 @@ class Page {
             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.

package/dist/schema/query.d.ts

@@ -1,56 +1,52 @@
-import { ColumnsFilter, FilterExpression, PageConfig, SortExpression } from '../api/schemas';
+import { FilterExpression } from '../api/schemas';
+import { NonEmptyArray, RequiredBy } from '../util/types';
 import { DeepConstraint, FilterConstraints, SortDirection, SortFilter } from './filters';
 import { Page, Paginable, PaginationOptions, PaginationQueryMeta } from './pagination';
 import { XataRecord } from './record';
 import { Repository } from './repository';
-import { Select, Selectable, SelectableColumn } from './selection';
+import { SelectableColumn, SelectedPick, ValueAtColumn } from './selection';
 export declare type QueryOptions<T extends XataRecord> = {
     page?: PaginationOptions;
-    columns?: Extract<keyof Selectable<T>, string>[];
+    columns?: NonEmptyArray<SelectableColumn<T>>;
+    filter?: FilterExpression;
     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> {
+export declare class Query<Record extends XataRecord, Result extends XataRecord = Record> implements Paginable<Record, Result> {
     #private;
     readonly meta: PaginationQueryMeta;
-    readonly records: R[];
-    constructor(repository: Repository<T> | null, table: string, data: Partial<QueryTableOptions>, parent?: Partial<QueryTableOptions>);
-    getQueryOptions(): QueryTableOptions;
+    readonly records: Result[];
+    constructor(repository: Repository<Record> | null, table: string, data: Partial<QueryOptions<Record>>, parent?: Partial<QueryOptions<Record>>);
+    getQueryOptions(): QueryOptions<Record>;
     /**
      * 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>;
+    any(...queries: Query<Record, Result>[]): Query<Record, Result>;
     /**
      * 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>;
+    all(...queries: Query<Record, Result>[]): Query<Record, Result>;
     /**
      * 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>;
+    not(...queries: Query<Record, Result>[]): Query<Record, Result>;
     /**
      * 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>;
+    none(...queries: Query<Record, Result>[]): Query<Record, Result>;
     /**
      * Builds a new query object adding one or more constraints. Examples:
      *
@@ -67,63 +63,56 @@ export declare class Query<T extends XataRecord, R extends XataRecord = T> imple
      * @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>;
+    filter(constraints: FilterConstraints<Record>): Query<Record, Result>;
+    filter<F extends SelectableColumn<Record>>(column: F, value: FilterConstraints<ValueAtColumn<Record, F>> | DeepConstraint<ValueAtColumn<Record, F>>): Query<Record, Result>;
     /**
      * 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>;
+    sort<F extends SelectableColumn<Record>>(column: F, direction: SortDirection): Query<Record, Result>;
     /**
      * 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, GetWithColumnOptions<T, R, typeof options>>>;
-    [Symbol.asyncIterator](): AsyncIterableIterator<R>;
-    getIterator<Options extends QueryOptions<T>>(chunk: number, options?: Omit<Options, 'page'>): AsyncGenerator<GetWithColumnOptions<T, R, typeof options>[]>;
+    select<K extends SelectableColumn<Record>>(columns: NonEmptyArray<K>): Query<Record, SelectedPick<Record, NonEmptyArray<K>>>;
+    getPaginated(): Promise<Page<Record, Result>>;
+    getPaginated(options: Omit<QueryOptions<Record>, 'columns'>): Promise<Page<Record, Result>>;
+    getPaginated<Options extends RequiredBy<QueryOptions<Record>, 'columns'>>(options: Options): Promise<Page<Record, SelectedPick<Record, typeof options['columns']>>>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Result>;
+    getIterator(chunk: number): AsyncGenerator<Result[]>;
+    getIterator(chunk: number, options: Omit<QueryOptions<Record>, 'columns' | 'page'>): AsyncGenerator<Result[]>;
+    getIterator<Options extends RequiredBy<Omit<QueryOptions<Record>, 'page'>, 'columns'>>(chunk: number, options: Options): AsyncGenerator<SelectedPick<Record, typeof options['columns']>[]>;
     /**
      * 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<GetWithColumnOptions<T, R, typeof options>[]>;
+    getMany(): Promise<Result[]>;
+    getMany(options: Omit<QueryOptions<Record>, 'columns'>): Promise<Result[]>;
+    getMany<Options extends RequiredBy<QueryOptions<Record>, 'columns'>>(options: Options): Promise<SelectedPick<Record, typeof options['columns']>[]>;
     /**
      * Performs the query in the database and returns all the results.
      * Warning: If there are a large number of results, this method can have performance implications.
      * @param options Additional options to be used when performing the query.
      * @returns An array of records from the database.
      */
-    getAll<Options extends QueryOptions<T>>(chunk?: number, options?: Omit<Options, 'page'>): Promise<GetWithColumnOptions<T, R, typeof options>[]>;
+    getAll(chunk?: number): Promise<Result[]>;
+    getAll(chunk: number | undefined, options: Omit<QueryOptions<Record>, 'columns' | 'page'>): Promise<Result[]>;
+    getAll<Options extends RequiredBy<Omit<QueryOptions<Record>, 'page'>, 'columns'>>(chunk: number | undefined, options: Options): Promise<SelectedPick<Record, typeof options['columns']>[]>;
     /**
      * 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<GetWithColumnOptions<T, R, typeof options> | 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>>;
+    getOne(): Promise<Result | null>;
+    getOne(options: Omit<QueryOptions<Record>, 'columns' | 'page'>): Promise<Result | null>;
+    getOne<Options extends RequiredBy<Omit<QueryOptions<Record>, 'page'>, 'columns'>>(options: Options): Promise<SelectedPick<Record, typeof options['columns']> | null>;
+    nextPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
+    previousPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
+    firstPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
+    lastPage(size?: number, offset?: number): Promise<Page<Record, Result>>;
     hasNextPage(): boolean;
 }
-/**
- * Helper type to read options and compute the correct type for the result values
- * T: Original type
- * R: Default destination type
- * Options: QueryOptions
- *
- * If the columns are overriden in the options, the result type is the pick of the original type and the columns
- * If the columns are not overriden, the result type is the default destination type
- */
-declare type GetWithColumnOptions<T, R, Options> = Options extends {
-    columns: SelectableColumn<T>[];
-} ? Select<T, Options['columns'][number]> : R;
-export {};

package/dist/schema/query.js

@@ -51,7 +51,7 @@ const pagination_1 = require("./pagination");
  */
 class Query {
     constructor(repository, table, data, parent) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t;
         _Query_table.set(this, void 0);
         _Query_repository.set(this, void 0);
         _Query_data.set(this, { filter: {} });
@@ -65,12 +65,14 @@ class Query {
         else {
             __classPrivateFieldSet(this, _Query_repository, this, "f");
         }
-        __classPrivateFieldGet(this, _Query_data, "f").filter.$any = (_b = (_a = data.filter) === null || _a === void 0 ? void 0 : _a.$any) !== null && _b !== void 0 ? _b : (_c = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _c === void 0 ? void 0 : _c.$any;
-        __classPrivateFieldGet(this, _Query_data, "f").filter.$all = (_e = (_d = data.filter) === null || _d === void 0 ? void 0 : _d.$all) !== null && _e !== void 0 ? _e : (_f = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _f === void 0 ? void 0 : _f.$all;
-        __classPrivateFieldGet(this, _Query_data, "f").filter.$not = (_h = (_g = data.filter) === null || _g === void 0 ? void 0 : _g.$not) !== null && _h !== void 0 ? _h : (_j = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _j === void 0 ? void 0 : _j.$not;
-        __classPrivateFieldGet(this, _Query_data, "f").filter.$none = (_l = (_k = data.filter) === null || _k === void 0 ? void 0 : _k.$none) !== null && _l !== void 0 ? _l : (_m = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _m === void 0 ? void 0 : _m.$none;
-        __classPrivateFieldGet(this, _Query_data, "f").sort = (_o = data.sort) !== null && _o !== void 0 ? _o : parent === null || parent === void 0 ? void 0 : parent.sort;
-        __classPrivateFieldGet(this, _Query_data, "f").columns = (_q = (_p = data.columns) !== null && _p !== void 0 ? _p : parent === null || parent === void 0 ? void 0 : parent.columns) !== null && _q !== void 0 ? _q : ['*'];
+        __classPrivateFieldGet(this, _Query_data, "f").filter = (_b = (_a = data.filter) !== null && _a !== void 0 ? _a : parent === null || parent === void 0 ? void 0 : parent.filter) !== null && _b !== void 0 ? _b : {};
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$any = (_d = (_c = data.filter) === null || _c === void 0 ? void 0 : _c.$any) !== null && _d !== void 0 ? _d : (_e = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _e === void 0 ? void 0 : _e.$any;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$all = (_g = (_f = data.filter) === null || _f === void 0 ? void 0 : _f.$all) !== null && _g !== void 0 ? _g : (_h = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _h === void 0 ? void 0 : _h.$all;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$not = (_k = (_j = data.filter) === null || _j === void 0 ? void 0 : _j.$not) !== null && _k !== void 0 ? _k : (_l = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _l === void 0 ? void 0 : _l.$not;
+        __classPrivateFieldGet(this, _Query_data, "f").filter.$none = (_o = (_m = data.filter) === null || _m === void 0 ? void 0 : _m.$none) !== null && _o !== void 0 ? _o : (_p = parent === null || parent === void 0 ? void 0 : parent.filter) === null || _p === void 0 ? void 0 : _p.$none;
+        __classPrivateFieldGet(this, _Query_data, "f").sort = (_q = data.sort) !== null && _q !== void 0 ? _q : parent === null || parent === void 0 ? void 0 : parent.sort;
+        __classPrivateFieldGet(this, _Query_data, "f").columns = (_s = (_r = data.columns) !== null && _r !== void 0 ? _r : parent === null || parent === void 0 ? void 0 : parent.columns) !== null && _s !== void 0 ? _s : ['*'];
+        __classPrivateFieldGet(this, _Query_data, "f").page = (_t = data.page) !== null && _t !== void 0 ? _t : parent === null || parent === void 0 ? void 0 : parent.page;
         this.any = this.any.bind(this);
         this.all = this.all.bind(this);
         this.not = this.not.bind(this);
@@ -89,7 +91,7 @@ class Query {
      * @returns A new Query object.
      */
     any(...queries) {
-        const $any = queries.map((query) => query.getQueryOptions().filter);
+        const $any = queries.map((query) => { var _a; return (_a = query.getQueryOptions().filter) !== null && _a !== void 0 ? _a : {}; });
         return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $any } }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     /**
@@ -98,7 +100,7 @@ class Query {
      * @returns A new Query object.
      */
     all(...queries) {
-        const $all = queries.map((query) => query.getQueryOptions().filter);
+        const $all = queries.map((query) => { var _a; return (_a = query.getQueryOptions().filter) !== null && _a !== void 0 ? _a : {}; });
         return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     /**
@@ -107,7 +109,7 @@ class Query {
      * @returns A new Query object.
      */
     not(...queries) {
-        const $not = queries.map((query) => query.getQueryOptions().filter);
+        const $not = queries.map((query) => { var _a; return (_a = query.getQueryOptions().filter) !== null && _a !== void 0 ? _a : {}; });
         return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $not } }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     /**
@@ -116,19 +118,18 @@ class Query {
      * @returns A new Query object.
      */
     none(...queries) {
-        const $none = queries.map((query) => query.getQueryOptions().filter);
+        const $none = queries.map((query) => { var _a; return (_a = query.getQueryOptions().filter) !== null && _a !== void 0 ? _a : {}; });
         return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $none } }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     filter(a, b) {
+        var _a, _b;
         if (arguments.length === 1) {
             const constraints = Object.entries(a).map(([column, constraint]) => ({ [column]: constraint }));
-            const $all = (0, lang_1.compact)([__classPrivateFieldGet(this, _Query_data, "f").filter.$all].flat().concat(constraints));
+            const $all = (0, lang_1.compact)([(_a = __classPrivateFieldGet(this, _Query_data, "f").filter) === null || _a === void 0 ? void 0 : _a.$all].flat().concat(constraints));
             return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
         }
         else {
-            const column = a;
-            const value = b;
-            const $all = (0, lang_1.compact)([__classPrivateFieldGet(this, _Query_data, "f").filter.$all].flat().concat({ [column]: value }));
+            const $all = (0, lang_1.compact)([(_b = __classPrivateFieldGet(this, _Query_data, "f").filter) === null || _b === void 0 ? void 0 : _b.$all].flat().concat([{ [a]: b }]));
             return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { filter: { $all } }, __classPrivateFieldGet(this, _Query_data, "f"));
         }
     }
@@ -139,7 +140,9 @@ class Query {
      * @returns A new Query object.
      */
     sort(column, direction) {
-        const sort = Object.assign(Object.assign({}, __classPrivateFieldGet(this, _Query_data, "f").sort), { [column]: direction });
+        var _a;
+        const originalSort = [(_a = __classPrivateFieldGet(this, _Query_data, "f").sort) !== null && _a !== void 0 ? _a : []].flat();
+        const sort = [...originalSort, { column, direction }];
         return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { sort }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     /**
@@ -151,7 +154,8 @@ class Query {
         return new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), { columns }, __classPrivateFieldGet(this, _Query_data, "f"));
     }
     getPaginated(options = {}) {
-        return __classPrivateFieldGet(this, _Query_repository, "f").query(this, options);
+        const query = new Query(__classPrivateFieldGet(this, _Query_repository, "f"), __classPrivateFieldGet(this, _Query_table, "f"), options, __classPrivateFieldGet(this, _Query_data, "f"));
+        return __classPrivateFieldGet(this, _Query_repository, "f").query(query);
     }
     [(_Query_table = new WeakMap(), _Query_repository = new WeakMap(), _Query_data = new WeakMap(), Symbol.asyncIterator)]() {
         return __asyncGenerator(this, arguments, function* _a() {
@@ -177,29 +181,20 @@ class Query {
             let end = false;
             while (!end) {
                 const { records, meta } = yield __await(this.getPaginated(Object.assign(Object.assign({}, options), { page: { size: chunk, offset } })));
+                // Method overloading does not provide type inference for the return type.
                 yield yield __await(records);
                 offset += chunk;
                 end = !meta.page.more;
             }
         });
     }
-    /**
-     * 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 = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const { records } = yield this.getPaginated(options);
+            // Method overloading does not provide type inference for the return type.
             return records;
         });
     }
-    /**
-     * Performs the query in the database and returns all the results.
-     * Warning: If there are a large number of results, this method can have performance implications.
-     * @param options Additional options to be used when performing the query.
-     * @returns An array of records from the database.
-     */
     getAll(chunk = pagination_1.PAGINATION_MAX_SIZE, options = {}) {
         var e_2, _a;
         return __awaiter(this, void 0, void 0, function* () {
@@ -217,24 +212,17 @@ class Query {
                 }
                 finally { if (e_2) throw e_2.error; }
             }
+            // Method overloading does not provide type inference for the return type.
             return results;
         });
     }
-    /**
-     * 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 = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const records = yield this.getMany(Object.assign(Object.assign({}, options), { page: { size: 1 } }));
+            // Method overloading does not provide type inference for the return type.
             return records[0] || null;
         });
     }
-    /**async deleteAll(): Promise<number> {
-      // TODO: Return number of affected rows
-      return 0;
-    }**/
     nextPage(size, offset) {
         return this.firstPage(size, offset);
     }

package/dist/schema/record.d.ts

@@ -1,4 +1,4 @@
-import { Selectable } from './selection';
+import { SelectedPick } from './selection';
 /**
  * Represents an identifiable record from the database.
  */
@@ -27,14 +27,14 @@ export interface XataRecord extends Identifiable {
     /**
      * Retrieves a refreshed copy of the current record from the database.
      */
-    read(): Promise<this>;
+    read(): Promise<SelectedPick<this, ['*']> | null>;
     /**
      * Performs a partial update of the current record. On success a new object is
      * returned and the current object is not mutated.
      * @param data The columns and their values that have to be updated.
      * @returns A new record containing the latest values for all the columns of the current record.
      */
-    update(data: Partial<Selectable<this>>): Promise<this>;
+    update(data: Partial<EditableData<Omit<this, keyof XataRecord>>>): Promise<SelectedPick<this, ['*']>>;
     /**
      * Performs a deletion of the current record in the database.
      *
@@ -42,3 +42,25 @@ export interface XataRecord extends Identifiable {
      */
     delete(): Promise<void>;
 }
+export declare type Link<Record extends XataRecord> = Omit<XataRecord, 'read' | 'update'> & {
+    /**
+     * Retrieves a refreshed copy of the current record from the database.
+     */
+    read(): Promise<SelectedPick<Record, ['*']> | null>;
+    /**
+     * Performs a partial update of the current record. On success a new object is
+     * returned and the current object is not mutated.
+     * @param data The columns and their values that have to be updated.
+     * @returns A new record containing the latest values for all the columns of the current record.
+     */
+    update(data: Partial<EditableData<Omit<Record, keyof XataRecord>>>): Promise<SelectedPick<Record, ['*']>>;
+};
+export declare function isIdentifiable(x: any): x is Identifiable & Record<string, unknown>;
+export declare function isXataRecord(x: any): x is XataRecord & Record<string, unknown>;
+export declare type EditableData<O extends BaseData> = {
+    [K in keyof O]: O[K] extends XataRecord ? {
+        id: string;
+    } : NonNullable<O[K]> extends XataRecord ? {
+        id: string;
+    } | undefined : O[K];
+};

package/dist/schema/record.js

@@ -1,2 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isXataRecord = exports.isIdentifiable = void 0;
+const lang_1 = require("../util/lang");
+function isIdentifiable(x) {
+    return (0, lang_1.isObject)(x) && (0, lang_1.isString)(x === null || x === void 0 ? void 0 : x.id);
+}
+exports.isIdentifiable = isIdentifiable;
+function isXataRecord(x) {
+    var _a;
+    return (isIdentifiable(x) && typeof (x === null || x === void 0 ? void 0 : x.xata) === 'object' && typeof ((_a = x === null || x === void 0 ? void 0 : x.xata) === null || _a === void 0 ? void 0 : _a.version) === 'number');
+}
+exports.isXataRecord = isXataRecord;

package/dist/schema/repository.d.ts

@@ -1,77 +1,73 @@
 import { FetchImpl } from '../api/fetcher';
 import { Page } from './pagination';
-import { Query, QueryOptions } from './query';
-import { BaseData, XataRecord } from './record';
-import { Select, SelectableColumn } from './selection';
+import { Query } from './query';
+import { BaseData, EditableData, Identifiable, XataRecord } from './record';
+import { SelectedPick } from './selection';
 export declare type Links = Record<string, Array<string[]>>;
 /**
  * Common interface for performing operations on a table.
  */
-export declare abstract class Repository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record> {
-    abstract create(object: Data): Promise<Record>;
+export declare abstract class Repository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, SelectedPick<Record, ['*']>> {
+    abstract create(object: EditableData<Data> & Partial<Identifiable>): Promise<SelectedPick<Record, ['*']>>;
+    /**
+     * Creates a single record in the table with a unique id.
+     * @param id The unique id.
+     * @param object Object containing the column names with their values to be stored in the table.
+     * @returns The full persisted record.
+     */
+    abstract create(id: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     /**
      * Creates multiple records in the table.
      * @param objects Array of objects with the column names and the values to be stored in the table.
      * @returns Array of the persisted records.
      */
-    abstract createMany(objects: Data[]): Promise<Record[]>;
+    abstract createMany(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
     /**
      * Queries a single record from the table given its unique id.
      * @param id The unique id.
      * @returns The persisted record for the given id or null if the record could not be found.
      */
-    abstract read(id: string): Promise<Record | null>;
-    /**
-     * Insert a single record with a unique id.
-     * @param id The unique id.
-     * @param object Object containing the column names with their values to be stored in the table.
-     * @returns The full persisted record.
-     */
-    abstract insert(id: string, object: Data): Promise<Record>;
+    abstract read(id: string): Promise<SelectedPick<Record, ['*']> | null>;
     /**
      * Partially update a single record given its unique id.
      * @param id The unique id.
      * @param object The column names and their values that have to be updatd.
      * @returns The full persisted record.
      */
-    abstract update(id: string, object: Partial<Data>): Promise<Record>;
+    abstract update(id: string, object: Partial<EditableData<Data>>): Promise<SelectedPick<Record, ['*']>>;
     /**
-     * Updates or inserts a single record. If a record exists with the given id,
+     * Creates or updates a single record. If a record exists with the given id,
      * it will be update, otherwise a new record will be created.
      * @param id A unique id.
      * @param object The column names and the values to be persisted.
      * @returns The full persisted record.
      */
-    abstract updateOrInsert(id: string, object: Data): Promise<Record>;
+    abstract createOrUpdate(id: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     /**
      * Deletes a record given its unique id.
      * @param id The unique id.
      * @throws If the record could not be found or there was an error while performing the deletion.
      */
     abstract delete(id: string): void;
-    abstract query<Result extends XataRecord, Options extends QueryOptions<Record>>(query: Query<Record, Result>, options: Options): Promise<Page<Record, typeof options extends {
-        columns: SelectableColumn<Data>[];
-    } ? Select<Data, typeof options['columns'][number]> : Result>>;
+    abstract query<Result extends XataRecord>(query: Query<Record, Result>): Promise<Page<Record, Result>>;
 }
-export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Repository<Data, Record> {
+export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record, SelectedPick<Record, ['*']>> {
     #private;
     constructor(client: BaseClient<any>, table: string);
-    create(object: Data): Promise<Record>;
-    createMany(objects: Data[]): Promise<Record[]>;
-    read(recordId: string): Promise<Record | null>;
-    update(recordId: string, object: Partial<Data>): Promise<Record>;
-    insert(recordId: string, object: Data): Promise<Record>;
-    updateOrInsert(recordId: string, object: Data): Promise<Record>;
+    create(object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
+    create(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
+    createMany(objects: EditableData<Data>[]): Promise<SelectedPick<Record, ['*']>[]>;
+    read(recordId: string): Promise<SelectedPick<Record, ['*']> | null>;
+    update(recordId: string, object: Partial<EditableData<Data>>): Promise<SelectedPick<Record, ['*']>>;
+    createOrUpdate(recordId: string, object: EditableData<Data>): Promise<SelectedPick<Record, ['*']>>;
     delete(recordId: string): Promise<void>;
-    query<Result extends XataRecord, Options extends QueryOptions<Record>>(query: Query<Record, Result>, options?: Options): Promise<Page<Record, typeof options extends {
-        columns: SelectableColumn<Data>[];
-    } ? Select<Data, typeof options['columns'][number]> : Result>>;
+    query<Result extends XataRecord>(query: Query<Record, Result>): Promise<Page<Record, Result>>;
 }
 interface RepositoryFactory {
-    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data>;
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data & XataRecord>;
 }
 export declare class RestRespositoryFactory implements RepositoryFactory {
-    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data>;
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data & XataRecord>;
 }
 declare type BranchStrategyValue = string | undefined | null;
 declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;

package/dist/schema/repository.js

@@ -26,20 +26,22 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
     function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
 };
-var _RestRepository_instances, _RestRepository_client, _RestRepository_fetch, _RestRepository_table, _RestRepository_getFetchProps, _BaseClient_links, _BaseClient_branch;
+var _RestRepository_instances, _RestRepository_client, _RestRepository_fetch, _RestRepository_table, _RestRepository_getFetchProps, _RestRepository_insertRecordWithoutId, _RestRepository_insertRecordWithId, _BaseClient_links, _BaseClient_branch;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = void 0;
 const api_1 = require("../api");
+const lang_1 = require("../util/lang");
 const filters_1 = require("./filters");
 const pagination_1 = require("./pagination");
 const query_1 = require("./query");
+const record_1 = require("./record");
 /**
  * Common interface for performing operations on a table.
  */
 class Repository extends query_1.Query {
 }
 exports.Repository = Repository;
-class RestRepository extends Repository {
+class RestRepository extends query_1.Query {
     constructor(client, table) {
         var _a;
         super(null, table, {});
@@ -58,20 +60,24 @@ class RestRepository extends Repository {
         }
         __classPrivateFieldSet(this, _RestRepository_fetch, fetchImpl, "f");
     }
-    create(object) {
+    create(a, b) {
         return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
-            const record = transformObjectLinks(object);
-            const response = yield (0, api_1.insertRecord)(Object.assign({ pathParams: {
-                    workspace: '{workspaceId}',
-                    dbBranchName: '{dbBranch}',
-                    tableName: __classPrivateFieldGet(this, _RestRepository_table, "f")
-                }, body: record }, fetchProps));
-            const finalObject = yield this.read(response.id);
-            if (!finalObject) {
-                throw new Error('The server failed to save the record');
+            if ((0, lang_1.isString)(a) && (0, lang_1.isObject)(b)) {
+                if (a === '')
+                    throw new Error("The id can't be empty");
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_insertRecordWithId).call(this, a, b);
+            }
+            else if ((0, lang_1.isObject)(a) && (0, lang_1.isString)(a.id)) {
+                if (a.id === '')
+                    throw new Error("The id can't be empty");
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_insertRecordWithId).call(this, a.id, Object.assign(Object.assign({}, a), { id: undefined }));
+            }
+            else if ((0, lang_1.isObject)(a)) {
+                return __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_insertRecordWithoutId).call(this, a);
+            }
+            else {
+                throw new Error('Invalid arguments for create method');
             }
-            return finalObject;
         });
     }
     createMany(objects) {
@@ -86,6 +92,7 @@ class RestRepository extends Repository {
             return finalObjects;
         });
     }
+    // TODO: Add column support: https://github.com/xataio/openapi/issues/139
     read(recordId) {
         return __awaiter(this, void 0, void 0, function* () {
             const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
@@ -96,31 +103,15 @@ class RestRepository extends Repository {
     update(recordId, object) {
         return __awaiter(this, void 0, void 0, function* () {
             const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
-            const response = yield (0, api_1.updateRecordWithID)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId }, body: object }, fetchProps));
+            const record = transformObjectLinks(object);
+            const response = yield (0, api_1.updateRecordWithID)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId }, body: record }, fetchProps));
             const item = yield this.read(response.id);
             if (!item)
                 throw new Error('The server failed to save the record');
             return item;
         });
     }
-    insert(recordId, object) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
-            const record = transformObjectLinks(object);
-            const response = yield (0, api_1.insertRecordWithID)(Object.assign({ pathParams: {
-                    workspace: '{workspaceId}',
-                    dbBranchName: '{dbBranch}',
-                    tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"),
-                    recordId
-                }, body: record }, fetchProps));
-            const finalObject = yield this.read(response.id);
-            if (!finalObject) {
-                throw new Error('The server failed to save the record');
-            }
-            return finalObject;
-        });
-    }
-    updateOrInsert(recordId, object) {
+    createOrUpdate(recordId, object) {
         return __awaiter(this, void 0, void 0, function* () {
             const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
             const response = yield (0, api_1.upsertRecordWithID)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId }, body: object }, fetchProps));
@@ -136,20 +127,19 @@ class RestRepository extends Repository {
             yield (0, api_1.deleteRecord)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"), recordId } }, fetchProps));
         });
     }
-    query(query, options = {}) {
-        var _a, _b, _c;
+    query(query) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             const data = query.getQueryOptions();
             const body = {
-                filter: Object.values(data.filter).some(Boolean) ? data.filter : undefined,
-                sort: (_a = (0, filters_1.buildSortFilter)(options === null || options === void 0 ? void 0 : options.sort)) !== null && _a !== void 0 ? _a : data.sort,
-                page: (_b = options === null || options === void 0 ? void 0 : options.page) !== null && _b !== void 0 ? _b : data.page,
-                columns: (_c = options === null || options === void 0 ? void 0 : options.columns) !== null && _c !== void 0 ? _c : data.columns
+                filter: Object.values((_a = data.filter) !== null && _a !== void 0 ? _a : {}).some(Boolean) ? data.filter : undefined,
+                sort: (0, filters_1.buildSortFilter)(data.sort),
+                page: data.page,
+                columns: data.columns
             };
             const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
             const { meta, records: objects } = yield (0, api_1.queryTable)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f") }, body }, fetchProps));
             const records = objects.map((record) => __classPrivateFieldGet(this, _RestRepository_client, "f").initObject(__classPrivateFieldGet(this, _RestRepository_table, "f"), record));
-            // TODO: We should properly type this any
             return new pagination_1.Page(query, meta, records);
         });
     }
@@ -172,6 +162,37 @@ _RestRepository_client = new WeakMap(), _RestRepository_fetch = new WeakMap(), _
             }
         };
     });
+}, _RestRepository_insertRecordWithoutId = function _RestRepository_insertRecordWithoutId(object) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+        const record = transformObjectLinks(object);
+        const response = yield (0, api_1.insertRecord)(Object.assign({ pathParams: {
+                workspace: '{workspaceId}',
+                dbBranchName: '{dbBranch}',
+                tableName: __classPrivateFieldGet(this, _RestRepository_table, "f")
+            }, body: record }, fetchProps));
+        const finalObject = yield this.read(response.id);
+        if (!finalObject) {
+            throw new Error('The server failed to save the record');
+        }
+        return finalObject;
+    });
+}, _RestRepository_insertRecordWithId = function _RestRepository_insertRecordWithId(recordId, object) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
+        const record = transformObjectLinks(object);
+        const response = yield (0, api_1.insertRecordWithID)(Object.assign({ pathParams: {
+                workspace: '{workspaceId}',
+                dbBranchName: '{dbBranch}',
+                tableName: __classPrivateFieldGet(this, _RestRepository_table, "f"),
+                recordId
+            }, body: record, queryParams: { createOnly: true } }, fetchProps));
+        const finalObject = yield this.read(response.id);
+        if (!finalObject) {
+            throw new Error('The server failed to save the record');
+        }
+        return finalObject;
+    });
 };
 class RestRespositoryFactory {
     createRepository(client, table) {
@@ -198,43 +219,31 @@ class BaseClient {
         });
     }
     initObject(table, object) {
-        const o = {};
-        Object.assign(o, object);
+        const result = {};
+        Object.assign(result, object);
         const tableLinks = __classPrivateFieldGet(this, _BaseClient_links, "f")[table] || [];
         for (const link of tableLinks) {
             const [field, linkTable] = link;
-            const value = o[field];
-            if (value && typeof value === 'object') {
-                const { id } = value;
-                if (Object.keys(value).find((col) => col === 'id')) {
-                    o[field] = this.initObject(linkTable, value);
-                }
-                else if (id) {
-                    o[field] = {
-                        id,
-                        get: () => {
-                            this.db[linkTable].read(id);
-                        }
-                    };
-                }
+            const value = result[field];
+            if (value && (0, lang_1.isObject)(value)) {
+                result[field] = this.initObject(linkTable, value);
             }
         }
         const db = this.db;
-        o.read = function () {
-            return db[table].read(o['id']);
+        result.read = function () {
+            return db[table].read(result['id']);
         };
-        o.update = function (data) {
-            return db[table].update(o['id'], data);
+        result.update = function (data) {
+            return db[table].update(result['id'], data);
         };
-        o.delete = function () {
-            return db[table].delete(o['id']);
+        result.delete = function () {
+            return db[table].delete(result['id']);
         };
         for (const prop of ['read', 'update', 'delete']) {
-            Object.defineProperty(o, prop, { enumerable: false });
+            Object.defineProperty(result, prop, { enumerable: false });
         }
-        // TODO: links and rev links
-        Object.freeze(o);
-        return o;
+        Object.freeze(result);
+        return result;
     }
     getBranch() {
         var e_1, _a;
@@ -272,12 +281,8 @@ _BaseClient_links = new WeakMap(), _BaseClient_branch = new WeakMap();
 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 });
+        return Object.assign(Object.assign({}, acc), { [key]: (0, record_1.isIdentifiable)(value) ? value.id : value });
     }, {});
 };

package/dist/schema/selection.d.ts

@@ -1,12 +1,24 @@
-import { StringKeys, UnionToIntersection, Values } from '../util/types';
-import { Query } from './query';
-import { BaseData, Identifiable, XataRecord } from './record';
-declare type Queries<T> = {
-    [key in keyof T as T[key] extends Query<any, any> ? key : never]: T[key];
-};
-export declare type Selectable<T extends BaseData> = T & Partial<Identifiable>;
-export declare type SelectableColumn<O> = '*' | (O extends Array<unknown> ? never : O extends Record<string, any> ? '*' | Values<{
-    [K in StringKeys<O>]: O[K] extends Record<string, any> ? `${K}.${SelectableColumn<O[K]>}` : K;
-}> : '');
-export declare type Select<T, K extends SelectableColumn<T>> = UnionToIntersection<K extends keyof T ? Pick<T, K> : T> & Queries<T> & XataRecord;
+import { If, IsArray, IsObject, StringKeys, UnionToIntersection, Values } from '../util/types';
+import { Link, XataRecord } from './record';
+export declare type SelectableColumn<O, RecursivePath extends any[] = []> = '*' | 'id' | DataProps<O> | NestedColumns<O, RecursivePath>;
+export declare type SelectedPick<O extends XataRecord, Key extends SelectableColumn<O>[]> = XataRecord & UnionToIntersection<Values<{
+    [K in Key[number]]: NestedValueAtColumn<O, K> & XataRecord;
+}>>;
+export declare type ValueAtColumn<O extends XataRecord, P extends SelectableColumn<O>> = P extends '*' ? Values<O> : P extends 'id' ? string : P extends keyof O ? O[P] : P extends `${infer K}.${infer V}` ? K extends keyof O ? Values<O[K] extends XataRecord ? (V extends SelectableColumn<O[K]> ? {
+    V: ValueAtColumn<O[K], V>;
+} : never) : O[K]> : never : never;
+declare type MAX_RECURSION = 5;
+declare type NestedColumns<O, RecursivePath extends any[]> = RecursivePath['length'] extends MAX_RECURSION ? never : If<IsObject<O>, Values<{
+    [K in DataProps<O>]: If<IsArray<NonNullable<O[K]>>, K, // If the property is an array, we stop recursion. We don't support object arrays yet
+    If<IsObject<NonNullable<O[K]>>, NonNullable<O[K]> extends XataRecord ? SelectableColumn<NonNullable<O[K]>, [...RecursivePath, O[K]]> extends string ? K | `${K}.${SelectableColumn<NonNullable<O[K]>, [...RecursivePath, O[K]]>}` : never : `${K}.${StringKeys<NonNullable<O[K]>> | '*'}`, // This allows usage of objects that are not links
+    K>>;
+}>, never>;
+declare type DataProps<O> = Exclude<StringKeys<O>, StringKeys<XataRecord>>;
+declare type NestedValueAtColumn<O, Key extends SelectableColumn<O>> = Key extends `${infer N}.${infer M}` ? N extends DataProps<O> ? {
+    [K in N]: M extends SelectableColumn<NonNullable<O[K]>> ? NestedValueAtColumn<NonNullable<O[K]>, M> & XataRecord : unknown;
+} : unknown : Key extends DataProps<O> ? {
+    [K in Key]: NonNullable<O[K]> extends XataRecord ? SelectedPick<NonNullable<O[K]>, ['*']> : O[K];
+} : Key extends '*' ? {
+    [K in keyof NonNullable<O>]: NonNullable<NonNullable<O>[K]> extends XataRecord ? NonNullable<O>[K] extends XataRecord ? Link<NonNullable<O>[K]> : Link<NonNullable<NonNullable<O>[K]>> | null : NonNullable<O>[K];
+} : unknown;
 export {};

package/dist/schema/selection.spec.d.ts

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

package/dist/schema/selection.spec.js

@@ -0,0 +1,109 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-floating-promises */
+Object.defineProperty(exports, "__esModule", { value: true });
+//                              SelectableColumn<O>                            //
+// --------------------------------------------------------------------------- //
+const validTeamColumns = [
+    '*',
+    'id',
+    'name',
+    'owner.*',
+    'owner.address.*',
+    'owner.address',
+    'owner.address.street'
+];
+// @ts-expect-error
+const invalidFullNameTeamColumn = 'full_name';
+// @ts-expect-error
+const invalidPartialTeamColumn = 'owner.address.';
+// @ts-expect-error
+const invalidDeleteTeamColumn = 'owner.delete';
+// @ts-expect-error
+const invalidReadTeamColumn = 'owner.read.*';
+//                              ValueAtColumn<O, P>                            //
+// --------------------------------------------------------------------------- //
+const labelsValue = ['foo'];
+// @ts-expect-error
+const invalidLabelsValue = [1];
+//                            SelectedRecordPick<O, Key>                        //
+// ---------------------------------------------------------------------------- //
+function selectedRecordPickTest1(selectedUserBaseRecord) {
+    var _a, _b, _c, _d;
+    selectedUserBaseRecord.id;
+    selectedUserBaseRecord.read();
+    selectedUserBaseRecord.full_name;
+    (_a = selectedUserBaseRecord.address) === null || _a === void 0 ? void 0 : _a.street;
+    // @ts-expect-error
+    selectedUserBaseRecord.team.id;
+    (_b = selectedUserBaseRecord.team) === null || _b === void 0 ? void 0 : _b.id;
+    (_c = selectedUserBaseRecord.team) === null || _c === void 0 ? void 0 : _c.read();
+    // @ts-expect-error
+    (_d = selectedUserBaseRecord.team) === null || _d === void 0 ? void 0 : _d.name;
+    selectedUserBaseRecord.owner.id;
+    selectedUserBaseRecord.owner.read();
+    // @ts-expect-error
+    selectedUserBaseRecord.owner.full_name;
+}
+function selectedRecordPickTest2(selectedUserFullRecord) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    selectedUserFullRecord.id;
+    selectedUserFullRecord.read();
+    selectedUserFullRecord.full_name;
+    (_a = selectedUserFullRecord.team) === null || _a === void 0 ? void 0 : _a.id;
+    (_b = selectedUserFullRecord.team) === null || _b === void 0 ? void 0 : _b.read();
+    (_c = selectedUserFullRecord.team) === null || _c === void 0 ? void 0 : _c.name;
+    (_d = selectedUserFullRecord.team) === null || _d === void 0 ? void 0 : _d.owner;
+    (_f = (_e = selectedUserFullRecord.team) === null || _e === void 0 ? void 0 : _e.owner) === null || _f === void 0 ? void 0 : _f.id;
+    (_h = (_g = selectedUserFullRecord.team) === null || _g === void 0 ? void 0 : _g.owner) === null || _h === void 0 ? void 0 : _h.read();
+    // @ts-expect-error
+    (_k = (_j = selectedUserFullRecord.team) === null || _j === void 0 ? void 0 : _j.owner) === null || _k === void 0 ? void 0 : _k.full_name;
+    // @ts-expect-error
+    selectedUserFullRecord.full_name = null;
+    selectedUserFullRecord.email = null;
+    selectedUserFullRecord.email = '';
+    // @ts-expect-error
+    selectedUserFullRecord.email = 2;
+    if (selectedUserFullRecord.team) {
+        // @ts-expect-error
+        selectedUserFullRecord.team.name = null;
+        selectedUserFullRecord.team.labels = null;
+        selectedUserFullRecord.team.labels = ['foo'];
+        // @ts-expect-error
+        selectedUserFullRecord.team.labels = [1];
+    }
+}
+function selectedRecordPickTest3(selectedUserNestedRecord) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+    selectedUserNestedRecord.id;
+    selectedUserNestedRecord.read();
+    // @ts-expect-error
+    selectedUserNestedRecord.full_name;
+    (_a = selectedUserNestedRecord.team) === null || _a === void 0 ? void 0 : _a.id;
+    (_b = selectedUserNestedRecord.team) === null || _b === void 0 ? void 0 : _b.read();
+    // @ts-expect-error
+    (_c = selectedUserNestedRecord.team) === null || _c === void 0 ? void 0 : _c.name;
+    (_e = (_d = selectedUserNestedRecord.team) === null || _d === void 0 ? void 0 : _d.owner) === null || _e === void 0 ? void 0 : _e.id;
+    (_g = (_f = selectedUserNestedRecord.team) === null || _f === void 0 ? void 0 : _f.owner) === null || _g === void 0 ? void 0 : _g.read();
+    (_j = (_h = selectedUserNestedRecord.team) === null || _h === void 0 ? void 0 : _h.owner) === null || _j === void 0 ? void 0 : _j.full_name;
+}
+function selectedRecordPickTest4(selectedUserNestedRecord) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+    selectedUserNestedRecord.id;
+    selectedUserNestedRecord.read();
+    // @ts-expect-error
+    selectedUserNestedRecord.full_name;
+    (_a = selectedUserNestedRecord.team) === null || _a === void 0 ? void 0 : _a.id;
+    (_b = selectedUserNestedRecord.team) === null || _b === void 0 ? void 0 : _b.read();
+    // @ts-expect-error
+    (_c = selectedUserNestedRecord.team) === null || _c === void 0 ? void 0 : _c.name;
+    (_e = (_d = selectedUserNestedRecord.team) === null || _d === void 0 ? void 0 : _d.owner) === null || _e === void 0 ? void 0 : _e.id;
+    (_g = (_f = selectedUserNestedRecord.team) === null || _f === void 0 ? void 0 : _f.owner) === null || _g === void 0 ? void 0 : _g.read();
+    // @ts-expect-error
+    (_j = (_h = selectedUserNestedRecord.team) === null || _h === void 0 ? void 0 : _h.owner) === null || _j === void 0 ? void 0 : _j.full_name;
+    (_l = (_k = selectedUserNestedRecord.team) === null || _k === void 0 ? void 0 : _k.owner) === null || _l === void 0 ? void 0 : _l.address;
+    (_p = (_o = (_m = selectedUserNestedRecord.team) === null || _m === void 0 ? void 0 : _m.owner) === null || _o === void 0 ? void 0 : _o.address) === null || _p === void 0 ? void 0 : _p.street;
+    (_s = (_r = (_q = selectedUserNestedRecord.team) === null || _q === void 0 ? void 0 : _q.owner) === null || _r === void 0 ? void 0 : _r.address) === null || _s === void 0 ? void 0 : _s.zipcode;
+}
+test('fake test', () => {
+    // This is a fake test to make sure that the type definitions in this file are working
+});

package/dist/util/lang.d.ts

@@ -1,2 +1,5 @@
 export declare function compact<T>(arr: Array<T | null | undefined>): T[];
+export declare function compactObject<T>(obj: Record<string, T | null | undefined>): Record<string, T>;
 export declare type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export declare function isObject(value: any): value is object;
+export declare function isString(value: any): value is string;

package/dist/util/lang.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compact = void 0;
+exports.isString = exports.isObject = exports.compactObject = exports.compact = void 0;
 function notEmpty(value) {
     return value !== null && value !== undefined;
 }
@@ -8,3 +8,15 @@ function compact(arr) {
     return arr.filter(notEmpty);
 }
 exports.compact = compact;
+function compactObject(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, value]) => notEmpty(value)));
+}
+exports.compactObject = compactObject;
+function isObject(value) {
+    return value !== undefined && value !== null && typeof value === 'object';
+}
+exports.isObject = isObject;
+function isString(value) {
+    return value !== undefined && value !== null && typeof value === 'string';
+}
+exports.isString = isString;

package/dist/util/types.d.ts

@@ -1,3 +1,13 @@
 export declare type StringKeys<O> = Extract<keyof O, string>;
-export declare type Values<O> = O[keyof O];
+export declare type NumberKeys<O> = Extract<keyof O, number>;
+export declare type Values<O> = O[StringKeys<O>];
 export declare type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+export declare type If<Condition, Then, Else> = Condition extends true ? Then : Else;
+export declare type IsObject<T> = T extends Record<string, any> ? true : false;
+export declare type IsArray<T> = T extends Array<any> ? true : false;
+export declare type NonEmptyArray<T> = T[] & {
+    0: T;
+};
+export declare type RequiredBy<T, K extends keyof T> = T & {
+    [P in K]-?: NonNullable<T[P]>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Xata.io SDK for TypeScript and JavaScript",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,5 +20,5 @@
     "url": "https://github.com/xataio/client-ts/issues"
   },
   "homepage": "https://github.com/xataio/client-ts/blob/main/client/README.md",
-  "gitHead": "09892c40a01ece59c802844310aac17aba7a281c"
+  "gitHead": "f46df88912b2bac2ddae598d9d08efc1f44b00be"
 }