@xata.io/client 0.0.0-beta.26144eb → 0.0.0-beta.2a518f7

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @xata.io/client
 
+## 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.js

@@ -141,7 +141,7 @@ class BranchApi {
     getBranchDetails(workspace, database, branch) {
         return components_1.operationsByTag.branch.getBranchDetails(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` } }, this.extraProps));
     }
-    createBranch(workspace, database, branch, from, options = {}) {
+    createBranch(workspace, database, branch, from = '', options = {}) {
         return components_1.operationsByTag.branch.createBranch(Object.assign({ pathParams: { workspace, dbBranchName: `${database}:${branch}` }, queryParams: { from }, body: options }, this.extraProps));
     }
     deleteBranch(workspace, database, branch) {

package/dist/schema/index.d.ts

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

package/dist/schema/index.js

@@ -14,12 +14,13 @@ 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.Query = exports.BaseClient = exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = void 0;
+exports.RestRespositoryFactory = exports.RestRepository = exports.Repository = exports.BaseClient = 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 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; } });
 Object.defineProperty(exports, "RestRepository", { enumerable: true, get: function () { return repository_1.RestRepository; } });
 Object.defineProperty(exports, "RestRespositoryFactory", { enumerable: true, get: function () { return repository_1.RestRespositoryFactory; } });
-Object.defineProperty(exports, "BaseClient", { enumerable: true, get: function () { return repository_1.BaseClient; } });
-var query_1 = require("./query");
-Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return query_1.Query; } });

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;
@@ -19,7 +19,7 @@ export interface Paginable<T extends XataRecord, R extends XataRecord = T> {
  * A Page contains a set of results from a query plus metadata about the retrieved
  * set of values such as the cursor, required to retrieve additional records.
  */
-export declare class Page<T extends XataRecord, R extends XataRecord> implements Paginable<T, R> {
+export declare class Page<T extends XataRecord, R extends XataRecord = T> implements Paginable<T, R> {
     #private;
     /**
      * Page metadata, required to retrieve additional records.
@@ -77,3 +77,7 @@ export declare type OffsetNavigationOptions = {
     offset?: number;
 };
 export declare type PaginationOptions = CursorNavigationOptions & OffsetNavigationOptions;
+export declare const PAGINATION_MAX_SIZE = 200;
+export declare const PAGINATION_DEFAULT_SIZE = 200;
+export declare const PAGINATION_MAX_OFFSET = 800;
+export declare const PAGINATION_DEFAULT_OFFSET = 0;

package/dist/schema/pagination.js

@@ -21,7 +21,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _Page_query;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Page = void 0;
+exports.PAGINATION_DEFAULT_OFFSET = exports.PAGINATION_MAX_OFFSET = exports.PAGINATION_DEFAULT_SIZE = exports.PAGINATION_MAX_SIZE = exports.Page = void 0;
 /**
  * A Page contains a set of results from a query plus metadata about the retrieved
  * set of values such as the cursor, required to retrieve additional records.
@@ -88,3 +88,7 @@ class Page {
 }
 exports.Page = Page;
 _Page_query = new WeakMap();
+exports.PAGINATION_MAX_SIZE = 200;
+exports.PAGINATION_DEFAULT_SIZE = 200;
+exports.PAGINATION_MAX_OFFSET = 800;
+exports.PAGINATION_DEFAULT_OFFSET = 0;

package/dist/schema/query.d.ts

@@ -1,8 +1,9 @@
-import { XataRecord, Repository } from '..';
-import { FilterExpression, SortExpression, PageConfig, ColumnsFilter } from '../api/schemas';
+import { ColumnsFilter, FilterExpression, PageConfig, SortExpression } from '../api/schemas';
 import { DeepConstraint, FilterConstraints, SortDirection, SortFilter } from './filters';
-import { PaginationOptions, Page, Paginable, PaginationQueryMeta } from './pagination';
-import { Selectable, SelectableColumn, Select } from './selection';
+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;
     columns?: Extract<keyof Selectable<T>, string>[];
@@ -81,27 +82,28 @@ export declare class Query<T extends XataRecord, R extends XataRecord = T> imple
      * @returns A new Query object.
      */
     select<K extends SelectableColumn<T>>(columns: K[]): Query<T, Select<T, K>>;
-    getPaginated<Options extends QueryOptions<T>>(options?: Options): Promise<Page<T, typeof options extends {
-        columns: SelectableColumn<T>[];
-    } ? Select<T, typeof options['columns'][number]> : R>>;
+    getPaginated<Options extends QueryOptions<T>>(options?: Options): Promise<Page<T, GetWithColumnOptions<T, R, typeof options>>>;
     [Symbol.asyncIterator](): AsyncIterableIterator<R>;
-    getIterator(chunk: number, options?: Omit<QueryOptions<T>, 'page'>): AsyncGenerator<R[]>;
+    getIterator<Options extends QueryOptions<T>>(chunk: number, options?: Omit<Options, 'page'>): AsyncGenerator<GetWithColumnOptions<T, R, typeof options>[]>;
     /**
      * Performs the query in the database and returns a set of results.
      * @param options Additional options to be used when performing the query.
      * @returns An array of records from the database.
      */
-    getMany<Options extends QueryOptions<T>>(options?: Options): Promise<(typeof options extends {
-        columns: SelectableColumn<T>[];
-    } ? Select<T, typeof options['columns'][number]> : R)[]>;
+    getMany<Options extends QueryOptions<T>>(options?: Options): Promise<GetWithColumnOptions<T, R, typeof options>[]>;
+    /**
+     * 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>[]>;
     /**
      * Performs the query in the database and returns the first result.
      * @param options Additional options to be used when performing the query.
      * @returns The first record that matches the query, or null if no record matched the query.
      */
-    getOne<Options extends Omit<QueryOptions<T>, 'page'>>(options?: Options): Promise<(typeof options extends {
-        columns: SelectableColumn<T>[];
-    } ? Select<T, typeof options['columns'][number]> : R) | null>;
+    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;
@@ -112,3 +114,16 @@ export declare class Query<T extends XataRecord, R extends XataRecord = T> imple
     lastPage(size?: number, offset?: number): Promise<Page<T, R>>;
     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

@@ -42,6 +42,7 @@ var _Query_table, _Query_repository, _Query_data;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Query = void 0;
 const lang_1 = require("../util/lang");
+const pagination_1 = require("./pagination");
 /**
  * Query objects contain the information of all filters, sorting, etc. to be included in the database query.
  *
@@ -193,6 +194,32 @@ class Query {
             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* () {
+            const results = [];
+            try {
+                for (var _b = __asyncValues(this.getIterator(chunk, options)), _c; _c = yield _b.next(), !_c.done;) {
+                    const page = _c.value;
+                    results.push(...page);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return results;
+        });
+    }
     /**
      * Performs the query in the database and returns the first result.
      * @param options Additional options to be used when performing the query.

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,45 +1,40 @@
 import { FetchImpl } from '../api/fetcher';
 import { Page } from './pagination';
 import { Query, QueryOptions } from './query';
-import { XataRecord } from './record';
-import { Selectable, SelectableColumn, Select } from './selection';
+import { BaseData, 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> {
-    /**
-     * Creates a record in the table.
-     * @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>;
+export declare abstract class Repository<Data extends BaseData, Record extends XataRecord = Data & XataRecord> extends Query<Record> {
+    abstract create(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>;
+    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: Selectable<T>): Promise<T>;
+    abstract insert(id: string, object: Data): Promise<Record>;
     /**
      * 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,
      * it will be update, otherwise a new record will be created.
@@ -47,36 +42,36 @@ export declare abstract class Repository<T extends XataRecord> extends Query<T>
      * @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 updateOrInsert(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>;
+    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>;
     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>;
@@ -98,7 +93,7 @@ export declare type XataClientOptions = {
     apiKey: string;
     repositoryFactory?: RepositoryFactory;
 };
-export declare class BaseClient<D extends Record<string, Repository<any>>> {
+export declare class BaseClient<D extends Record<string, Repository<any>> = Record<string, Repository<any>>> {
     #private;
     options: XataClientOptions;
     db: D;

package/dist/schema/repository.js

@@ -76,7 +76,7 @@ class RestRepository extends Repository {
             const fetchProps = yield __classPrivateFieldGet(this, _RestRepository_instances, "m", _RestRepository_getFetchProps).call(this);
             const records = objects.map((object) => transformObjectLinks(object));
             const response = yield (0, api_1.bulkInsertTableRecords)(Object.assign({ pathParams: { workspace: '{workspaceId}', dbBranchName: '{dbBranch}', tableName: __classPrivateFieldGet(this, _RestRepository_table, "f") }, body: { records } }, fetchProps));
-            const finalObjects = yield this.any(...response.recordIDs.map((id) => this.filter('id', id))).getMany();
+            const finalObjects = yield this.any(...response.recordIDs.map((id) => this.filter('id', id))).getAll();
             if (finalObjects.length !== objects.length) {
                 throw new Error('The server failed to save some records');
             }
@@ -185,6 +185,14 @@ class BaseClient {
         }
         this.options = options;
         __classPrivateFieldSet(this, _BaseClient_links, links, "f");
+        const factory = options.repositoryFactory || new RestRespositoryFactory();
+        this.db = new Proxy({}, {
+            get: (_target, prop) => {
+                if (typeof prop !== 'string')
+                    throw new Error('Invalid table name');
+                return factory.createRepository(this, prop);
+            }
+        });
     }
     initObject(table, object) {
         const o = {};

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

@@ -1,6 +1,6 @@
 {
   "name": "@xata.io/client",
-  "version": "0.0.0-beta.26144eb",
+  "version": "0.0.0-beta.2a518f7",
   "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": "26144eb7608667b25f20c6ac63bcf9c07ba1736f"
+  "gitHead": "2a518f767eca80719ec95721ec93208a39082522"
 }