@xata.io/client 0.12.0 → 0.13.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @xata.io/client
 
+## 0.13.0
+
+### Minor Changes
+
+- [#375](https://github.com/xataio/client-ts/pull/375) [`c9f34ad`](https://github.com/xataio/client-ts/commit/c9f34ad37d75203083a1dec2fac2b03e096521af) Thanks [@SferaDev](https://github.com/SferaDev)! - Change default pagination size to 20
+
+* [#375](https://github.com/xataio/client-ts/pull/375) [`5f82e43`](https://github.com/xataio/client-ts/commit/5f82e4394010f40dcbf3faf2d0bdb58a6fc1c37a) Thanks [@SferaDev](https://github.com/SferaDev)! - Return a paginable object in getPaginated
+
 ## 0.12.0
 
 ### Minor Changes

package/README.md

@@ -123,24 +123,24 @@ const user = await xata.db.users.read('rec_1234abcdef');
 
 ```ts
 // Query objects selecting all fields.
-const users = await xata.db.users.select().getMany();
+const page = await xata.db.users.select().getPaginated();
 const user = await xata.db.users.select().getFirst();
 
 // You can also use `xata.db.users` directly, since it's an immutable Query too!
-const users = await xata.db.users.getMany();
+const page = await xata.db.users.getPaginated();
 const user = await xata.db.users.getFirst();
 
 // Query objects selecting just one or more fields
-const users = await xata.db.users.select('email', 'profile').getMany();
+const page = await xata.db.users.select('email', 'profile').getPaginated();
 
 // Apply constraints
-const users = await xata.db.users.filter('email', 'foo@example.com').getMany();
+const page = await xata.db.users.filter('email', 'foo@example.com').getPaginated();
 
 // Sorting
-const users = await xata.db.users.sort('fullName', 'asc').getMany();
+const page = await xata.db.users.sort('full_name', 'asc').getPaginated();
 ```
 
-Query operations (`select()`, `filter()`, `sort()`) return a `Query` object. These objects are immutable. You can add additional constraints, sort, etc. by calling their methods, and a new query will be returned. In order to finally make a query to the database you'll invoke `getAll()`, `getFirst()`, `getMany()` or `getPaginated()`.
+Query operations (`select()`, `filter()`, `sort()`) return a `Query` object. These objects are immutable. You can add additional constraints, sort, etc. by calling their methods, and a new query will be returned. In order to finally make a query to the database you'll invoke `getPaginated()`, `getMany()`, `getAll()`, or `getFirst()`.
 
 ```ts
 // Operators that combine multiple conditions can be deconstructed
@@ -154,16 +154,23 @@ filter('email', startsWith('username')).not(filter('created_at', gt(somePastDate
 // Queries are immutable objects. This is useful to derive queries from other queries
 const admins = filter('admin', true);
 const spaniardsAdmins = admins.filter('country', 'Spain');
-await admins.getMany(); // still returns all admins
+await admins.getAll(); // still returns all admins
 
 // Finally fetch the results of the query
-const users = await query.getMany();
+const users = await query.getAll();
 const firstUser = await query.getFirst();
+```
+
+The `getPaginated()` method will return a `Page` object. It's a wrapper that internally uses cursor based pagination.
 
-// Also you can paginate the results
-const page = await query.getPaginated();
-const hasPage2 = page.hasNextPage();
-const page2 = await page.nextPage();
+```ts
+page.records; // Array of records
+page.hasNextPage(); // Boolean
+
+const nextPage = await page.nextPage(); // Page object
+const previousPage = await page.previousPage(); // Page object
+const firstPage = await page.firstPage(); // Page object
+const lastPage = await page.lastPage(); // Page object
 ```
 
 If you want to use an iterator, both the Repository and the Query classes implement an AsyncIterable. Alternatively you can use `getIterator()` and customize the batch size of the iterator:
@@ -208,23 +215,6 @@ await user.delete();
 await xata.db.users.delete('rec_1234abcdef');
 ```
 
-#### Deno support
-
-Right now we are still not publishing the client on deno.land or have support for deno in the codegen.
-
-However you can already use it with your preferred node CDN with the following import in the auto-generated `xata.ts` file:
-
-```ts
-import {
-  BaseClient,
-  Query,
-  Repository,
-  RestRespositoryFactory,
-  XataClientOptions,
-  XataRecord
-} from 'https://esm.sh/@xata.io/client@<version>/dist/schema?target=deno';
-```
-
 ### API Client
 
 One of the main features of the SDK is the ability to interact with the whole Xata API and perform administrative operations such as creating/reading/updating/deleting workspaces, databases, tables, branches...
@@ -256,3 +246,20 @@ const record = await client.records.getRecord(workspace, databaseName, 'branch',
 
 await client.workspaces.deleteWorkspace(workspace);
 ```
+
+## Deno support
+
+Right now we are still not publishing the client on deno.land or have support for deno in the codegen.
+
+However you can already use it with your preferred node CDN with the following import in the auto-generated `xata.ts` file:
+
+```ts
+import {
+  BaseClient,
+  Query,
+  Repository,
+  RestRespositoryFactory,
+  XataClientOptions,
+  XataRecord
+} from 'https://esm.sh/@xata.io/client@<version>/dist/schema?target=deno';
+```

package/dist/index.cjs

@@ -946,13 +946,13 @@ var __privateSet$5 = (obj, member, value, setter) => {
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
-var _query;
+var _query, _page;
 class Page {
   constructor(query, meta, records = []) {
     __privateAdd$6(this, _query, void 0);
     __privateSet$5(this, _query, query);
     this.meta = meta;
-    this.records = records;
+    this.records = new RecordArray(this, records);
   }
   async nextPage(size, offset) {
     return __privateGet$6(this, _query).getPaginated({ pagination: { size, offset, after: this.meta.page.cursor } });
@@ -972,12 +972,40 @@ class Page {
 }
 _query = new WeakMap();
 const PAGINATION_MAX_SIZE = 200;
-const PAGINATION_DEFAULT_SIZE = 200;
+const PAGINATION_DEFAULT_SIZE = 20;
 const PAGINATION_MAX_OFFSET = 800;
 const PAGINATION_DEFAULT_OFFSET = 0;
 function isCursorPaginationOptions(options) {
   return isDefined(options) && (isDefined(options.first) || isDefined(options.last) || isDefined(options.after) || isDefined(options.before));
 }
+const _RecordArray = class extends Array {
+  constructor(page, overrideRecords) {
+    super(...overrideRecords ?? page.records);
+    __privateAdd$6(this, _page, void 0);
+    __privateSet$5(this, _page, page);
+  }
+  async nextPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).nextPage(size, offset);
+    return new _RecordArray(newPage);
+  }
+  async previousPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).previousPage(size, offset);
+    return new _RecordArray(newPage);
+  }
+  async firstPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).firstPage(size, offset);
+    return new _RecordArray(newPage);
+  }
+  async lastPage(size, offset) {
+    const newPage = await __privateGet$6(this, _page).lastPage(size, offset);
+    return new _RecordArray(newPage);
+  }
+  hasNextPage() {
+    return __privateGet$6(this, _page).meta.page.more;
+  }
+};
+let RecordArray = _RecordArray;
+_page = new WeakMap();
 
 var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
@@ -1004,7 +1032,7 @@ const _Query = class {
     __privateAdd$5(this, _repository, void 0);
     __privateAdd$5(this, _data, { filter: {} });
     this.meta = { page: { cursor: "start", more: true } };
-    this.records = [];
+    this.records = new RecordArray(this, []);
     __privateSet$4(this, _table$1, table);
     if (repository) {
       __privateSet$4(this, _repository, repository);
@@ -1093,8 +1121,11 @@ const _Query = class {
     }
   }
   async getMany(options = {}) {
-    const { records } = await this.getPaginated(options);
-    return records;
+    const page = await this.getPaginated(options);
+    if (page.hasNextPage() && options.pagination?.size === void 0) {
+      console.trace("Calling getMany does not return all results. Paginate to get all results or call getAll.");
+    }
+    return page.records;
   }
   async getAll(options = {}) {
     const { batchSize = PAGINATION_MAX_SIZE, ...rest } = options;
@@ -1985,6 +2016,7 @@ exports.PAGINATION_MAX_OFFSET = PAGINATION_MAX_OFFSET;
 exports.PAGINATION_MAX_SIZE = PAGINATION_MAX_SIZE;
 exports.Page = Page;
 exports.Query = Query;
+exports.RecordArray = RecordArray;
 exports.Repository = Repository;
 exports.RestRepository = RestRepository;
 exports.SchemaPlugin = SchemaPlugin;