@xata.io/client 0.0.0-beta.2b5cc25 → 0.0.0-beta.3d1e440

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,28 @@
 # @xata.io/client
 
+## 0.5.1
+
+### Patch Changes
+
+- 12729ab: Make API client fetch implementation optional
+
+## 0.5.0
+
+### Patch Changes
+
+- 14ec7d1: Fix in Selectable type
+
+## 0.4.0
+
+### Patch Changes
+
+- b951331: Add support for new float column
+- d470610: Add new getAll() method
+- eaf92a8: Expose pagination constants (size and offset limits)
+- 57fde77: Reduce subrequests for createMany
+- eaf92a8: Implement schema-less client
+- 97a3caa: Make createBranch from optional with empty branch
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/api/client.d.ts

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

package/dist/api/client.js

@@ -17,14 +17,15 @@ const components_1 = require("./components");
 const providers_1 = require("./providers");
 class XataApiClient {
     constructor(options) {
-        var _a;
+        var _a, _b;
         _XataApiClient_extraProps.set(this, void 0);
-        const fetchImpl = typeof fetch !== 'undefined' ? fetch : options.fetch;
+        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 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'),

package/dist/api/components.d.ts

@@ -875,7 +875,7 @@ export declare type QueryTableVariables = {
  *   `$none`, etc.
  *
  * All operators start with an `$` to differentiate them from column names
- * (which are not allowed to start with an underscore).
+ * (which are not allowed to start with an dollar sign).
  *
  * #### Exact matching and control operators
  *
@@ -943,27 +943,17 @@ export declare type QueryTableVariables = {
  * }
  * ```
  *
- * If you want to OR together multiple values, you can use an array of values:
+ * If you want to OR together multiple values, you can use the `$any` operator with an array of values:
  *
  * ```json
  * {
  *   "filter": {
- *     "settings.plan": ["free", "paid"]
+ *     "settings.plan": {"$any": ["free", "paid"]}
  *   },
  * }
  * ```
  *
- * Same query with `$is` operator:
- *
- * ```json
- * {
- *   "filter": {
- *     "settings.plan": { "$is": ["free", "paid"]}
- *   },
- * }
- * ```
- *
- * Specifying multiple columns, ANDs them together:
+ * If you specify multiple columns in the same filter, they are logically AND'ed together:
  *
  * ```json
  * {
@@ -974,6 +964,8 @@ export declare type QueryTableVariables = {
  * }
  * ```
  *
+ * The above matches if both conditions are met.
+ *
  * To be more explicit about it, you can use `$all` or `$any`:
  *
  * ```json
@@ -981,13 +973,13 @@ export declare type QueryTableVariables = {
  *   "filter": {
  *       "$any": {
  *         "settings.dark": true,
- *         "settings.plan": "free",
+ *         "settings.plan": "free"
  *       }
  *   },
  * }
  * ```
  *
- * `$all` and `$any` can also receive an array of objects, which allows for repeating columns:
+ * The `$all` and `$any` operators can also receive an array of objects, which allows for repeating column names:
  *
  * ```json
  * {
@@ -1030,7 +1022,7 @@ export declare type QueryTableVariables = {
  * }
  * ```
  *
- * We can also make the negation version, `$notExists` :
+ * Or you can use the inverse operator `$notExists`:
  *
  * ```json
  * {
@@ -1083,7 +1075,7 @@ export declare type QueryTableVariables = {
  * }
  * ```
  *
- * #### Numeric/date ranges
+ * #### Numeric ranges
  *
  * ```json
  * {
@@ -1098,18 +1090,6 @@ export declare type QueryTableVariables = {
  *
  * The supported operators are `$gt`, `$lt`, `$ge`, `$le`.
  *
- * Date ranges would support the same operators, with the date as string in RFC 3339:
- *
- * ```json
- * {
- *   "filter": {
- *       "<column_name>": {
- *         "$gt": "2019-10-12T07:20:50.52Z",
- *         "$lt": "2021-10-12T07:20:50.52Z"
- *       }
- *   }
- * }
- * ```
  *
  * #### Negations
  *
@@ -1162,7 +1142,7 @@ export declare type QueryTableVariables = {
  * }
  * ```
  *
- * In addition, we can add specific operators like `$isNot` to simplify expressions:
+ * In addition, you can use operators like `$isNot` or `$notExists` to simplify expressions:
  *
  * ```json
  * {
@@ -1213,6 +1193,22 @@ export declare type QueryTableVariables = {
  * predicate. The `$includes` operator is a synonym for the `$includesAny`
  * operator.
  *
+ * Here is an example of using the `$includesAll` operator:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "settings.labels": {
+ *       "$includesAll": [
+ *         {"$contains": "label"},
+ *       ]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The above matches if all label values contain the string "labels".
+ *
  * ### Sorting
  *
  * Sorting by one element:

package/dist/api/components.js

@@ -458,7 +458,7 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  *   `$none`, etc.
  *
  * All operators start with an `$` to differentiate them from column names
- * (which are not allowed to start with an underscore).
+ * (which are not allowed to start with an dollar sign).
  *
  * #### Exact matching and control operators
  *
@@ -526,27 +526,17 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * }
  * ```
  *
- * If you want to OR together multiple values, you can use an array of values:
+ * If you want to OR together multiple values, you can use the `$any` operator with an array of values:
  *
  * ```json
  * {
  *   "filter": {
- *     "settings.plan": ["free", "paid"]
+ *     "settings.plan": {"$any": ["free", "paid"]}
  *   },
  * }
  * ```
  *
- * Same query with `$is` operator:
- *
- * ```json
- * {
- *   "filter": {
- *     "settings.plan": { "$is": ["free", "paid"]}
- *   },
- * }
- * ```
- *
- * Specifying multiple columns, ANDs them together:
+ * If you specify multiple columns in the same filter, they are logically AND'ed together:
  *
  * ```json
  * {
@@ -557,6 +547,8 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * }
  * ```
  *
+ * The above matches if both conditions are met.
+ *
  * To be more explicit about it, you can use `$all` or `$any`:
  *
  * ```json
@@ -564,13 +556,13 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  *   "filter": {
  *       "$any": {
  *         "settings.dark": true,
- *         "settings.plan": "free",
+ *         "settings.plan": "free"
  *       }
  *   },
  * }
  * ```
  *
- * `$all` and `$any` can also receive an array of objects, which allows for repeating columns:
+ * The `$all` and `$any` operators can also receive an array of objects, which allows for repeating column names:
  *
  * ```json
  * {
@@ -613,7 +605,7 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * }
  * ```
  *
- * We can also make the negation version, `$notExists` :
+ * Or you can use the inverse operator `$notExists`:
  *
  * ```json
  * {
@@ -666,7 +658,7 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * }
  * ```
  *
- * #### Numeric/date ranges
+ * #### Numeric ranges
  *
  * ```json
  * {
@@ -681,18 +673,6 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  *
  * The supported operators are `$gt`, `$lt`, `$ge`, `$le`.
  *
- * Date ranges would support the same operators, with the date as string in RFC 3339:
- *
- * ```json
- * {
- *   "filter": {
- *       "<column_name>": {
- *         "$gt": "2019-10-12T07:20:50.52Z",
- *         "$lt": "2021-10-12T07:20:50.52Z"
- *       }
- *   }
- * }
- * ```
  *
  * #### Negations
  *
@@ -745,7 +725,7 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * }
  * ```
  *
- * In addition, we can add specific operators like `$isNot` to simplify expressions:
+ * In addition, you can use operators like `$isNot` or `$notExists` to simplify expressions:
  *
  * ```json
  * {
@@ -796,6 +776,22 @@ exports.bulkInsertTableRecords = bulkInsertTableRecords;
  * predicate. The `$includes` operator is a synonym for the `$includesAny`
  * operator.
  *
+ * Here is an example of using the `$includesAll` operator:
+ *
+ * ```json
+ * {
+ *   "filter": {
+ *     "settings.labels": {
+ *       "$includesAll": [
+ *         {"$contains": "label"},
+ *       ]
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The above matches if all label values contain the string "labels".
+ *
  * ### Sorting
  *
  * Sorting by one element:

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

@@ -1,5 +1,5 @@
-import { XataRecord } from '..';
 import { Query } from './query';
+import { XataRecord } from './record';
 export declare type PaginationQueryMeta = {
     page: {
         cursor: string;

package/dist/schema/query.d.ts

@@ -1,7 +1,8 @@
-import { Repository, XataRecord } from '..';
 import { ColumnsFilter, FilterExpression, PageConfig, SortExpression } from '../api/schemas';
 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';
 export declare type QueryOptions<T extends XataRecord> = {
     page?: PaginationOptions;

package/dist/schema/record.d.ts

@@ -8,6 +8,9 @@ export interface Identifiable {
      */
     id: string;
 }
+export interface BaseData {
+    [key: string]: any;
+}
 /**
  * Represents a persisted record from the database.
  */

package/dist/schema/repository.d.ts

@@ -1,82 +1,77 @@
 import { FetchImpl } from '../api/fetcher';
 import { Page } from './pagination';
 import { Query, QueryOptions } from './query';
-import { XataRecord } from './record';
-import { Select, Selectable, SelectableColumn } from './selection';
+import { BaseData, Identifiable, XataRecord } from './record';
+import { Select, SelectableColumn } from './selection';
 export declare type Links = Record<string, Array<string[]>>;
 /**
  * Common interface for performing operations on a table.
  */
-export declare abstract class Repository<T extends XataRecord> extends Query<T> {
+export declare abstract class Repository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record> {
+    abstract create(object: Data & Partial<Identifiable>): Promise<Record>;
     /**
-     * Creates a record in the table.
+     * 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(object: Selectable<T>): Promise<T>;
+    abstract create(id: string, object: Data): Promise<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: Selectable<T>[]): Promise<T[]>;
+    abstract createMany(objects: Data[]): Promise<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<T | 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: Selectable<T>): Promise<T>;
+    abstract read(id: string): Promise<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<Selectable<T>>): Promise<T>;
+    abstract update(id: string, object: Partial<Data>): Promise<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: Selectable<T>): Promise<T>;
+    abstract createOrUpdate(id: string, object: Data): Promise<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<R extends XataRecord, Options extends QueryOptions<T>>(query: Query<T, R>, options: Options): Promise<Page<T, typeof options extends {
-        columns: SelectableColumn<T>[];
-    } ? Select<T, typeof options['columns'][number]> : R>>;
+    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>>;
 }
-export declare class RestRepository<T extends XataRecord> extends Repository<T> {
+export declare class RestRepository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Repository<Data, Record> {
     #private;
     constructor(client: BaseClient<any>, table: string);
-    create(object: Selectable<T>): Promise<T>;
-    createMany(objects: T[]): Promise<T[]>;
-    read(recordId: string): Promise<T | null>;
-    update(recordId: string, object: Partial<Selectable<T>>): Promise<T>;
-    insert(recordId: string, object: Selectable<T>): Promise<T>;
-    updateOrInsert(recordId: string, object: Selectable<T>): Promise<T>;
+    create(object: Data): Promise<Record>;
+    create(recordId: string, object: Data): Promise<Record>;
+    createMany(objects: Data[]): Promise<Record[]>;
+    read(recordId: string): Promise<Record | null>;
+    update(recordId: string, object: Partial<Data>): Promise<Record>;
+    createOrUpdate(recordId: string, object: Data): Promise<Record>;
     delete(recordId: string): Promise<void>;
-    query<R extends XataRecord, Options extends QueryOptions<T>>(query: Query<T, R>, options?: Options): Promise<Page<T, typeof options extends {
-        columns: SelectableColumn<T>[];
-    } ? Select<T, typeof options['columns'][number]> : R>>;
+    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>>;
 }
 interface RepositoryFactory {
-    createRepository<T extends XataRecord>(client: BaseClient<any>, table: string): Repository<T>;
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data>;
 }
 export declare class RestRespositoryFactory implements RepositoryFactory {
-    createRepository<T extends XataRecord>(client: BaseClient<any>, table: string): Repository<T>;
+    createRepository<Data extends BaseData>(client: BaseClient<any>, table: string): Repository<Data>;
 }
 declare type BranchStrategyValue = string | undefined | null;
 declare type BranchStrategyBuilder = () => BranchStrategyValue | Promise<BranchStrategyValue>;

package/dist/schema/repository.js

@@ -26,10 +26,11 @@ 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");
@@ -41,6 +42,7 @@ class Repository extends query_1.Query {
 exports.Repository = Repository;
 class RestRepository extends Repository {
     constructor(client, table) {
+        var _a;
         super(null, table, {});
         _RestRepository_instances.add(this);
         _RestRepository_client.set(this, void 0);
@@ -49,26 +51,32 @@ class RestRepository extends Repository {
         __classPrivateFieldSet(this, _RestRepository_client, client, "f");
         __classPrivateFieldSet(this, _RestRepository_table, table, "f");
         // TODO: Remove when integrating with API client
-        const fetchImpl = typeof fetch !== 'undefined' ? fetch : __classPrivateFieldGet(this, _RestRepository_client, "f").options.fetch;
+        const globalFetch = typeof fetch !== 'undefined' ? fetch : undefined;
+        const fetchImpl = (_a = __classPrivateFieldGet(this, _RestRepository_client, "f").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.`);
         }
         __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) {
@@ -100,24 +108,7 @@ class RestRepository extends Repository {
             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));
@@ -169,6 +160,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) {
@@ -201,7 +223,7 @@ class BaseClient {
         for (const link of tableLinks) {
             const [field, linkTable] = link;
             const value = o[field];
-            if (value && typeof value === 'object') {
+            if (value && (0, lang_1.isObject)(value)) {
                 const { id } = value;
                 if (Object.keys(value).find((col) => col === 'id')) {
                     o[field] = this.initObject(linkTable, value);
@@ -210,7 +232,7 @@ class BaseClient {
                     o[field] = {
                         id,
                         get: () => {
-                            this.db[linkTable].read(id);
+                            return this.db[linkTable].read(id);
                         }
                     };
                 }
@@ -271,8 +293,8 @@ const isBranchStrategyBuilder = (strategy) => {
 };
 // 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.entries(object !== null && object !== void 0 ? object : {}).reduce((acc, [key, value]) => {
+        if ((0, lang_1.isObject)(value) && (0, lang_1.isString)(value.id)) {
             return Object.assign(Object.assign({}, acc), { [key]: value.id });
         }
         return Object.assign(Object.assign({}, acc), { [key]: value });

package/dist/schema/selection.d.ts

@@ -1,12 +1,10 @@
-import { XataRecord } from '..';
 import { StringKeys, UnionToIntersection, Values } from '../util/types';
 import { Query } from './query';
-import { Identifiable } from './record';
+import { BaseData, Identifiable, XataRecord } from './record';
 declare type Queries<T> = {
-    [key in keyof T as T[key] extends Query<any> ? key : never]: T[key];
+    [key in keyof T as T[key] extends Query<any, any> ? key : never]: T[key];
 };
-declare type InternalProperties = keyof XataRecord;
-export declare type Selectable<T extends XataRecord> = Omit<T, InternalProperties> & Identifiable;
+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;
 }> : '');

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.0.0-beta.2b5cc25",
+  "version": "0.0.0-beta.3d1e440",
   "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": "2b5cc25e3f068c7789a2f5f026562f7b302435ce"
+  "gitHead": "3d1e440610e2b18e76cab792c794491d7fd6c118"
 }