merchi_sdk_ts 1.9.10 → 1.9.12

package/dist/entities/job.js

@@ -238,6 +238,10 @@ var Job = /** @class */ (function (_super) {
         Job.property({ type: Date }),
         __metadata("design:type", Object)
     ], Job.prototype, "dateLastActioned", void 0);
+    __decorate([
+        Job.property({ type: Date }),
+        __metadata("design:type", Object)
+    ], Job.prototype, "dateFirstActioned", void 0);
     __decorate([
         Job.property(),
         __metadata("design:type", Date)

package/dist/entities/notification.test.js

@@ -19,3 +19,33 @@ test('can list notifications with notificationSender filter', function () {
         expect(query).toContainEqual(['notification_sender', '123']);
     });
 });
+test('list forwards skipCount=true as skip_count query param', function () {
+    var merchi = new Merchi();
+    var fetch = mockFetch(true, {
+        'notifications': [],
+        // backend returns ``available: null`` when skip_count was honoured
+        'available': null,
+        'count': 0
+    }, 200);
+    var options = { skipCount: true };
+    return merchi.Notification.list(options).then(function (response) {
+        var query = fetch.mock.calls[0][1]['query'];
+        expect(query).toContainEqual(['skip_count', 'true']);
+        // ``available`` must round-trip as ``null``; the typed metadata
+        // is now ``number | null``, so consumers can detect the absence.
+        expect(response.metadata.available).toBeNull();
+    });
+});
+test('list omits skip_count when skipCount is not set', function () {
+    var merchi = new Merchi();
+    var fetch = mockFetch(true, {
+        'notifications': [],
+        'available': 0,
+        'count': 0
+    }, 200);
+    return merchi.Notification.list({}).then(function () {
+        var query = fetch.mock.calls[0][1]['query'];
+        var skipCountEntries = query.filter(function (entry) { return entry[0] === 'skip_count'; });
+        expect(skipCountEntries).toEqual([]);
+    });
+});

package/dist/entity.js

@@ -614,6 +614,14 @@ var Entity = /** @class */ (function () {
             if (options.limit !== undefined) {
                 fetchOptions.query.push(['limit', options.limit.toString()]);
             }
+            if (options.skipCount !== undefined) {
+                // Snake-case is the canonical form on the server; the API
+                // also accepts ``skipCount`` via its camelCase alias, but
+                // matching the wire shape of the other ``*_only`` /
+                // ``*_filter`` flags keeps logs and traffic captures
+                // consistent.
+                fetchOptions.query.push(['skip_count', options.skipCount.toString()]);
+            }
             if (options.q !== undefined) {
                 fetchOptions.query.push(['q', options.q]);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merchi_sdk_ts",
-  "version": "1.9.10",
+  "version": "1.9.12",
   "main": "dist/index.js",
   "type": "module",
   "repository": "git@github.com:merchisdk/merchi_sdk_ts.git",

package/src/entities/job.ts

@@ -145,6 +145,9 @@ export class Job extends Entity {
   @Job.property({type: Date})
   public dateLastActioned?: Date | null;
 
+  @Job.property({type: Date})
+  public dateFirstActioned?: Date | null;
+
   @Job.property()
   public groupBuyProductionStarted?: Date;
 

package/src/entities/notification.test.ts

@@ -22,3 +22,37 @@ test('can list notifications with notificationSender filter', () => {
     expect(query).toContainEqual(['notification_sender', '123']);
   });
 });
+
+test('list forwards skipCount=true as skip_count query param', () => {
+  const merchi = new Merchi();
+  const fetch = mockFetch(true, {
+    'notifications': [],
+    // backend returns ``available: null`` when skip_count was honoured
+    'available': null,
+    'count': 0
+  }, 200);
+  const options = { skipCount: true };
+  return merchi.Notification.list(options).then((response) => {
+    const query = fetch.mock.calls[0][1]['query'];
+    expect(query).toContainEqual(['skip_count', 'true']);
+    // ``available`` must round-trip as ``null``; the typed metadata
+    // is now ``number | null``, so consumers can detect the absence.
+    expect(response.metadata.available).toBeNull();
+  });
+});
+
+test('list omits skip_count when skipCount is not set', () => {
+  const merchi = new Merchi();
+  const fetch = mockFetch(true, {
+    'notifications': [],
+    'available': 0,
+    'count': 0
+  }, 200);
+  return merchi.Notification.list({}).then(() => {
+    const query = fetch.mock.calls[0][1]['query'];
+    const skipCountEntries = query.filter(
+      (entry: [string, string]) => entry[0] === 'skip_count'
+    );
+    expect(skipCountEntries).toEqual([]);
+  });
+});

package/src/entity.ts

@@ -105,6 +105,7 @@ interface ListOptions {
   inDomain?: number;
   inDomainName?: string;
   inDomainRoles?: number[];
+  isJobManager?: boolean;
   isMaster?: boolean;
   isOrder?: boolean;
   isPrivate?: boolean;
@@ -159,11 +160,22 @@ interface ListOptions {
   teamOnly?: boolean;
   turnaroundTimeDays?: number;
   withRights?: boolean;
+  // Opt out of the unbounded ``SELECT count(*)`` the API runs to
+  // populate ``available``. When ``skipCount`` is true the response's
+  // ``available`` is ``null``. Use this whenever the caller only
+  // renders the visible page of rows (search modals, autocomplete,
+  // navbar dropdowns, infinite scroll, ...) and never reads
+  // ``metadata.available``. Paginated tables that show "Showing X
+  // of Y" or compute a page count must NOT set this.
+  skipCount?: boolean;
 }
 
 export interface ListMetadata {
   canCreate?: boolean;
-  available: number;
+  // ``null`` when the caller passed ``skipCount: true``: the API
+  // intentionally skipped the ``COUNT(*)`` query. JSON consumers
+  // can detect the absence rather than mistaking it for zero.
+  available: number | null;
   count: number;
   limit: number;
   offset: number;
@@ -417,6 +429,16 @@ export class Entity {
       if (options.limit !== undefined) {
         fetchOptions.query.push(['limit', options.limit.toString()]);
       }
+      if (options.skipCount !== undefined) {
+        // Snake-case is the canonical form on the server; the API
+        // also accepts ``skipCount`` via its camelCase alias, but
+        // matching the wire shape of the other ``*_only`` /
+        // ``*_filter`` flags keeps logs and traffic captures
+        // consistent.
+        fetchOptions.query.push(
+          ['skip_count', options.skipCount.toString()]
+        );
+      }
       if (options.q !== undefined) {
         fetchOptions.query.push(['q', options.q]);
       }
@@ -463,6 +485,10 @@ export class Entity {
       if (options.asRole !== undefined) {
         fetchOptions.query.push(['as_role', options.asRole.toString()]);
       }
+      if (options.isJobManager !== undefined) {
+        fetchOptions.query.push(
+          ['is_job_manager', options.isJobManager.toString()]);
+      }
       if (options.groupBuyOnly !== undefined) {
         fetchOptions.query.push(
           ['group_buy_only', options.groupBuyOnly.toString()]);