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

package/dist/Order.js

@@ -8,11 +8,11 @@ import Message from "./Message";
 // business got with it.
 export default class Order extends Message {
     // For ProtoMap, which sees a total still multiplied by Constants.AMOUNT_FACTOR.
-    static fromScaledValues(header, senderId, taskStatus, senderName, senderPhone, status, fulfillmentMode, shoppingList, scaledShoppingListTotal, shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived) {
-        return new Order(header, senderId, taskStatus, senderName, senderPhone, status, fulfillmentMode, shoppingList, amountFromScaledValue(scaledShoppingListTotal), shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived === undefined ? null : amountFromScaledValue(scaledPaymentReceived));
+    static fromScaledValues(header, senderId, taskStatus, status, fulfillmentMode, shoppingList, scaledShoppingListTotal, shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived) {
+        return new Order(header, senderId, taskStatus, status, fulfillmentMode, shoppingList, amountFromScaledValue(scaledShoppingListTotal), shoppingListCount, deliveryAddressId, deliveryAddress, creationDate, note, scaledPaymentReceived === undefined ? null : amountFromScaledValue(scaledPaymentReceived));
     }
-    constructor(header, senderId, taskStatus, senderName, senderPhone, _status, _fulfillmentMode, _shoppingList, _shoppingListTotal, _shoppingListCount, _deliveryAddressId, _deliveryAddress, creationDate, _note, _paymentReceived) {
-        super(header, senderId, proto_MessageType.SALES_ORDER, taskStatus, senderName, senderPhone);
+    constructor(header, senderId, taskStatus, _status, _fulfillmentMode, _shoppingList, _shoppingListTotal, _shoppingListCount, _deliveryAddressId, _deliveryAddress, creationDate, _note, _paymentReceived) {
+        super(header, senderId, proto_MessageType.SALES_ORDER, taskStatus);
         this._status = _status;
         this._fulfillmentMode = _fulfillmentMode;
         this._shoppingList = _shoppingList;

package/dist/ProtoMap.d.ts

@@ -5,9 +5,11 @@ import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./genera
 import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
 import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
 import { Message as proto_Message } from "./generated/Message";
+import { Party as proto_Party } from "./generated/Party";
 import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
 import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
 import { User as proto_User } from "./generated/User";
+import { UserRequest as proto_UserRequest } from "./generated/UserRequest";
 import Address from "./Address";
 import AuthTokens from "./AuthTokens";
 import Business from "./Business";
@@ -34,11 +36,11 @@ export declare function getProfileResponseEntities(response: proto_ProfileSyncOu
 export declare function businessResponseToCacheWrite(response: proto_BusinessSyncOutResponse): CacheWrite;
 export declare function profileResponseToCacheWrite(response: proto_ProfileSyncOutResponse): CacheWrite;
 export declare function getBusinessResponseAttachmentBaseUrlExpiry(response: proto_BusinessSyncOutResponse | null): bigint;
-export declare function orderToBlob(order: proto_Message, heldETag: bigint | null): StoredBlob;
+export declare function orderToBlob(order: proto_Message, storedETag: bigint | null): StoredBlob;
 export declare function isPartyPreferencesMessage(message: proto_Message): boolean;
 export declare function getMessageUpdatedAt(message: proto_Message): bigint;
 export declare function getMessageId(message: proto_Message): bigint;
-export declare function partyPreferencesToBlob(partyPreferences: proto_Message, heldETag: bigint | null): StoredBlob;
+export declare function partyPreferencesToBlob(partyPreferences: proto_Message, storedETag: bigint | null): StoredBlob;
 export declare function businessResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_BusinessSyncOutResponse | null;
 export declare function profileResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_ProfileSyncOutResponse | null;
 export declare function deletedBusinessResponseFromBlobs(blobs: ReadonlyArray<StoredBlob>): proto_BusinessSyncOutResponse | null;
@@ -51,12 +53,16 @@ export declare function buildBusinessSyncOutRequest(business: string | bigint, s
 export declare function cursorsToBlobs(cursors: SyncState, movedKeys: ReadonlySet<number>): Array<StoredBlob>;
 export declare function cursorsFromBlobs(keys: ReadonlyArray<number>, blobs: ReadonlyArray<StoredBlob | null>): SyncState;
 export declare function raiseBusinessCursors(cursors: SyncState, response: proto_BusinessSyncOutResponse): ReadonlySet<number>;
-export declare function buildBusinessSyncInRequest(messageUpdateNumber: bigint, messages: ReadonlyArray<proto_Message>): proto_BusinessSyncInRequest;
+export declare function raiseMessageCursors(cursors: SyncState, messages: ReadonlyArray<proto_Message>): ReadonlySet<number>;
+export declare function buildBusinessSyncInRequest(messageUpdateNumber: bigint, messages: ReadonlyArray<proto_Message>, party?: proto_Party | null): proto_BusinessSyncInRequest;
 export declare function getSyncInResponseMessages(response: proto_BusinessSyncInResponse): ReadonlyArray<proto_Message>;
+export declare function isSyncInResponseFull(request: proto_BusinessSyncInRequest, response: proto_BusinessSyncInResponse): boolean;
 export declare function buildProfileSyncOutRequest(syncInState: SyncState, joinBusinessId?: bigint): proto_ProfileSyncOutRequest;
 export declare function raiseProfileCursors(cursors: SyncState, response: proto_ProfileSyncOutResponse): ReadonlySet<number>;
-export declare function buildUser(userProfile: UserProfile): proto_User;
+export declare function buildUser(userProfile: UserProfile, userId: bigint): proto_User;
 export declare function buildUpdateUser(userProfile: UserProfile): proto_User;
+export declare function buildUserRequest(user: proto_User, syncInState: SyncState, joinBusinessId?: bigint): proto_UserRequest;
+export declare function getUserRequestSyncOutRequest(request: proto_UserRequest): proto_ProfileSyncOutRequest;
 export declare function hasJoinedBusinessLink(joinBusinessId: bigint, response: proto_ProfileSyncOutResponse): boolean;
 export declare function hasJoinedBusiness(joinBusinessId: bigint, response: proto_ProfileSyncOutResponse): boolean;
 export declare function getBusinessResponseCountryCode(response: proto_BusinessSyncOutResponse | null): number | undefined;
@@ -68,6 +74,8 @@ export declare function authTokensFromProto(authTokens: proto_AuthTokens): AuthT
 export declare function buildAuthTokensBytes(authTokens: proto_AuthTokens): Uint8Array;
 export declare function authTokensToBlob(authTokens: AuthTokens): StoredBlob;
 export declare function authTokensFromBytes(bytes: Uint8Array): AuthTokens;
+export declare function userIdToBlob(userId: bigint): StoredBlob;
+export declare function userIdFromBytes(bytes: Uint8Array): bigint;
 export declare function getResponseAuthTokens(response: proto_BusinessSyncOutResponse | proto_BusinessSyncInResponse | proto_ProfileSyncOutResponse): proto_AuthTokens | undefined;
 export declare function refreshAuthTokens(authTokens: proto_AuthTokens, issued: proto_AuthTokens | undefined): proto_AuthTokens;
 export declare function refreshAuthTokens(authTokens: proto_AuthTokens | null, issued: proto_AuthTokens | undefined): proto_AuthTokens | null;
@@ -79,6 +87,7 @@ export declare function buildOrder(message: proto_Message, countryCode: number):
 export declare function buildShoppingList(message: proto_Message, countryCode: number): ShoppingList;
 export declare function buildPartyPreferencesMessage(messageId: bigint, existing: proto_Message | null, senderId: bigint, shoppingList: ShoppingList | null, fulfillmentMode: proto_FulfillmentMode | null, now: bigint): proto_Message;
 export declare function buildOrderMessage(orderId: bigint, senderId: bigint, shoppingList: ShoppingList, fulfillmentMode: proto_FulfillmentMode, deliveryAddressId: bigint, deliveryAddress: Address | null, note: string | null, creationDate: bigint): proto_Message;
+export declare function buildParty(user: UserProfile, deliveryAddress: Address | null): proto_Party;
 export declare function messagesToCacheWrite(messages: ReadonlyArray<proto_Message>): CacheWrite;
 export declare function hasShoppingListChanged(stored: proto_Message | null, shoppingList: ShoppingList): boolean;
 export declare function entityETag(updateNumber: bigint, updatedAt: bigint): bigint;

package/dist/ProtoMap.js

@@ -16,6 +16,7 @@ import { MessageType as proto_MessageType } from "./generated/MessageType";
 import { OnlineStoreTheme as proto_OnlineStoreTheme } from "./generated/OnlineStoreTheme";
 import { OrderStatus as proto_OrderStatus } from "./generated/OrderStatus";
 import { Package as proto_Package } from "./generated/Package";
+import { Party as proto_Party } from "./generated/Party";
 import { PartyPreferencesPayload as proto_PartyPreferencesPayload } from "./generated/PartyPreferencesPayload";
 import { Price as proto_Price } from "./generated/Price";
 import { PriceList as proto_PriceList } from "./generated/PriceList";
@@ -30,6 +31,7 @@ import { TaskStatus as proto_TaskStatus } from "./generated/TaskStatus";
 import { Tax as proto_Tax } from "./generated/Tax";
 import { UrlAndToken as proto_UrlAndToken } from "./generated/UrlAndToken";
 import { User as proto_User } from "./generated/User";
+import { UserRequest as proto_UserRequest } from "./generated/UserRequest";
 import Address, { AddressList } from "./Address";
 import Attachment from "./Attachment";
 import AttachmentBaseUrl from "./AttachmentBaseUrl";
@@ -73,8 +75,7 @@ export function getBusinessResponseEntities(response) {
         result.push(toWireEntity(attachment.entity, proto_Attachment.toBinary(attachment)));
     for (const configuration of response.configurations)
         result.push(toWireEntity(configuration.entity, proto_Configuration.toBinary(configuration)));
-    for (const message of response.messages)
-        result.push(toWireEntity(message.entity, proto_Message.toBinary(message)));
+    result.push(...getMessageEntities(response.messages));
     for (const productCategory of response.productCategories)
         result.push(toItemWireEntity(productCategory.item, proto_ProductCategory.toBinary(productCategory)));
     for (const product of response.products)
@@ -125,18 +126,18 @@ export function getBusinessResponseAttachmentBaseUrlExpiry(response) {
 }
 // One order as a blob, for a caller holding a message rather than a response. Only the payload says
 // whether a message is an order, so a message without a sales order throws here instead of being
-// stored where a read would not find it. heldETag is the eTag the container holds the order at, or
+// stored where a read would not find it. storedETag is the eTag the container holds the order at, or
 // null - see messageToBlob.
-export function orderToBlob(order, heldETag) {
+export function orderToBlob(order, storedETag) {
     if (order.payload.oneofKind !== "salesOrder")
         throw new InvalidArgumentException("That message carries no sales order, so it is not an order");
-    return messageToBlob(order, heldETag);
+    return messageToBlob(order, storedETag);
 }
 // Whether a message carries party preferences.
 export function isPartyPreferencesMessage(message) {
     return message.payload.oneofKind === "partyPreferences";
 }
-// When a message was last written. Use it to order two copies of one thing held at different ids,
+// When a message was last written. Use it to order two copies of one thing stored at different ids,
 // which have no shared version.
 export function getMessageUpdatedAt(message) {
     return getEntity(message.entity).updatedAt;
@@ -144,11 +145,11 @@ export function getMessageUpdatedAt(message) {
 export function getMessageId(message) {
     return getEntity(message.entity).id;
 }
-// heldETag as for orderToBlob
-export function partyPreferencesToBlob(partyPreferences, heldETag) {
+// storedETag as for orderToBlob
+export function partyPreferencesToBlob(partyPreferences, storedETag) {
     if (partyPreferences.payload.oneofKind !== "partyPreferences")
         throw new InvalidArgumentException("That message carries no party preferences");
-    return messageToBlob(partyPreferences, heldETag);
+    return messageToBlob(partyPreferences, storedETag);
 }
 // Rebuilds the response a business container's blobs make up, as the call returned it. Null when they
 // hold nothing yet. The entity type is part of each blob id and picks the array a blob goes in, so no
@@ -349,25 +350,43 @@ export function cursorsFromBlobs(keys, blobs) {
     return cursors;
 }
 // Raises the cursors to what a page of a business read brought, tombstones included, and returns the
-// keys that moved. Only a read moves them. A push does not.
+// keys that moved. A page is a response to a read, or to a sync in, which carries the messages that
+// are newer than the cursor, as a read does (see raiseMessageCursors).
 export function raiseBusinessCursors(cursors, response) {
     return raiseCursorsFrom(cursors, getBusinessResponseEntities(response));
 }
-// The request that pushes what this customer changed. A storefront may push only messages. One
-// request is one batch, so an order and the cart it emptied go together and a customer is never left
-// with the order and a still full cart. messageUpdateNumber is how far reads of this container have
-// got with messages - see SyncCache.readMessageUpdateNumber.
-export function buildBusinessSyncInRequest(messageUpdateNumber, messages) {
+// The same for the messages of a sync in response, which is a page of the messages of a read.
+export function raiseMessageCursors(cursors, messages) {
+    return raiseCursorsFrom(cursors, getMessageEntities(messages));
+}
+// The request that sends what this customer changed. A storefront may send only messages and,
+// with an order, the customer as a party (see buildParty). One request is one batch, so an order and
+// the cart it emptied go together and a customer is never left with the order and a still full
+// cart. messageUpdateNumber is how far reads of this container have got with messages - see
+// SyncCache.readMessageUpdateNumber.
+export function buildBusinessSyncInRequest(messageUpdateNumber, messages, party = null) {
     return proto_BusinessSyncInRequest.create({
         messageUpdateNumber: messageUpdateNumber,
         messages: [...messages],
+        party: party ?? undefined,
     });
 }
-// The messages a sync in response carried: this push's own, with the update numbers the server
-// assigned. Those numbers are not how far a read has got.
+// The messages a sync in response carried. The server makes a sync out of the customer's messages
+// after it writes, so they are the stored messages that are newer than the cursor of the request,
+// the ones that were sent among them, in the order of their update numbers and not in the order
+// they were sent in. A message is found by its id.
 export function getSyncInResponseMessages(response) {
     return response.messages;
 }
+// Whether a sync in response may have been cut short, and the rest of the messages is read as a
+// read reads on. As for a page of a read (see nextBusinessSyncOutRequest), it is a full page that
+// raised the cursor the request carried. A full page that raised none means the server broke the
+// ascending order it promises, so reading ends there.
+export function isSyncInResponseFull(request, response) {
+    if (response.messages.length < proto_Constants.SYNC_OUT_LIMIT)
+        return false;
+    return response.messages.some((message) => getEntity(message.entity).updateNumber > request.messageUpdateNumber);
+}
 // The request for everything changed in the caller's profile since these cursors. It names no
 // business, since a profile sync is not scoped to one and has no sync in. joinBusinessId is the
 // entity id of a business to make the caller a customer of while the server answers.
@@ -385,10 +404,13 @@ export function buildProfileSyncOutRequest(syncInState, joinBusinessId = BigInt(
 export function raiseProfileCursors(cursors, response) {
     return raiseCursorsFrom(cursors, getProfileResponseEntities(response));
 }
-// The user a sign up sends as CreateUserRequest.user, for the server to create. It has no entity yet
-// (the server assigns id, createdAt and updatedAt), so none of EntityHeader is sent.
-export function buildUser(userProfile) {
+// The user a call of Service.createUser or Service.updateUser sends, under the entity id userId. The
+// rest of EntityHeader is not read by the server, so it is not sent. A sign up sends the id that
+// Model.createUser made, which the server stores the new user under. An update sends the id of the
+// customer's own user, which the server matches to the caller.
+export function buildUser(userProfile, userId) {
     return proto_User.create({
+        entity: proto_Entity.create({ id: userId }),
         firstName: userProfile.firstName,
         lastName: stringToProto(userProfile.lastName),
         mobilePhoneNumber: userProfile.mobilePhoneNumber,
@@ -396,15 +418,25 @@ export function buildUser(userProfile) {
         preferredLanguageCode: stringToProto(userProfile.preferredLanguageCode),
     });
 }
-// The user that Service.updateUser writes over this customer's profile: the fields of buildUser plus
-// the entity id, which the server matches to the caller. The rest of EntityHeader is not read on
-// that call, so it is not sent.
+// The user that Service.updateUser writes over this customer's profile: buildUser under the id of
+// userProfile.
 export function buildUpdateUser(userProfile) {
-    return proto_User.create({
-        ...buildUser(userProfile),
-        entity: proto_Entity.create({ id: userProfile.id }),
+    return buildUser(userProfile, userProfile.id);
+}
+// The request of Service.createUser and Service.updateUser: the user to write, and the profile read
+// from these cursors that the response answers. joinBusinessId is the entity id of a business to
+// join after the user is created, and only a sign up may name one (Constants.ENTITY_ID_NULL, the
+// default, joins nothing).
+export function buildUserRequest(user, syncInState, joinBusinessId = BigInt(proto_Constants.ENTITY_ID_NULL)) {
+    return proto_UserRequest.create({
+        user: user,
+        profileSyncOutRequest: buildProfileSyncOutRequest(syncInState, joinBusinessId),
     });
 }
+// The profile read that a user request holds. Absent means every cursor at zero and no join.
+export function getUserRequestSyncOutRequest(request) {
+    return request.profileSyncOutRequest ?? proto_ProfileSyncOutRequest.create({});
+}
 // The two things a response to a join must hold, checked separately so a caller can report which one
 // is missing - see Model.requireJoinedBusiness. Both take the id, since both requests that carry a
 // joinBusinessId need them.
@@ -529,6 +561,16 @@ export function authTokensToBlob(authTokens) {
 export function authTokensFromBytes(bytes) {
     return authTokensFromProto(proto_AuthTokens.fromBinary(bytes));
 }
+// The id that a sign up will create the user under, as a blob: the id as eight bytes, and a null
+// eTag, since a new id replaces the old one.
+export function userIdToBlob(userId) {
+    const bytes = new Uint8Array(USER_ID_BYTE_COUNT);
+    new DataView(bytes.buffer).setBigUint64(0, userId);
+    return { id: Ids.USER_ID_BLOB_ID, eTag: null, bytes: bytes };
+}
+export function userIdFromBytes(bytes) {
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getBigUint64(0);
+}
 // #endregion
 // #region Paging
 // What the server issued while answering. All three response types carry it in the same field.
@@ -814,18 +856,20 @@ export function buildShoppingList(message, countryCode) {
     return (cartShoppingListFromProto(message.payload.partyPreferences, countryCode) ?? ShoppingList.EMPTY);
 }
 // #endregion
-// #region What a customer pushes
+// #region What a customer sends
 //
 // A storefront writes one entity type, a Message carrying the cart or an order placed from it. Two
-// rules hold for both, so a pushed message is storable here as well as on the server. The client
-// chooses the id: a sync in returns an update number and no id, so a message the server named could
-// not be found here again. The client also sets updatedAt and the server keeps it, so the copy
-// stored here has the same eTag as the one a later read brings back.
-// This customer's party preferences as a message to push, carrying the cart and optionally the
-// fulfillment mode. An existing message is amended, since its payload can carry fields a storefront
-// cannot read, and dropping them would overwrite that data. Its id is kept, as the server holds the
-// preferences under it. The derived id is used only when there is nothing to amend.
-// A list with no items is pushed as no list. The merchant app stores its cart with no items too, and
+// rules hold for both. The client chooses the id: a sync in returns an update number and no id, so
+// a message the server named could not be found here again. The client also sets updatedAt. The
+// server keeps it for a cart, and gives an order the oldest possible one. The copy stored here is
+// the one in the response, so it has the same eTag as the copy a later read brings back.
+// This customer's party preferences as a message to send, carrying the cart and optionally the
+// fulfillment mode. The server stores a cart as a whole, so the existing message is amended: the
+// fulfillment mode is sent back as it is, and a field left out would be removed from the stored cart.
+// The message always has the id given, which a signed-in customer takes from their business link
+// (Ids.getPartyPreferencesMessageId): the server refuses a cart with another id. Only a visitor,
+// who has no link, passes the id of the cart already stored, so that an edit amends it.
+// A list with no items is sent as no list. The merchant app stores its cart with no items too, and
 // both read as no cart (cartShoppingListFromProto), so an emptied cart, a cart with no items and a cart
 // never created are one state to a storefront.
 // fulfillmentMode null keeps the existing value, the ordinary case: a storefront treats that field
@@ -844,19 +888,23 @@ export function buildPartyPreferencesMessage(messageId, existing, senderId, shop
     const updatedAt = existingEntity === null || existingEntity.updatedAt < now ? now : existingEntity.updatedAt + 1n;
     const partyPreferences = proto_PartyPreferencesPayload.create({
         ...preferences,
-        shoppingList: pushedShoppingList(shoppingList, false),
+        shoppingList: shoppingListToSend(shoppingList, false),
     });
     if (fulfillmentMode !== null)
         partyPreferences.fulfillmentMode = fulfillmentMode;
+    // The creation time is that of the message amended. A message under another id is not that one.
+    const isAmended = existingEntity !== null && existingEntity.id === messageId;
     return proto_Message.create({
-        entity: pushedEntity(existingEntity?.id ?? messageId, existingEntity?.createdAt ?? updatedAt, updatedAt),
+        entity: entityToSend(messageId, isAmended ? existingEntity.createdAt : updatedAt, updatedAt),
         senderId: senderId,
         messageType: proto_MessageType.PARTY_PREFERENCES,
         status: proto_TaskStatus.NOT_YET_PROCESSED,
         payload: { oneofKind: "partyPreferences", partyPreferences: partyPreferences },
     });
 }
-// One order as a message to push. Its shopping list is sent as final regardless of the list's
+// One order as a message to send. The server stores it only if no message has its id, with the
+// oldest possible updatedAt, so sending an order again changes nothing. creationDate is the time of
+// the order, in the message as createdAt and in the payload. Its shopping list is sent as final regardless of the list's
 // isFinal, as Java SalesOrderViewModel.saveChanges does before creating an order: the customer has
 // finished choosing, and only a final list records a later edit as a change instead of altering what
 // was ordered. The two totals are all that remains of an order completed by an older merchant app,
@@ -864,7 +912,7 @@ export function buildPartyPreferencesMessage(messageId, existing, senderId, shop
 // counts it carries, which a caller could set to anything.
 export function buildOrderMessage(orderId, senderId, shoppingList, fulfillmentMode, deliveryAddressId, deliveryAddress, note, creationDate) {
     return proto_Message.create({
-        entity: pushedEntity(orderId, creationDate, creationDate),
+        entity: entityToSend(orderId, creationDate, creationDate),
         senderId: senderId,
         messageType: proto_MessageType.SALES_ORDER,
         status: proto_TaskStatus.NOT_YET_PROCESSED,
@@ -873,7 +921,7 @@ export function buildOrderMessage(orderId, senderId, shoppingList, fulfillmentMo
             salesOrder: proto_SalesOrderPayload.create({
                 status: proto_OrderStatus.NOT_STARTED,
                 fulfillmentMode: fulfillmentMode,
-                shoppingList: pushedShoppingList(shoppingList, true),
+                shoppingList: shoppingListToSend(shoppingList, true),
                 shoppingListTotal: amountToScaledValue(shoppingList.totalAmount),
                 shoppingListCount: shoppingList.existingItems.length,
                 deliveryAddressId: deliveryAddressId,
@@ -884,37 +932,55 @@ export function buildOrderMessage(orderId, senderId, shoppingList, fulfillmentMo
         },
     });
 }
+// The customer as the party that an order is sent with, which the business needs to show the order
+// and to record payments against it. The party carries no id: the server applies it to the party of
+// the link. The name is the customer's formatted name, as Java User.getFormattedName makes it. It is
+// at most 65 characters, and the server shortens it to a party's 32. The phone number is the
+// customer's own, which the server requires to be the one that the authentication token verified.
+// deliveryAddress is the address of an order that is delivered, or null for an order that is not, as
+// the merchant app adds one to the party only for a delivery. It keeps its id, which is its id in
+// the customer's list of addresses.
+export function buildParty(user, deliveryAddress) {
+    return proto_Party.create({
+        name: user.formattedName,
+        mobilePhoneNumber: user.mobilePhoneNumber,
+        addresses: deliveryAddress === null ? [] : [addressToProto(deliveryAddress)],
+    });
+}
 // The messages of a sync in response as a cache write, tombstones included like any other entity
-// array. This stores a push's own messages under the update numbers the server assigned, with no
-// separate stamping step, since the response carries full entities.
+// array. They are stored under the update numbers the server stored them under, with no separate
+// stamping step, since the response carries full entities.
 export function messagesToCacheWrite(messages) {
-    return toCacheWrite(messages.map((message) => toWireEntity(message.entity, proto_Message.toBinary(message))));
+    return toCacheWrite(getMessageEntities(messages));
+}
+function getMessageEntities(messages) {
+    return messages.map((message) => toWireEntity(message.entity, proto_Message.toBinary(message)));
 }
-// The Entity of something this client is pushing. The update number goes out as zero, since the
-// server replaces a caller's own with the one it assigns. A message not pushed yet is stored holding
+// The Entity of something this client is sending. The update number goes out as zero, since the
+// server replaces a caller's own with the one it assigns. A message not sent yet is stored with
 // zero, and messageToBlob versions it from the copy it amends. updateInfo is zero too: it would be
 // the id of the store that made the change, and the server knows no store of this client. This
 // client does not need it: a read sends these messages back (the server leaves no one's changes out
 // of a storefront's read), and the eTag stored here is the one the server kept, so storing what the
 // read brings back changes nothing.
-function pushedEntity(id, createdAt, updatedAt) {
+function entityToSend(id, createdAt, updatedAt) {
     return proto_Entity.create({ id: id, createdAt: createdAt, updatedAt: updatedAt });
 }
-// Whether shoppingList differs from what stored holds, so updateCart can skip a push. Compares raw
-// lists, since a message's updatedAt differs on every call. That works because the server echoes a
-// pushed list back with the items it was sent, so stored is what was last sent.
-// The server echoes the items in package id order, and the list's own order is kept in each item's
-// shoppingListOrder, which is compared with the item. So both lists are put in package id order
-// first. Otherwise a cart not picked in that order would differ from its echo and be pushed again,
-// which re-stamps updatedAt for every other device.
-// Also true when stored was never pushed (updateNumber 0, left by updateCartLocalOnly), so an
-// unsent local edit is still pushed.
+// Whether shoppingList differs from what stored contains, so updateCart can skip a request. Compares
+// raw lists, since a message's updatedAt differs on every call. That works because the server answers
+// with the list it was sent, with its items, so stored is what was last sent.
+// The server answers with the items in package id order, and the list's own order is kept in each
+// item's shoppingListOrder, which is compared with the item. So both lists are put in package id
+// order first. Otherwise a cart not picked in that order would differ from the answer and be sent
+// again, which re-stamps updatedAt for every other device.
+// Also true when stored was never sent (updateNumber 0, left by updateCartLocalOnly), so an
+// unsent local edit is still sent.
 export function hasShoppingListChanged(stored, shoppingList) {
     if (stored === null)
-        return pushedShoppingList(shoppingList, false) !== undefined;
+        return shoppingListToSend(shoppingList, false) !== undefined;
     if (getEntity(stored.entity).updateNumber === 0n)
         return true;
-    return !proto_ShoppingList.equals(inPackageIdOrder(getCartShoppingList(stored)), inPackageIdOrder(pushedShoppingList(shoppingList, false)));
+    return !proto_ShoppingList.equals(inPackageIdOrder(getCartShoppingList(stored)), inPackageIdOrder(shoppingListToSend(shoppingList, false)));
 }
 // The same list with its items sorted by package id, the order the server sends them in
 function inPackageIdOrder(list) {
@@ -936,13 +1002,13 @@ function getCartShoppingList(message) {
     return shoppingList === undefined || holdsNothing(shoppingList) ? undefined : shoppingList;
 }
 // Whether a list on the wire has no items. The items are what is judged, not the counts, as in
-// pushedShoppingList
+// shoppingListToSend
 function holdsNothing(shoppingList) {
     return shoppingList.existingItems.length === 0 && shoppingList.deletedItems.length === 0;
 }
-// A shopping list to push, or absent when it holds nothing - see buildPartyPreferencesMessage.
+// A shopping list to send, or absent when it holds nothing - see buildPartyPreferencesMessage.
 // Emptiness is judged by the items sent, not the counts, for the reason given at shoppingListToProto.
-function pushedShoppingList(shoppingList, isFinal) {
+function shoppingListToSend(shoppingList, isFinal) {
     if (shoppingList === null)
         return undefined;
     if (shoppingList.existingItems.length === 0 && shoppingList.deletedItems.length === 0)
@@ -950,8 +1016,8 @@ function pushedShoppingList(shoppingList, isFinal) {
     return shoppingListToProto(shoppingList, isFinal);
 }
 // The counts are the lengths of the item arrays, not the list's own counts. A read takes them from
-// the wire because the protocol sends a count even where it omits the items, but a push always sends
-// the items. Counting the arrays means a pushed list cannot disagree with its contents.
+// the wire because the protocol sends a count even where it omits the items, but a list that is sent
+// always has its items. Counting the arrays means a list cannot disagree with its contents.
 function shoppingListToProto(shoppingList, isFinal) {
     return proto_ShoppingList.create({
         isFinal: isFinal,
@@ -1019,18 +1085,18 @@ export function entityETag(updateNumber, updatedAt) {
     return (updateNumber << UPDATED_AT_BITS) | updatedAt;
 }
 // A message this client wrote has no update number until a server assigns one, and has none in the
-// store while unpushed (see pushedEntity). It is versioned at the update number of the copy it
-// amends, which heldETag carries, so its updatedAt makes it the later copy of that version. If the
+// store while unsent (see entityToSend). It is versioned at the update number of the copy it
+// amends, which storedETag carries, so its updatedAt makes it the later copy of that version. If the
 // server sends the amended copy again, that copy does not replace it, but a later server version
 // with a greater update number does. A message that amends nothing is at zero. A message that has an
 // update number is versioned by it, as any entity is.
-function messageToBlob(message, heldETag) {
+function messageToBlob(message, storedETag) {
     const entity = getEntity(message.entity);
     const updateNumber = entity.updateNumber !== 0n
         ? entity.updateNumber
-        : heldETag === null
+        : storedETag === null
             ? 0n
-            : heldETag >> UPDATED_AT_BITS;
+            : storedETag >> UPDATED_AT_BITS;
     return {
         id: entity.id,
         eTag: entityETag(updateNumber, entity.updatedAt),
@@ -1119,8 +1185,8 @@ function addressFromProto(address) {
     return new Address(address.id, address.addressType, stringFromProto(address.unitNumber), stringFromProto(address.community), stringFromProto(address.line2), stringFromProto(address.city), stringFromProto(address.state), stringFromProto(address.pinCode), address.countryCode);
 }
 // The reverse of addressFromProto, for a delivery address sent directly instead of by id - see
-// buildOrderMessage. id is copied from Address, though it means nothing outside the list the address
-// was read from, and this address is in none.
+// buildOrderMessage - and for the address of a party - see buildParty. id is copied from Address, as
+// it is the id of the address in the customer's list.
 function addressToProto(address) {
     return proto_Address.create({
         id: address.id,
@@ -1252,7 +1318,7 @@ function productFromProto(productProto, photos, countryCode) {
 }
 function orderFromProto(message, salesOrder, countryCode) {
     const entity = getEntity(message.entity);
-    return Order.fromScaledValues(toEntityHeader(entity), message.senderId, message.status, stringFromProto(message.senderName), stringFromProto(message.senderPhone), salesOrder.status, salesOrder.fulfillmentMode, shoppingListFromProto(salesOrder.shoppingList, countryCode), salesOrder.shoppingListTotal, salesOrder.shoppingListCount, salesOrder.deliveryAddressId, salesOrder.deliveryAddress === undefined ? null : addressFromProto(salesOrder.deliveryAddress), salesOrder.creationDate, stringFromProto(salesOrder.note), salesOrder.paymentReceived);
+    return Order.fromScaledValues(toEntityHeader(entity), message.senderId, message.status, salesOrder.status, salesOrder.fulfillmentMode, shoppingListFromProto(salesOrder.shoppingList, countryCode), salesOrder.shoppingListTotal, salesOrder.shoppingListCount, salesOrder.deliveryAddressId, salesOrder.deliveryAddress === undefined ? null : addressFromProto(salesOrder.deliveryAddress), salesOrder.creationDate, stringFromProto(salesOrder.note), salesOrder.paymentReceived);
 }
 // The one part of a cart message a customer is shown. Null when the cart holds nothing, so a cart
 // emptied by placing an order, one never created, and a list with no items (the merchant app stores
@@ -1281,4 +1347,6 @@ function takePhotos(attachmentsByOwner, owningEntityId, attachmentBaseUrl) {
 const UPDATED_AT_BITS = 64n;
 // The bytes of a blob that exists only for its eTag
 const NO_BYTES = new Uint8Array(0);
+// The width of a user id in its blob: an id is 64 bits
+const USER_ID_BYTE_COUNT = 8;
 const NO_PHOTOS = Object.freeze([]);

package/dist/Service.d.ts

@@ -3,14 +3,13 @@ import { BusinessSyncInRequest as proto_BusinessSyncInRequest } from "./generate
 import { BusinessSyncInResponse as proto_BusinessSyncInResponse } from "./generated/BusinessSyncInResponse";
 import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./generated/BusinessSyncOutRequest";
 import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
-import { CreateUserRequest as proto_CreateUserRequest } from "./generated/CreateUserRequest";
 import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
 import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
-import { User as proto_User } from "./generated/User";
+import { UserRequest as proto_UserRequest } from "./generated/UserRequest";
 export default interface Service {
     businessSyncOut(request: proto_BusinessSyncOutRequest, authTokens: proto_AuthTokens | null): Promise<proto_BusinessSyncOutResponse>;
     businessSyncIn(request: proto_BusinessSyncInRequest, authTokens: proto_AuthTokens): Promise<proto_BusinessSyncInResponse>;
     profileSyncOut(request: proto_ProfileSyncOutRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
-    createUser(request: proto_CreateUserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
-    updateUser(user: proto_User, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    createUser(request: proto_UserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    updateUser(request: proto_UserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
 }

package/dist/ServiceProxy.d.ts

@@ -3,10 +3,9 @@ import { BusinessSyncInRequest as proto_BusinessSyncInRequest } from "./generate
 import { BusinessSyncInResponse as proto_BusinessSyncInResponse } from "./generated/BusinessSyncInResponse";
 import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./generated/BusinessSyncOutRequest";
 import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
-import { CreateUserRequest as proto_CreateUserRequest } from "./generated/CreateUserRequest";
 import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
 import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
-import { User as proto_User } from "./generated/User";
+import { UserRequest as proto_UserRequest } from "./generated/UserRequest";
 import Service from "./Service";
 export type FetchFunction = (url: string, init: RequestInit) => Promise<Response>;
 export default class ServiceProxy implements Service {
@@ -14,8 +13,8 @@ export default class ServiceProxy implements Service {
     businessSyncOut(request: proto_BusinessSyncOutRequest, authTokens: proto_AuthTokens | null): Promise<proto_BusinessSyncOutResponse>;
     businessSyncIn(request: proto_BusinessSyncInRequest, authTokens: proto_AuthTokens): Promise<proto_BusinessSyncInResponse>;
     profileSyncOut(request: proto_ProfileSyncOutRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
-    createUser(request: proto_CreateUserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
-    updateUser(user: proto_User, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    createUser(request: proto_UserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
+    updateUser(request: proto_UserRequest, authTokens: proto_AuthTokens): Promise<proto_ProfileSyncOutResponse>;
     private post;
     private send;
     private getFetchFunction;

package/dist/ServiceProxy.js

@@ -2,10 +2,9 @@ import { BusinessSyncInRequest as proto_BusinessSyncInRequest } from "./generate
 import { BusinessSyncInResponse as proto_BusinessSyncInResponse } from "./generated/BusinessSyncInResponse";
 import { BusinessSyncOutRequest as proto_BusinessSyncOutRequest } from "./generated/BusinessSyncOutRequest";
 import { BusinessSyncOutResponse as proto_BusinessSyncOutResponse } from "./generated/BusinessSyncOutResponse";
-import { CreateUserRequest as proto_CreateUserRequest } from "./generated/CreateUserRequest";
 import { ProfileSyncOutRequest as proto_ProfileSyncOutRequest } from "./generated/ProfileSyncOutRequest";
 import { ProfileSyncOutResponse as proto_ProfileSyncOutResponse } from "./generated/ProfileSyncOutResponse";
-import { User as proto_User } from "./generated/User";
+import { UserRequest as proto_UserRequest } from "./generated/UserRequest";
 import { IllegalOperationException } from "./Exceptions";
 import { isError, throwOnError } from "./HttpStatusCodes";
 import { buildAuthTokensBytes } from "./ProtoMap";
@@ -33,11 +32,10 @@ export default class ServiceProxy {
         return this.post(Routes.PROFILE_SYNC_OUT, proto_ProfileSyncOutRequest, request, proto_ProfileSyncOutResponse, authTokens);
     }
     async createUser(request, authTokens) {
-        return this.post(Routes.CREATE_USER, proto_CreateUserRequest, request, proto_ProfileSyncOutResponse, authTokens);
+        return this.post(Routes.CREATE_USER, proto_UserRequest, request, proto_ProfileSyncOutResponse, authTokens);
     }
-    // The User is the whole request, since there is no wrapper message for it
-    async updateUser(user, authTokens) {
-        return this.post(Routes.UPDATE_USER, proto_User, user, proto_ProfileSyncOutResponse, authTokens);
+    async updateUser(request, authTokens) {
+        return this.post(Routes.UPDATE_USER, proto_UserRequest, request, proto_ProfileSyncOutResponse, authTokens);
     }
     // One call: encode, send, throw the matching exception on an error status, decode. The message
     // types are passed in so every route is sent and read the same way.

package/dist/SyncCache.d.ts

@@ -16,9 +16,11 @@ export default class SyncCache {
     readDeletedProfile(containerName: string): Promise<proto_ProfileSyncOutResponse | null>;
     readProfileCursors(containerName: string): Promise<SyncState>;
     writeProfile(containerName: string, response: proto_ProfileSyncOutResponse): Promise<number>;
-    storeProfile(containerName: string, response: proto_ProfileSyncOutResponse): Promise<number>;
     readAuthTokens(containerName: string): Promise<AuthTokens | null>;
     writeAuthTokens(containerName: string, authTokens: AuthTokens): Promise<void>;
+    readUserId(containerName: string): Promise<bigint | null>;
+    writeUserId(containerName: string, userId: bigint): Promise<void>;
+    deleteUserId(containerName: string): Promise<void>;
     readOrders(containerName: string): Promise<ReadonlyArray<proto_Message>>;
     readDeletedOrders(containerName: string): Promise<ReadonlyArray<proto_Message>>;
     readMessageUpdateNumber(containerName: string): Promise<bigint>;