@peabody-soft/mbs-model-ts 1.10.0 → 1.12.0

package/dist/Catalog.d.ts

@@ -16,6 +16,8 @@ export default class Catalog {
     getCategory(productCategoryId: bigint): ProductCategory | null;
     getProduct(productId: bigint): Product | null;
     getPackage(packageId: bigint): Package | null;
+    getProductForDisplay(productId: bigint): Product | null;
+    getPackageForDisplay(packageId: bigint): Package | null;
     static comparePackages(left: Package, right: Package): number;
     static compareByName(left: Item, right: Item): number;
     private static compareNames;
@@ -27,6 +29,8 @@ export default class Catalog {
     private readonly _allProducts;
     private readonly _uncategorized;
     private readonly _candidatePackages;
+    private readonly _displayProductMap;
+    private readonly _displayPackageMap;
     private readonly _priceListMap;
     private _currentSalePriceListId;
     private _categories;

package/dist/Catalog.js

@@ -13,6 +13,7 @@ class Catalog {
     constructor(categories, products, packages, priceLists, prices) {
         // Every package that has a product, by that product's id, whether it can be bought or not
         this._candidatePackages = new Map();
+        this._displayPackageMap = new Map();
         this._priceListMap = new Map();
         this._currentSalePriceListId = DEFAULT_SALE_PRICE_LIST_ID;
         // What a customer can reach, rebuilt by applySalePriceList
@@ -31,11 +32,13 @@ class Catalog {
         const productsById = new Map();
         for (const product of products)
             productsById.set(product.id, product);
+        this._displayProductMap = productsById;
         for (const pkg of packages) {
             const product = productsById.get(pkg.productId);
             if (product === undefined)
                 continue;
             UpdatableEntity.setParent(pkg, product);
+            this._displayPackageMap.set(pkg.id, pkg);
             const productPackages = this._candidatePackages.get(product.id);
             if (productPackages === undefined)
                 this._candidatePackages.set(product.id, [pkg]);
@@ -110,6 +113,25 @@ class Catalog {
     getPackage(packageId) {
         return this._packageMap.get(packageId) ?? null;
     }
+    // Like getProduct, but for any product that the server sent, whether it can be bought or not: it
+    // is disabled, or it has nothing left to buy. It is for drawing a shopping list that already
+    // exists, such as an order that was placed, whose line can name a product that is no longer
+    // sold. Do not use it to offer anything for sale. Its packages are not on offer either:
+    // Product.packages keeps only the buyable ones, so it is empty for a product that cannot be
+    // bought. Null for an unknown id.
+    getProductForDisplay(productId) {
+        return this._displayProductMap.get(productId) ?? null;
+    }
+    // Like getPackage, but for any package of a product that the server sent, whether it can be
+    // bought or not: it is disabled, it has no enabled price, or its product is disabled. For
+    // drawing a shopping list that already exists (see getProductForDisplay), not for offering
+    // anything for sale. Package.price is the price in the current sale price list, null when there
+    // is none, and disabled when the package is not in that list. Null for an unknown id, and for
+    // the four reserved package ids a shopping list uses for its charge and summary lines (see
+    // Ids.isReservedPackageId).
+    getPackageForDisplay(packageId) {
+        return this._displayPackageMap.get(packageId) ?? null;
+    }
     // Display comparator for packages, matching the merchant app's PackageComparator minus the
     // clauses a storefront cannot exercise (disabled packages and the purchase price list, neither sent)
     static comparePackages(left, right) {

package/dist/Ids.d.ts

@@ -13,6 +13,7 @@ export default class Ids {
     static readonly GENERAL_SETTINGS_CONFIGURATION_ID: bigint;
     static readonly ATTACHMENT_BASE_URL_BLOB_ID: bigint;
     static readonly AUTH_TOKENS_BLOB_ID: bigint;
+    static readonly USER_ID_BLOB_ID: bigint;
     private static readonly SYNC_CURSOR_BLOB_ID_BASE;
     private static readonly UNSIGNED_64_BIT_MASK;
     private static readonly UNSIGNED_32_BIT_MASK;

package/dist/Ids.js

@@ -15,8 +15,8 @@ class Ids {
         return (BigInt(entityTypeId) << Ids.ENTITY_TYPE_BIT_SHIFT) | (lowPart & Ids.ID_MASK);
     }
     // The cart's message id: the business link id with the entity type swapped for the message one
-    // (Java Message.getPartyPreferencesMessageId). Derived because a sync in answers with an update
-    // number and no id, so a cart the server named could not be stored. One link has one cart.
+    // (Java Message.getPartyPreferencesMessageId). One link has one cart. The server stores a cart
+    // only under this id, and refuses an order that has it.
     static getPartyPreferencesMessageId(businessLinkId) {
         return Ids.buildId(proto_Constants.MESSAGE_ENTITY_TYPE_ID, Ids.getLowPart(businessLinkId));
     }
@@ -74,7 +74,9 @@ Ids.GENERAL_SETTINGS_CONFIGURATION_ID = 0x0d10000000000000n;
 Ids.ATTACHMENT_BASE_URL_BLOB_ID = -1n;
 // Where a container keeps the credentials that sign its calls (see AuthTokens). Written with a null eTag, since a reissued token is not a later version of the earlier one. The latest wins.
 Ids.AUTH_TOKENS_BLOB_ID = -2n;
-// The first of a block of fixed blob ids, one per key (see getSyncCursorBlobId). A key is an entity type id, below 0x80, so the block runs from -0x100 down to -0x17F and cannot meet the fixed blobs at -1 and -2.
+// Where a profile container keeps the id that the next sign up creates the user under (see Model.createUser). Written with a null eTag, since a new id replaces the old one. It is the one blob a container holds that no response carried.
+Ids.USER_ID_BLOB_ID = -3n;
+// The first of a block of fixed blob ids, one per key (see getSyncCursorBlobId). A key is an entity type id, below 0x80, so the block runs from -0x100 down to -0x17F and cannot meet the fixed blobs at -1, -2 and -3.
 Ids.SYNC_CURSOR_BLOB_ID_BASE = -0x100n;
 Ids.UNSIGNED_64_BIT_MASK = (1n << 64n) - 1n;
 Ids.UNSIGNED_32_BIT_MASK = (1n << 32n) - 1n;

package/dist/Message.d.ts

@@ -5,12 +5,8 @@ export default abstract class Message extends Entity {
     private readonly _senderId;
     private readonly _messageType;
     private readonly _taskStatus;
-    private readonly _senderName;
-    private readonly _senderPhone;
-    protected constructor(header: EntityHeader, _senderId: bigint, _messageType: proto_MessageType, _taskStatus: proto_TaskStatus, _senderName: string | null, _senderPhone: string | null);
+    protected constructor(header: EntityHeader, _senderId: bigint, _messageType: proto_MessageType, _taskStatus: proto_TaskStatus);
     get senderId(): bigint;
     get messageType(): proto_MessageType;
     get taskStatus(): proto_TaskStatus;
-    get senderName(): string | null;
-    get senderPhone(): string | null;
 }

package/dist/Message.js

@@ -2,17 +2,14 @@ import Entity from "./Entity";
 // Something a customer sent to a business: an order (sales order) or a shopping cart (party preferences), the two payloads this library understands.
 // A business entity despite being customer-authored, since Java authorizes the message table through Right.MESSAGES_MODIFY against the business.
 export default class Message extends Entity {
-    constructor(header, _senderId, _messageType, _taskStatus, _senderName, _senderPhone) {
+    constructor(header, _senderId, _messageType, _taskStatus) {
         super(header);
         this._senderId = _senderId;
         this._messageType = _messageType;
         this._taskStatus = _taskStatus;
-        this._senderName = _senderName;
-        this._senderPhone = _senderPhone;
     }
     // The customer's party id at the business (BusinessLink.partyId), not the id of their User. A
-    // business sync out sends a customer only messages from their own party. senderName and
-    // senderPhone identify the sender without resolving the party.
+    // business sync out sends a customer only messages from their own party.
     get senderId() {
         return this._senderId;
     }
@@ -23,11 +20,4 @@ export default class Message extends Entity {
     get taskStatus() {
         return this._taskStatus;
     }
-    get senderName() {
-        return this._senderName;
-    }
-    // E.164 formatted
-    get senderPhone() {
-        return this._senderPhone;
-    }
 }

package/dist/Model.d.ts

@@ -23,7 +23,7 @@ export default class Model {
     updateCartLocalOnly(shoppingList: ShoppingList): Promise<void>;
     createOrder(orderId: bigint, fulfillmentMode: proto_FulfillmentMode, deliveryAddressId: bigint, deliveryAddress: Address | null, note: string | null): Promise<void>;
     private beginSignIn;
-    private pushBusinessMessages;
+    private sendBusinessMessages;
     private storeCartInCache;
     private requireBusinessBeingBrowsed;
     private requireCustomerOfBusiness;
@@ -35,15 +35,15 @@ export default class Model {
     private static isBusinessNamed;
     private requireBusinessLink;
     private readJoinBusinessId;
+    private getVettedBusiness;
     private static findBusinessEntity;
     private static findBusinessLink;
     private static getBusinessContainerName;
     private requireBusinessAuthTokens;
     private profileSyncIn;
     private createProfileOnServer;
+    private readProfilePages;
     private static requireJoinedBusiness;
-    private cacheProfileResponse;
-    private writeProfileResponse;
     private storeIssuedTokens;
     private getProfileContainerName;
     private requireProfileContainerName;

package/dist/Model.js

@@ -1,5 +1,4 @@
 import { Constants as proto_Constants } from "./generated/Constants";
-import { CreateUserRequest as proto_CreateUserRequest } from "./generated/CreateUserRequest";
 import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
 import AuthTokens from "./AuthTokens";
 import * as ContainerNames from "./ContainerNames";
@@ -8,7 +7,7 @@ import Ids from "./Ids";
 import LiveData from "./LiveData";
 import { canonicalizeBusinessId } from "./Profile";
 import * as ProtoMap from "./ProtoMap";
-import { InternalServerException, NotFoundException } from "./ServiceExceptions";
+import { ConflictException, InternalServerException, NotFoundException } from "./ServiceExceptions";
 import ShoppingList from "./ShoppingList";
 import SyncCache from "./SyncCache";
 import * as SyncKeys from "./SyncKeys";
@@ -63,7 +62,7 @@ class Model {
     // Signs in and syncs this subject's profile in, for a subject the server has a profile for (use
     // createUser otherwise). Also reads in the business being browsed, if any, as this customer.
     //
-    // Anything thrown after beginSignIn's guard (a bad credential, a rejected push while reading the
+    // Anything thrown after beginSignIn's guard (a bad credential, a rejected request while reading the
     // business) calls signOut. profileSyncIn publishes a cached profile before it reaches the
     // network, so a retry could otherwise find _profile set and fail the "already signed in" guard.
     // Throws NotFoundException if the business being browsed cannot be opened. See businessSyncIn.
@@ -84,22 +83,64 @@ class Model {
     // profile for (use signIn otherwise). Also reads in the business being browsed, if any, as this
     // customer. Throws NotFoundException if that business cannot be opened (see businessSyncIn), after
     // the User exists. The sign-up is not undone: the customer stays signed up and signed in.
+    // - The user is created under an id this model makes for the subject, not userToCreate.id. One id
+    //   is made per subject and saved in the profile container before the call, and every attempt of
+    //   that subject sends it until the sign up is stored or refused with a ConflictException. It is
+    //   kept after a network error, a 5xx and any other error (a 400, a 401), and a successful signIn
+    //   does not delete it. It is deleted once the answer is stored, and by a ConflictException.
+    // - A ConflictException means the server could not create the user: the subject has one already,
+    //   or the id could not be used. It is rethrown, and this method does not sign in: the caller signs
+    //   in, which reads the profile. If signIn answers UnauthorizedException the subject has no
+    //   profile, and the caller creates again. The saved id is already deleted, so that sign up makes
+    //   a new one.
+    // - When the business being browsed is published and was read to the end, the call joins it too,
+    //   so the answer holds the link and the business and no second call is needed. If the server then
+    //   answers a NotFoundException, the user was created but the join was rejected, and no answer came
+    //   back: the profile is read without a join, and the business read that follows makes the join
+    //   again, which throws. A NotFoundException when no join was sent is rethrown at once.
     async createUser(authenticationMethod, subjectId, authenticationToken, userToCreate) {
         this.beginSignIn(authenticationMethod, subjectId, authenticationToken);
         const authTokens = await this.requireProfileAuthTokens();
-        await this.createProfileOnServer(proto_CreateUserRequest.create({ user: ProtoMap.buildUser(userToCreate) }), authTokens);
+        const containerName = this.requireProfileContainerName();
+        const cache = Model.getCache();
+        let userId = await cache.readUserId(containerName);
+        if (userId === null) {
+            userId = Ids.getNewId(proto_Constants.USER_ENTITY_TYPE_ID);
+            await cache.writeUserId(containerName, userId);
+        }
+        // A subject with no profile has nothing synced, so every cursor is zero
+        const noCursors = new SyncState(SyncKeys.PROFILE_SYNC_IN);
+        const joinBusinessId = this.getVettedBusiness()?.id ?? BigInt(proto_Constants.ENTITY_ID_NULL);
+        try {
+            await this.createProfileOnServer(ProtoMap.buildUserRequest(ProtoMap.buildUser(userToCreate, userId), noCursors, joinBusinessId), authTokens);
+        }
+        catch (error) {
+            if (error instanceof ConflictException) {
+                await cache.deleteUserId(containerName);
+                throw error;
+            }
+            const isJoinRefused = error instanceof NotFoundException &&
+                joinBusinessId !== BigInt(proto_Constants.ENTITY_ID_NULL);
+            if (!isJoinRefused)
+                throw error;
+            await this.profileSyncIn(ProtoMap.buildProfileSyncOutRequest(noCursors), await this.requireProfileAuthTokens());
+            await cache.deleteUserId(containerName);
+        }
         if (this._businessId !== null)
             await this.businessSyncIn();
     }
     // Updates this customer's own profile with what userProfile holds. Service.updateUser matches the
     // caller against the User by entity id (see ProtoMap.buildUpdateUser), so userProfile must be this
-    // customer's own, read in earlier, not built fresh. Throws if no profile has been read. Not
-    // paged. Publishes nothing today: the response carries no entities, only reissued tokens (see
-    // writeProfileResponse).
+    // customer's own, read in earlier, not built fresh. Throws if no profile has been read. The answer
+    // is cached and published as a profile read is, so the User as the server stored it replaces the
+    // held one (see readProfilePages).
     async updateUser(userProfile) {
         if (this._profile.value === null)
             throw new IllegalOperationException("Nobody is signed in, so this call cannot be made");
-        await this.writeProfileResponse(await Model.getService().updateUser(ProtoMap.buildUpdateUser(userProfile), await this.requireProfileAuthTokens()));
+        const containerName = this.requireProfileContainerName();
+        const request = ProtoMap.buildUserRequest(ProtoMap.buildUpdateUser(userProfile), await Model.getCache().readProfileCursors(containerName));
+        const authTokens = await this.requireProfileAuthTokens();
+        await this.readProfilePages(containerName, ProtoMap.getUserRequestSyncOutRequest(request), authTokens, () => Model.getService().updateUser(request, authTokens));
     }
     // Discards this model. The next getInstance() builds a fresh one, signed out and browsing nothing.
     async signOut() {
@@ -131,7 +172,7 @@ class Model {
     // order placed from it. Both need a customer who is a member of the business (see
     // requireCustomerOfBusiness), except that a signed-out visitor can keep a cart locally (see
     // updateCartLocalOnly).
-    // An order reaches the store only after the server accepts it, so a customer never holds an order
+    // An order reaches the store only after the server accepts it, so a customer never has an order
     // the server has not accepted, and a failed call leaves nothing to reconcile. A cart can be
     // stored before the server has it (see updateCartLocalOnly).
     // Creates or replaces this customer's cart, on the server and in the store. An empty list
@@ -139,9 +180,11 @@ class Model {
     // Signed out, this calls updateCartLocalOnly, as the server has no cart for a visitor. Signed in,
     // it costs a request, so an editor should write each change with updateCartLocalOnly and call this
     // on a schedule (debounced, on blur, on a timer).
-    // A call that matches the stored copy returns without a request (hasShoppingListChanged). It does
-    // not replace a read of the business: the response to a push holds only the pushed messages, so
-    // it brings no changes made by others.
+    // A call that matches the stored copy returns without a request (hasShoppingListChanged), and so
+    // reads nothing. A call that sends gets back the customer's messages that are newer than the last
+    // read, the cart among them: a change that the business made to an order comes with it. It brings
+    // nothing of the rest of the business, so it does not replace a read of it.
+    // The cart is sent as a whole and replaces the stored cart if it is dated later.
     async updateCart(shoppingList) {
         if (this._profile.value === null)
             return this.updateCartLocalOnly(shoppingList);
@@ -150,7 +193,7 @@ class Model {
         if (!ProtoMap.hasShoppingListChanged(stored, shoppingList))
             return;
         const partyPreferencesMessage = ProtoMap.buildPartyPreferencesMessage(Ids.getPartyPreferencesMessageId(target.businessLink.id), stored, target.senderId, shoppingList, null, BigInt(Date.now()));
-        await this.pushBusinessMessages(target, [partyPreferencesMessage]);
+        await this.sendBusinessMessages(target, [partyPreferencesMessage]);
     }
     // The same, but stored locally and not sent. Call it on every edit (a request per tap of a
     // quantity stepper is too many), and call updateCart on a schedule to send.
@@ -161,12 +204,17 @@ class Model {
     // the update number of the copy it amends, buildPartyPreferencesMessage dates it past that copy,
     // and the later copy wins.
     async updateCartLocalOnly(shoppingList) {
-        // A signed-out visitor has no membership to derive a message id from, so a fresh id is drawn.
-        // It is the cart's id only for the first edit: buildPartyPreferencesMessage reuses the stored
-        // cart's id, so later edits amend one entity. With no party, the sender is ENTITY_ID_NULL. The
-        // first push after signing in carries the real one.
-        if (this._profile.value === null)
-            return this.storeCartInCache(ContainerNames.forBusiness(this.requireBusinessBeingBrowsed()), Ids.getNewId(proto_Constants.MESSAGE_ENTITY_TYPE_ID), BigInt(proto_Constants.ENTITY_ID_NULL), shoppingList);
+        // A signed-out visitor has no membership to derive a message id from, so a fresh id is drawn for
+        // the first edit and the stored cart keeps it, so later edits amend one entity. With no party, the
+        // sender is ENTITY_ID_NULL. A visitor's cart is never sent as it is: signing in sends a new cart
+        // under the id of the membership (see businessSyncIn).
+        if (this._profile.value === null) {
+            const containerName = ContainerNames.forBusiness(this.requireBusinessBeingBrowsed());
+            const stored = await Model.getCache().readPartyPreferences(containerName);
+            return this.storeCartInCache(containerName, stored === null
+                ? Ids.getNewId(proto_Constants.MESSAGE_ENTITY_TYPE_ID)
+                : ProtoMap.getMessageId(stored), BigInt(proto_Constants.ENTITY_ID_NULL), shoppingList);
+        }
         const target = this.requireCustomerOfBusiness();
         return this.storeCartInCache(target.containerName, Ids.getPartyPreferencesMessageId(target.businessLink.id), target.senderId, shoppingList);
     }
@@ -176,10 +224,14 @@ class Model {
     // The emptied cart records this fulfillmentMode, which Business.defaultFulfillmentMode returns.
     // The caller creates orderId with Ids.getNewId(Constants.MESSAGE_ENTITY_TYPE_ID), so it can find
     // the placed order, and can retry a call that a NetworkConnectionException left unresolved using
-    // the same id, without placing a second order. getPartyPreferencesMessageId gives a cart the same
-    // guarantee.
+    // the same id, without placing a second order: the server stores an order only if no message has
+    // its id, so a retry changes nothing, even after the business has started the order. The cart has
+    // one id for the same reason (see getPartyPreferencesMessageId).
     // A delivery must name an address: an id from this customer's list, or a full address sent
-    // directly (see requireDeliveryAddress).
+    // directly (see requireDeliveryAddress). Either way the address goes to the business with the
+    // order, in the party of the customer, so a full address has an id that is not zero.
+    // The party of the customer goes with every order: their name and phone number, and the delivery
+    // address of an order that is delivered. It is not sent with a cart.
     async createOrder(orderId, fulfillmentMode, deliveryAddressId, deliveryAddress, note) {
         const target = this.requireCustomerOfBusiness();
         // Read from the store rather than the published Business, so the order matches the stored cart
@@ -190,16 +242,25 @@ class Model {
             : ProtoMap.buildShoppingList(partyPreferencesMessage, target.countryCode);
         if (shoppingList.existingItems.length === 0)
             throw new IllegalOperationException("The cart holds nothing, so there is no order to place");
-        Model.requireDeliveryAddress(target.addresses, fulfillmentMode, deliveryAddressId, deliveryAddress);
+        Model.requireDeliveryAddress(target.user.addresses, fulfillmentMode, deliveryAddressId, deliveryAddress);
+        // A delivery is where the party of the customer gets an address, as in the merchant app, which adds
+        // the delivery address of an order to the party and none for a pick-up. It is the address of the
+        // order: the one sent whole, else the one the id names in the customer's list.
+        const partyAddress = fulfillmentMode === proto_FulfillmentMode.DELIVERY
+            ? (deliveryAddress ?? target.user.addresses.getAddress(deliveryAddressId))
+            : null;
+        if (partyAddress !== null && partyAddress.id === BigInt(proto_Constants.ENTITY_ID_NULL))
+            throw new InvalidArgumentException("An address to deliver to has an id of its own, which is how the party of the customer keeps it");
         // One timestamp for both messages: the time the order was placed
         const now = BigInt(Date.now());
-        // One request for the order and the emptied cart: two calls could leave an order placed and the
-        // cart still full if the second failed
-        await this.pushBusinessMessages(target, [
+        // One request for the order, the emptied cart and the party: two calls could leave an order placed
+        // and the cart still full if the second failed. The party goes with every order, one sent again
+        // included, and with nothing else: the server refuses a party that has no order with it.
+        await this.sendBusinessMessages(target, [
             ProtoMap.buildOrderMessage(orderId, target.senderId, shoppingList, fulfillmentMode, deliveryAddressId, deliveryAddress, note, now),
             // The customer's latest choice of fulfillmentMode, for defaultFulfillmentMode to offer next time
             ProtoMap.buildPartyPreferencesMessage(Ids.getPartyPreferencesMessageId(target.businessLink.id), partyPreferencesMessage, target.senderId, null, fulfillmentMode, now),
-        ]);
+        ], ProtoMap.buildParty(target.user, partyAddress));
     }
     // #endregion
     // Throws if a profile is already held, otherwise stores the credentials every later call signs
@@ -211,32 +272,40 @@ class Model {
         this._subjectId = subjectId;
         this._authenticationToken = authenticationToken;
     }
-    // #region Pushing
-    // Pushes the messages in one request, together with the update number this business container's
-    // reads have reached, then stores the response. The server answers with these messages under their
-    // assigned update numbers and nothing else: a push is not a read. They are stored without moving
-    // any cursor, so the next read receives them again, along with anything others changed in the
-    // meantime. A rejected push throws from the Service call itself, as for any bad status, so
-    // reaching the write below means the server accepted it.
-    async pushBusinessMessages(target, messages) {
+    // #region Sending
+    // Sends the messages, and the party of the customer if there is one, in one request, together with
+    // the update number this business container's reads have reached, then stores the response.
+    // The server answers with a sync out of the customer's messages, made after it writes: the stored
+    // messages that are newer than that update number, in the order of their update numbers, with the
+    // ones that were sent among them, and not in the order they were sent in. It is stored as a page of
+    // a read is, and moves the message cursor the same way. A message that was not stored (an order
+    // whose id exists, a cart dated no later than the stored one) is in it only if the stored message
+    // is newer than the cursor, and then it is the stored message. The cache has every message at or
+    // below the cursor, so what a caller needs afterwards is read from the cache by id.
+    // A full page may have more behind it, which is read as a read reads. A rejected request throws
+    // from the Service call itself, as for any bad status, so reaching the write below means the
+    // server accepted it.
+    async sendBusinessMessages(target, messages, party = null) {
         const cache = Model.getCache();
         const messageUpdateNumber = await cache.readMessageUpdateNumber(target.containerName);
         const authTokens = await this.requireBusinessAuthTokens(target.containerName, target.businessLink);
-        const response = await Model.getService().businessSyncIn(ProtoMap.buildBusinessSyncInRequest(messageUpdateNumber, messages), ProtoMap.buildAuthTokens(authTokens));
+        const request = ProtoMap.buildBusinessSyncInRequest(messageUpdateNumber, messages, party);
+        const response = await Model.getService().businessSyncIn(request, ProtoMap.buildAuthTokens(authTokens));
         await this.storeIssuedTokens(ProtoMap.getResponseAuthTokens(response), target.containerName);
-        // Stored as the response carried them: the server answers with the messages themselves, so
-        // nothing is stamped
-        const changeCount = await cache.writeMessages(target.containerName, ProtoMap.getSyncInResponseMessages(response));
+        let changeCount = await cache.writeMessages(target.containerName, ProtoMap.getSyncInResponseMessages(response));
+        // Read on from the cursor the page moved, with the tokens the response may have renewed
+        if (ProtoMap.isSyncInResponseFull(request, response))
+            changeCount += await this.readBusinessPages(target.containerName, target.businessLink.businessId, await cache.readBusinessCursors(target.containerName), ProtoMap.getBusinessResponseAttachmentBaseUrlExpiry(await cache.readBusiness(target.containerName)), ProtoMap.buildAuthTokens(await this.requireBusinessAuthTokens(target.containerName, target.businessLink)));
         // What the store took decides whether anything is published - see the Publishing region
         if (changeCount !== 0)
             this.publishBusiness(await cache.readBusiness(target.containerName));
     }
-    // Amends the cart containerName holds and writes the result to the cache. Nothing is pushed.
+    // Amends the cart containerName stores and writes the result to the cache. Nothing is sent.
     // The two callers differ in container, id and sender: see updateCartLocalOnly.
     async storeCartInCache(containerName, messageId, senderId, shoppingList) {
         const cache = Model.getCache();
         const changeCount = await cache.writePartyPreferences(containerName, ProtoMap.buildPartyPreferencesMessage(messageId, await cache.readPartyPreferences(containerName), senderId, shoppingList, null, BigInt(Date.now())));
-        // Published on what the store took, as for every read and push
+        // Published on what the store took, as for every read and sync in
         if (changeCount !== 0)
             this.publishBusiness(await cache.readBusiness(containerName));
     }
@@ -268,7 +337,7 @@ class Model {
             businessLink: businessLink,
             containerName: Model.getBusinessContainerName(businessLink),
             senderId: businessLink.partyId,
-            addresses: user.addresses,
+            user: user,
             countryCode: business.countryCode,
         };
     }
@@ -292,7 +361,8 @@ class Model {
     // #region The four calls of Service, each as this model makes it
     //
     // Each caches the response (a read caches every page as it arrives), files the tokens the server
-    // issued, and publishes what the cache then holds. A read is paged. A sign up and an update are not.
+    // issued, and publishes what the cache then holds. A read is paged, and the answer to a sign up or
+    // an update is the first page of a profile read.
     // Reads in the business being browsed: an anonymous visitor under its businessId, a signed-in
     // customer under their own container (see getBusinessContainerName), joining as a customer first
     // if not linked (see requireBusinessLink).
@@ -529,8 +599,8 @@ class Model {
     // A business published from the cache by a read that has not ended is not known to be open or to
     // be the one the businessId names, so a customer is not joined to it.
     async readJoinBusinessId(businessId) {
-        const alreadyHeld = this._business.value;
-        if (alreadyHeld !== null && this._isPublishedBusinessVetted)
+        const alreadyHeld = this.getVettedBusiness();
+        if (alreadyHeld !== null)
             return alreadyHeld.id;
         await this.syncAnonymousBusiness(businessId);
         // A missing business is a NotFoundException from the read above. Reaching here with none
@@ -540,6 +610,12 @@ class Model {
             throw new InternalServerException(`The read of business ${businessId} answered with no Business`);
         return business.id;
     }
+    // The business being browsed, if it is published and has been read to the end and found open. A
+    // business published from the cache by a read that has not ended is not known to be either, so
+    // this is null for it.
+    getVettedBusiness() {
+        return this._isPublishedBusinessVetted ? this._business.value : null;
+    }
     static findBusinessEntity(profile, businessId) {
         const wanted = canonicalizeBusinessId(businessId);
         for (const business of profile.businesses)
@@ -600,9 +676,26 @@ class Model {
     async profileSyncIn(firstRequest, firstAuthTokens) {
         const containerName = this.getProfileContainerName();
         if (containerName === null)
-            return null;
-        const cached = await Model.getCache().readProfile(containerName);
-        this.publishProfile(cached);
+            return;
+        this.publishProfile(await Model.getCache().readProfile(containerName));
+        await this.readProfilePages(containerName, firstRequest, firstAuthTokens, () => Model.getService().profileSyncOut(firstRequest, firstAuthTokens));
+    }
+    // The sign-up call. Its answer is the first page of a profile read, which readProfilePages
+    // continues if the page is full. The id saved for the sign up is deleted once that page is stored.
+    async createProfileOnServer(request, authTokens) {
+        const containerName = this.requireProfileContainerName();
+        await this.readProfilePages(containerName, ProtoMap.getUserRequestSyncOutRequest(request), authTokens, () => Model.getService().createUser(request, authTokens), () => Model.getCache().deleteUserId(containerName));
+    }
+    // Caches and publishes a profile read of the pages that firstRequest starts. sendFirstPage makes
+    // the first call: profileSyncOut for a read, createUser or updateUser for a write, which answers
+    // with the first page of the read that its profileSyncOutRequest describes. Later pages are read
+    // with profileSyncOut, because a write cannot be sent again.
+    // Each page is cached, moving the cursors, and the tokens it reissues are stored. afterFirstPage
+    // runs once the first page and its tokens are stored. The profile is published once, and only if
+    // the store took something. The join is checked last, so everything that arrived is cached and
+    // published before it can throw: the pages are valid even when the join is not.
+    async readProfilePages(containerName, firstRequest, firstAuthTokens, sendFirstPage, afterFirstPage = null) {
+        const cache = Model.getCache();
         let request = firstRequest;
         let authTokens = firstAuthTokens;
         let changeCount = 0;
@@ -611,9 +704,14 @@ class Model {
         const joinBusinessId = firstRequest.joinBusinessId;
         let hasJoinedLink = false;
         let hasJoinedBusiness = false;
+        let page = await sendFirstPage();
         for (;;) {
-            const page = await Model.getService().profileSyncOut(request, authTokens);
-            changeCount += await this.cacheProfileResponse(containerName, page, true);
+            changeCount += await cache.writeProfile(containerName, page);
+            await this.storeIssuedTokens(ProtoMap.getResponseAuthTokens(page), containerName);
+            if (afterFirstPage !== null) {
+                await afterFirstPage();
+                afterFirstPage = null;
+            }
             if (ProtoMap.hasJoinedBusinessLink(joinBusinessId, page))
                 hasJoinedLink = true;
             if (ProtoMap.hasJoinedBusiness(joinBusinessId, page))
@@ -625,36 +723,19 @@ class Model {
             // Each call after the first is signed with what the previous page reissued, since a token can
             // expire part way through a long read
             authTokens = ProtoMap.refreshAuthTokens(authTokens, ProtoMap.getResponseAuthTokens(page));
+            page = await Model.getService().profileSyncOut(request, authTokens);
         }
-        // As above: nothing the store took, nothing published
-        let response = cached;
-        if (changeCount !== 0) {
-            response = await Model.getCache().readProfile(containerName);
-            this.publishProfile(response);
-        }
-        // Checked last, so everything that arrived is cached and published before this can throw. The
-        // pages are valid even when the join is not.
+        if (changeCount !== 0)
+            this.publishProfile(await cache.readProfile(containerName));
+        // After a sign up the User exists whatever became of the join, so what came back is kept and
+        // published before this throws
         Model.requireJoinedBusiness(joinBusinessId, hasJoinedLink, hasJoinedBusiness);
-        return response;
-    }
-    // The sign-up call. Not paged: resending it would create a second user, and a new caller has at
-    // most their User, one BusinessLink and the Business it names. It can join a business in the same
-    // call, with the same join requirements as a profile read, in one response.
-    async createProfileOnServer(request, authTokens) {
-        const response = await this.writeProfileResponse(await Model.getService().createUser(request, authTokens));
-        const joinBusinessId = request.joinBusinessId;
-        // Raised after the response is cached and published, as on a profile read. It matters more
-        // here: the User exists regardless of the join, so discarding the response and signing up
-        // again would create a second one
-        Model.requireJoinedBusiness(joinBusinessId, ProtoMap.hasJoinedBusinessLink(joinBusinessId, response), ProtoMap.hasJoinedBusiness(joinBusinessId, response));
-        return response;
     }
     // #endregion
     // #region Driving one call
     // Throws when a requested join is not answered with both the BusinessLink (the membership, whose
     // token signs calls) and the Business it names (whose businessId everything else is built from).
-    // Without both, the caller is a customer of something it cannot reach. Shared by the two calls
-    // that can carry a joinBusinessId.
+    // Without both, the caller is a customer of something it cannot reach.
     //
     // Throws a ServiceException, since the fault is the server's and not the caller's: the server
     // answered 200 and left out what was asked for. The 500 status means a retry is worthwhile.
@@ -673,34 +754,6 @@ class Model {
                 : "BusinessLink";
         throw new InternalServerException(`A join of business ${joinBusinessId} was answered with no ${missing}`);
     }
-    // Caches the entities of a profile response and files the tokens it reissued under the same
-    // container. Returns how much the store accepted, which decides whether anything is published.
-    // The three calls that receive a profile response (a page of a read, a sign up, an update) share
-    // this, so they cache and file tokens the same way. It does not publish: a read publishes once
-    // after all its pages, the other two once each.
-    // Only a page of a read moves the container's cursors. A sign up and an update are changes this
-    // client made and the next read brings them back, so they are stored without moving any.
-    async cacheProfileResponse(containerName, response, isPageOfRead) {
-        const cache = Model.getCache();
-        const changeCount = isPageOfRead
-            ? await cache.writeProfile(containerName, response)
-            : await cache.storeProfile(containerName, response);
-        await this.storeIssuedTokens(ProtoMap.getResponseAuthTokens(response), containerName);
-        return changeCount;
-    }
-    // Handles the response of a profile call other than a read: caches and publishes it, as for a
-    // paged read without the paging. Like a read, a sign up and an update publish only when the store
-    // accepted something. An update publishes nothing today because the server puts no entities in
-    // its response, only reissued tokens. If it ever answers with the stored User, whose update
-    // number and updated time a caller cannot know, this publishes it as the server sent it.
-    async writeProfileResponse(response) {
-        const containerName = this.getProfileContainerName();
-        if (containerName === null)
-            return response;
-        if ((await this.cacheProfileResponse(containerName, response, false)) !== 0)
-            this.publishProfile(await Model.getCache().readProfile(containerName));
-        return response;
-    }
     // Stores the tokens a call received in the container the call was about: a profile call's tokens
     // in the subject's profile container, a business call's in that business's container. The caller
     // picks the container, because a token does not record what it is for. A business sync out that
@@ -765,7 +818,8 @@ class Model {
     // over every page), whatever the response carried. The store keeps a blob only when its eTag is
     // later, so it can reject a response in full (a cursor that moved without its eTag resends an
     // entity already cached). Publishing then would notify every observer of an identical value.
-    // All four calls follow this, so an update publishes nothing (see writeProfileResponse).
+    // A sign up and an update follow this too, because their answer is the first page of a profile read
+    // (see readProfilePages).
     //
     // A business with online shopping off is not published, even from the cache, or a customer could
     // be joined to it. A read that finds the published business is no longer open, or that the server

package/dist/Order.d.ts

@@ -15,8 +15,8 @@ export default class Order extends Message {
     private readonly _deliveryAddress;
     private readonly _note;
     private readonly _paymentReceived;
-    static fromScaledValues(header: EntityHeader, senderId: bigint, taskStatus: proto_TaskStatus, senderName: string | null, senderPhone: string | null, status: proto_OrderStatus, fulfillmentMode: proto_FulfillmentMode, shoppingList: ShoppingList, scaledShoppingListTotal: bigint, shoppingListCount: number, deliveryAddressId: bigint, deliveryAddress: Address | null, creationDate: bigint, note: string | null, scaledPaymentReceived: bigint | undefined): Order;
-    constructor(header: EntityHeader, senderId: bigint, taskStatus: proto_TaskStatus, senderName: string | null, senderPhone: string | null, _status: proto_OrderStatus, _fulfillmentMode: proto_FulfillmentMode, _shoppingList: ShoppingList, _shoppingListTotal: number, _shoppingListCount: number, _deliveryAddressId: bigint, _deliveryAddress: Address | null, creationDate: bigint, _note: string | null, _paymentReceived: number | null);
+    static fromScaledValues(header: EntityHeader, senderId: bigint, taskStatus: proto_TaskStatus, status: proto_OrderStatus, fulfillmentMode: proto_FulfillmentMode, shoppingList: ShoppingList, scaledShoppingListTotal: bigint, shoppingListCount: number, deliveryAddressId: bigint, deliveryAddress: Address | null, creationDate: bigint, note: string | null, scaledPaymentReceived: bigint | undefined): Order;
+    constructor(header: EntityHeader, senderId: bigint, taskStatus: proto_TaskStatus, _status: proto_OrderStatus, _fulfillmentMode: proto_FulfillmentMode, _shoppingList: ShoppingList, _shoppingListTotal: number, _shoppingListCount: number, _deliveryAddressId: bigint, _deliveryAddress: Address | null, creationDate: bigint, _note: string | null, _paymentReceived: number | null);
     get status(): proto_OrderStatus;
     get fulfillmentMode(): proto_FulfillmentMode;
     get shoppingList(): ShoppingList;