@cube-nl/dmp-sdk 1.1.0-rc.1 → 1.1.0-rc.2

package/dist/wireframe.js

@@ -1,5 +1,5 @@
 import { DmpError } from './errors.js';
-import { PreviewStore } from './preview.js';
+import { compare, PreviewStore } from './preview.js';
 import { isoDate } from './ui/format.js';
 const FORMATS = {
     tekst: 'text',
@@ -11,6 +11,8 @@ const FORMATS = {
 };
 const filled = (value) => typeof value === 'string' && value !== '';
 const own = (row, key) => Object.prototype.hasOwnProperty.call(row, key);
+// `a, -b` and ['a', '-b'] alike: the items of a comma list, as the server reads it.
+const items = (value = []) => [value].flat().join(',').split(',').map((item) => item.trim());
 function isGap(value) {
     if (typeof value !== 'object' || value === null) {
         return false;
@@ -29,11 +31,12 @@ function isGap(value) {
 }
 /** The valid gap entries of `ontbreekt`; malformed ones are dropped with a single warning. */
 export function readGaps(value) {
-    if (!Array.isArray(value)) {
-        return [];
+    const gaps = [];
+    const dropped = [];
+    // Anything but a list is one malformed entry: a typo must not silently mean "nothing is missing".
+    for (const entry of Array.isArray(value) ? value : value == null ? [] : [value]) {
+        (isGap(entry) ? gaps : dropped).push(entry);
     }
-    const gaps = value.filter(isGap);
-    const dropped = value.filter((entry) => !isGap(entry));
     if (dropped.length > 0) {
         console.warn(`cube-app.json ontbreekt: ${dropped.length} malformed entries ignored`, dropped);
     }
@@ -73,10 +76,11 @@ export function withGaps(schema, gaps) {
     const names = added.map((field) => field.name);
     return {
         ...schema,
-        // Mock data may hold a missing field without its format: an amount there still shows as money.
+        // Money is not recognisable by its values, dates are (inferFormat): only an amount gets its format here, and a
+        // stale `datum` gap must not drop a live date-time's time.
         fields: [...schema.fields.map((field) => {
                 const gap = gaps.find(({ resource, veld }) => resource === schema.name && veld === field.name);
-                return gap !== undefined && field.format == null ? { ...field, format: shown(gap.type) } : field;
+                return gap?.type === 'bedrag' && field.format == null ? { ...field, format: 'currency' } : field;
             }), ...added],
         // An empty summary means "every field of a row", which already holds the invented ones.
         summary: schema.summary.length > 0 ? [...schema.summary, ...names] : schema.summary,
@@ -141,13 +145,14 @@ async function locally(name, rows, { filter = {}, sort = [] }) {
 export function mixedResource(live, gaps, mock, mockRows) {
     const { name } = live;
     const missing = new Map(gaps.filter((gap) => gap.resource === name && gap.veld !== undefined).map((gap) => [gap.veld, gap]));
-    // `-field`, `sum(field)` and `field.month` all name `field`.
-    const names = (item) => item.split(/[-+(),.]/).some((part) => missing.has(part));
+    // `-field`, `sum(field)` and `field.month` name `field`; `count` and `created_at.month` do not name a field
+    // called `count` or `month`.
+    const names = (item) => missing.has(/^[-+]?(?:\w+\()?([^.()]*)/.exec(item)?.[1] ?? '');
     const split = (query = {}) => {
         const selected = selection(query, name);
         const kept = selected?.filter((field) => !missing.has(field));
         const filters = Object.entries(query.filter ?? {});
-        const sort = [query.sort ?? []].flat();
+        const sort = items(query.sort).filter((item) => item !== '');
         // The live part names no missing field; the local part only missing ones.
         const part = (local) => ({
             filter: Object.fromEntries(filters.filter(([key]) => missing.has(key) === local)),
@@ -181,7 +186,15 @@ export function mixedResource(live, gaps, mock, mockRows) {
                 }
             }
         }
-        return { ...page, data: data };
+        const { meta } = page;
+        return {
+            ...page,
+            data: data,
+            // A filter on a missing field covers this page only, so the count and the last page say so too.
+            meta: Object.keys(local.filter).length > 0
+                ? { ...meta, page: { ...meta.page, total: data.length, pages: meta.page.number } }
+                : meta,
+        };
     };
     const list = async (query, init) => {
         const parts = split(query);
@@ -206,9 +219,15 @@ export function mixedResource(live, gaps, mock, mockRows) {
             const parts = split(query);
             const response = await live.get(id, parts.live, init);
             fill(response.data, parts.shown);
+            // The id was only asked for the invented values.
+            if (!parts.shown('id')) {
+                delete response.data.id;
+            }
             return response;
         },
-        aggregate: (query, init) => [query.fn, query.group ?? [], Object.keys(query.filter ?? {})].flat().some(names)
+        aggregate: (query, init) => [items(query.fn).map((fn) => fn.replace(/^\w+$/, '')), items(query.group), Object.keys(query.filter ?? {})]
+            .flat()
+            .some(names)
             ? mock.resource(name).aggregate(query)
             : live.aggregate(query, init),
     };
@@ -253,9 +272,27 @@ export function simulatedWrites(client, name) {
             .map((row) => local.get(key(row)) ?? row);
         const joined = fitting.filter((row) => !served.has(key(row)) && !listed.has(key(row)));
         const total = page.total - [...served].filter((id) => !fits.has(id)).length + joined.length;
+        let data = page.number === 1 ? [...joined, ...kept] : kept;
+        // No sort reads as one empty field, which no row has: then nothing moves.
+        const sorts = items(query.sort)
+            .map((item) => [item.replace(/^[-+]/, ''), item.startsWith('-') ? -1 : 1]);
+        // A row written here that the server did not list (created, or joining the list) or that changed in a sort
+        // field is placed by the sort; the others keep the server's order, whose collation may differ from ours.
+        const placed = (row) => local.has(key(row))
+            && (!listed.has(key(row)) || sorts.some(([field]) => origins.get(key(row))?.[field] !== row[field]));
+        const server = data.filter((row) => !placed(row));
+        // Only when the server's rows carry every sort field to compare on; a placed row without one sorts as empty.
+        if (sorts.every(([field]) => server.every((row) => own(row, field)))) {
+            for (const row of data.filter(placed)) {
+                // Before the first row (server or placed) it sorts before; -1 >>> 0 is past the end, so it appends.
+                const at = server.findIndex((other) => sorts.reduce((result, [field, sign]) => result || sign * compare(row[field], other[field]), 0) < 0);
+                server.splice(at >>> 0, 0, row);
+            }
+            data = server;
+        }
         return {
             ...response,
-            data: (page.number === 1 ? [...joined, ...kept] : kept).map((row) => pick(row, query)),
+            data: data.map((row) => pick(row, query)),
             meta: { ...response.meta, page: { ...page, total } },
         };
     };
@@ -268,7 +305,7 @@ export function simulatedWrites(client, name) {
         return copy === undefined ? client.get(id, query, init) : answer(200, pick(copy, query));
     };
     // The row as it is here; a real one's server copy is kept the first time it changes.
-    const own = async (id) => {
+    const current = async (id) => {
         const { data } = await get(id);
         if (!local.has(String(id))) {
             origins.set(String(id), data);
@@ -299,14 +336,14 @@ export function simulatedWrites(client, name) {
             return answer(201, { ...row });
         },
         async update(id, body) {
-            const data = await own(id);
+            const data = await current(id);
             const row = { ...data, ...body, id: data.id };
             local.set(String(id), row);
             return answer(200, { ...row });
         },
         // As the server: an id that is not there is a 404, and a delete never lowers a count for nothing.
         async delete(id) {
-            await own(id);
+            await current(id);
             local.delete(String(id));
             deleted.add(String(id));
             return answer(204, null);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cube-nl/dmp-sdk",
-  "version": "1.1.0-rc.1",
+  "version": "1.1.0-rc.2",
   "description": "Dependency-free TypeScript client for the Cube DMP REST API (cube/api), with OAuth 2.1 + PKCE, and CubeApp for no-build apps (preview on mock data, live on the DMP).",
   "license": "MIT",
   "type": "module",
@@ -25,7 +25,10 @@
     "access": "public",
     "tag": "next"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/trial.js",
+    "./dist/cube-sdk.js"
+  ],
   "engines": {
     "node": ">=20"
   },