@peabody-soft/mbs-model-ts 1.11.0 → 1.13.0

package/dist/SyncCache.js

@@ -1,9 +1,12 @@
 import { Constants as proto_Constants } from "./generated/Constants";
+import { StoreCorruptException } from "./Exceptions";
 import Ids from "./Ids";
 import * as ProtoMap from "./ProtoMap";
 import * as SyncKeys from "./SyncKeys";
 // What the server has already sent, so the next call can ask only for what changed. A read cache:
-// everything in it came from a response, so dropping a container costs one refetch.
+// everything in it came from a response, so dropping a container costs one refetch. The exception is
+// the id of a sign up that is under way (readUserId), which the client makes and deletes once the
+// server has answered.
 // It does not write through or sync. The caller calls the Service, does the paging, and chooses
 // which writes are reads. It holds only wire data, which ProtoMap reads. See SYNC LAYER in
 // ../Prompt.txt.
@@ -14,7 +17,8 @@ import * as SyncKeys from "./SyncKeys";
 //   readOrders and readPartyPreferences leave them out.
 // - A cursor is a blob per entity type (its eTag is the cursor). It is not derived from the
 //   entities, because tombstones and this client's own changes would move it. It rises only with
-//   a page of a read, in that page's batch, and the store keeps the greater.
+//   a page of a read, in that page's batch, and the store keeps the greater. Only
+//   resetProfileCursors lowers one.
 export default class SyncCache {
     constructor(_database) {
         this._database = _database;
@@ -24,11 +28,11 @@ export default class SyncCache {
     // written. Tombstones are included as sent: a deleted entity carries what it was, or only its header
     // for an item. Code that builds on this must leave tombstones out, except for the order of a message.
     async readBusiness(containerName) {
-        return ProtoMap.businessResponseFromBlobs(await this.readAll(containerName));
+        return this.readDecoded(containerName, ProtoMap.businessResponseFromBlobs);
     }
     // The cursors the next read sends: the highest update number of each entity type that a page of a
-    // read brought, tombstones included, or zero for a type none has brought. Only a read moves them, so
-    // the next read brings back what this client pushed.
+    // read brought, tombstones included, or zero for a type none has brought. A page is a response to a
+    // read, or the messages of a response to a sync in.
     async readBusinessCursors(containerName) {
         return this.readCursors(containerName, SyncKeys.BUSINESS_SYNC_IN);
     }
@@ -51,36 +55,40 @@ export default class SyncCache {
     // The tombstones cached for one business, as a response, each as stored and as the server sent it.
     // Null when there are none. The entities a deleted entity owned are tombstones too.
     async readDeletedBusiness(containerName) {
-        return ProtoMap.deletedBusinessResponseFromBlobs(await this.readAll(containerName));
+        return this.readDecoded(containerName, ProtoMap.deletedBusinessResponseFromBlobs);
     }
     // The same for one profile: the customer, the businesses they may reach, and the link to each.
     async readProfile(containerName) {
-        return ProtoMap.profileResponseFromBlobs(await this.readAll(containerName));
+        return this.readDecoded(containerName, ProtoMap.profileResponseFromBlobs);
     }
     // The tombstones of a profile, as readDeletedBusiness returns those of a business.
     async readDeletedProfile(containerName) {
-        return ProtoMap.deletedProfileResponseFromBlobs(await this.readAll(containerName));
+        return this.readDecoded(containerName, ProtoMap.deletedProfileResponseFromBlobs);
     }
     async readProfileCursors(containerName) {
         return this.readCursors(containerName, SyncKeys.PROFILE_SYNC_IN);
     }
-    // One page of a profile read - see writeBusiness
+    // Deletes the profile cursors, so the next read asks for the whole profile. Use it when the
+    // container lacks an entity that its cursors are past, which no read would send again. The
+    // entities, tokens and saved user id stay, and a repeated entity changes nothing.
+    async resetProfileCursors(containerName) {
+        await this.write(containerName, {
+            blobs: NO_BLOBS,
+            deletedIds: SyncKeys.PROFILE_SYNC_IN.map((key) => Ids.getSyncCursorBlobId(key)),
+        });
+    }
+    // One page of a profile read, or the answer to a sign up or an update, which is the first page of
+    // one. See writeBusiness.
     async writeProfile(containerName, response) {
         return this.writeRead(containerName, ProtoMap.profileResponseToCacheWrite(response), SyncKeys.PROFILE_SYNC_IN, (cursors) => ProtoMap.raiseProfileCursors(cursors, response));
     }
-    // Stores the response to a call that is not a read (a sign up, an update). It holds a change this
-    // client made, so it moves no cursor and the next read brings it back. Otherwise the same as
-    // writeProfile.
-    async storeProfile(containerName, response) {
-        return this.write(containerName, ProtoMap.profileResponseToCacheWrite(response));
-    }
     // The credentials that sign calls about this container (the user token in a profile container, the
     // link token in a business one), or null before the server issues either.
     async readAuthTokens(containerName) {
         const blob = await (await this.getContainer(containerName)).read(Ids.AUTH_TOKENS_BLOB_ID);
         if (blob === null)
             return null;
-        return ProtoMap.authTokensFromBytes(blob.bytes);
+        return this.decode(containerName, () => ProtoMap.authTokensFromBytes(blob.bytes));
     }
     // Written without comparison, unlike everything else here: a reissued token is not a later version of
     // the old one, so the last one written wins. Stores only what this server issued - see
@@ -88,23 +96,40 @@ export default class SyncCache {
     async writeAuthTokens(containerName, authTokens) {
         await this.writeBlobs(containerName, [ProtoMap.authTokensToBlob(authTokens)]);
     }
+    // The id that a sign up in this profile container creates the user under, or null when none is
+    // saved. See Model.createUser. It is not an entity, so no read of a profile returns it.
+    async readUserId(containerName) {
+        const blob = await (await this.getContainer(containerName)).read(Ids.USER_ID_BLOB_ID);
+        if (blob === null)
+            return null;
+        return this.decode(containerName, () => ProtoMap.userIdFromBytes(blob.bytes));
+    }
+    // Saves the id before the sign up is sent, and it stays until deleteUserId deletes it. It replaces
+    // an id saved before.
+    async writeUserId(containerName, userId) {
+        await this.writeBlobs(containerName, [ProtoMap.userIdToBlob(userId)]);
+    }
+    // Deletes the saved id, if there is one, once the sign up is over.
+    async deleteUserId(containerName) {
+        await this.write(containerName, { blobs: NO_BLOBS, deletedIds: [Ids.USER_ID_BLOB_ID] });
+    }
     // The open orders of the caller whose responses were written here, because a server sends a caller
     // only their own messages. An open order is one the business has not completed. Completed orders
     // are deleted messages, which readDeletedOrders returns. Nothing here records which caller that was
     // or detects a change of caller. See THE MESSAGES OF A BUSINESS ARE NOT PUBLIC.
     async readOrders(containerName) {
-        return ProtoMap.orderMessagesFromBlobs(await this.readAll(containerName));
+        return this.readDecoded(containerName, ProtoMap.orderMessagesFromBlobs);
     }
     // The orders the business has completed, by fulfilling or cancelling. The merchant app completes an
     // order by deleting its message, so each is a tombstone. A server sends these whole, because the
     // customer is shown the order afterwards. Each is returned as stored and as sent. A tombstone with
     // no order in it is not included.
     async readDeletedOrders(containerName) {
-        return ProtoMap.deletedOrderMessagesFromBlobs(await this.readAll(containerName));
+        return this.readDecoded(containerName, ProtoMap.deletedOrderMessagesFromBlobs);
     }
-    // The cursor a push sends: how far reads of this container have got with this customer's messages,
-    // party preferences and orders alike. It is the cursor the next read sends. What a push stores here
-    // does not move it, so a change made during the push is not skipped.
+    // The cursor a sync in sends: how far reads of this container have got with this customer's
+    // messages, party preferences and orders alike. It is the cursor the next read sends. The answer
+    // to a sync in is a sync out from it, so what that stores moves it, as a read does.
     async readMessageUpdateNumber(containerName) {
         return (await this.readBusinessCursors(containerName)).getUpdateNumber(proto_Constants.MESSAGE_ENTITY_TYPE_ID);
     }
@@ -117,7 +142,7 @@ export default class SyncCache {
     // per business, so two would mean two callers share the container, the open question described
     // for readOrders.
     async readPartyPreferences(containerName) {
-        return ProtoMap.partyPreferencesMessageFromBlobs(await this.readAll(containerName));
+        return this.readDecoded(containerName, ProtoMap.partyPreferencesMessageFromBlobs);
     }
     async writePartyPreferences(containerName, partyPreferences) {
         return this.writeOwnMessage(containerName, partyPreferences, ProtoMap.partyPreferencesToBlob);
@@ -133,12 +158,12 @@ export default class SyncCache {
         this._containers.delete(containerName);
         await this._database.deleteContainer(containerName);
     }
-    // Deletes the party preferences message this container holds, and returns zero when there is none.
-    // It is the only delete that no tombstone caused. A cart written before anybody signed in is handed
-    // over to the container named for the membership. The copy left behind would be read by the next
-    // anonymous visitor and the next customer to sign in - see Model.businessSyncIn. A caller deletes
-    // nothing else from a container: it all came off the wire, and anything the server has not
-    // reported as deleted stays.
+    // Deletes the party preferences message this container stores, and returns zero when there is none.
+    // It is the only delete of an entity that no tombstone caused. A cart written before anybody signed
+    // in is handed over to the container named for the membership. The copy left behind would be read
+    // by the next anonymous visitor and the next customer to sign in - see Model.businessSyncIn. A
+    // caller deletes no other entity from a container: it all came off the wire, and anything the
+    // server has not reported as deleted stays.
     async deletePartyPreferences(containerName) {
         const partyPreferences = await this.readPartyPreferences(containerName);
         if (partyPreferences === null)
@@ -148,25 +173,39 @@ export default class SyncCache {
             deletedIds: [ProtoMap.getMessageId(partyPreferences)],
         });
     }
-    // Stores the messages a sync in response carried, in one batch, so the cache cannot hold a pushed
-    // order without the party preferences message it emptied. Tombstones are included, as for any
-    // entity array off the wire. This stores a push's own messages once the server has echoed them with
-    // real update numbers. It checks no payload type, unlike writeOrder and writePartyPreferences.
-    // Those take a message from the caller, where storing an order as party preferences is a mistake
-    // worth catching. Here the response is taken as correct. It moves no cursor, because this client
-    // made the change and the next read brings the same messages back.
+    // Stores the messages a sync in response carried, in one batch with the message cursor that they
+    // raise, as writeBusiness stores a page of a read: the response is a sync out of the customer's
+    // messages, made after the write. So the cache cannot store an order without the party
+    // preferences message it emptied, and a cursor cannot get ahead of the messages it describes.
+    // Tombstones are included, as for any entity array off the wire. It checks no payload type, unlike
+    // writeOrder and writePartyPreferences. Those take a message from the caller, where storing an
+    // order as party preferences is a mistake worth catching. Here the response is taken as correct.
+    // Returns how many messages it changed, as writeBusiness does.
     async writeMessages(containerName, messages) {
-        return this.write(containerName, ProtoMap.messagesToCacheWrite(messages));
+        return this.writeRead(containerName, ProtoMap.messagesToCacheWrite(messages), SyncKeys.BUSINESS_SYNC_IN, (cursors) => ProtoMap.raiseMessageCursors(cursors, messages));
+    }
+    // Reads every blob of the container and decodes them with decoder. Throws StoreCorruptException
+    // if decoder throws.
+    async readDecoded(containerName, decoder) {
+        const blobs = await (await this.getContainer(containerName)).readAll();
+        return this.decode(containerName, () => decoder(blobs));
     }
-    async readAll(containerName) {
-        return (await this.getContainer(containerName)).readAll();
+    // Anything thrown while reading what the store holds means the store holds something unreadable,
+    // since the same bytes decoded when they were written.
+    decode(containerName, decoder) {
+        try {
+            return decoder();
+        }
+        catch (error) {
+            throw new StoreCorruptException(containerName, error);
+        }
     }
-    // Stores a message the caller holds, not one a response carried, versioned from the copy this
-    // container holds. A message this client amended has no update number, so it is stored at that of
+    // Stores a message the caller built, not one a response carried, versioned from the copy this
+    // container stores. A message this client amended has no update number, so it is stored at that of
     // the copy it amends - see ProtoMap.messageToBlob
     async writeOwnMessage(containerName, message, toBlob) {
-        const held = await (await this.getContainer(containerName)).read(ProtoMap.getMessageId(message));
-        return this.writeBlobs(containerName, [toBlob(message, held?.eTag ?? null)]);
+        const stored = await (await this.getContainer(containerName)).read(ProtoMap.getMessageId(message));
+        return this.writeBlobs(containerName, [toBlob(message, stored?.eTag ?? null)]);
     }
     // For writers that store one blob and delete nothing (a credential or a single message), because no
     // tombstone comes with either
@@ -176,8 +215,8 @@ export default class SyncCache {
     // One transaction per call, so an interrupted write can be repeated and never leaves the cache
     // partly written. The store's count covers only what it stored: a blob that the store already holds
     // a copy of that is as new (a tombstone too) is not stored and not counted. A delete has nothing
-    // to compare, so the ids are counted instead. The only delete is a caller's own - see
-    // deletePartyPreferences.
+    // to compare, so the ids are counted instead. A delete is a caller's own: see
+    // deletePartyPreferences, deleteUserId and resetProfileCursors.
     async write(containerName, cacheWrite) {
         const blobs = cacheWrite.blobs;
         const deletedIds = cacheWrite.deletedIds;

package/dist/SyncKeys.js

@@ -19,8 +19,9 @@ export const PROFILE_SYNC_IN = Object.freeze([
     proto_Constants.BUSINESS_ENTITY_TYPE_ID,
     proto_Constants.BUSINESS_LINK_ENTITY_TYPE_ID,
 ]);
-// Update numbers a business sync out records (as a BusinessSyncInResponse returns them). Message
-// is the only entity type a storefront may push, so this is a set of one.
+// The cursor of a business sync in: BusinessSyncInRequest.messageUpdateNumber, which is how far
+// reads have got with the customer's messages. The response carries the messages that are newer than
+// it. Message is the only entity type a storefront may send, so this is a set of one.
 export const BUSINESS_SYNC_OUT = Object.freeze([
     proto_Constants.MESSAGE_ENTITY_TYPE_ID,
 ]);

package/dist/generated/BusinessSyncInRequest.d.ts

@@ -4,38 +4,52 @@ import type { BinaryReadOptions } from "@protobuf-ts/runtime";
 import type { IBinaryReader } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
+import { Party } from "./Party";
 import { Message } from "./Message";
 /**
- * Pushes the business entities a customer has changed - their shopping cart and the orders placed
- * from it - to one business database. The request names no business: the link token in the
- * AuthTokens of the authorization header does, as a link names exactly one.
- * Not implemented yet: the route (shopBusinessSyncIn) answers 501, and what is said here and in the
- * BusinessSyncInResponse is the contract that it is to meet, and not behaviour that the server has.
- * ProtoMap.fromProto accepts the paymentReceived of an order, and the senderId and status of a message,
- * as they are sent, so, sync in has to enforce who may set each of them when it is written.
- * An entity being synced in carries the id it already has, or Constants.ENTITY_ID_NULL if the
- * caller is creating it and the server is to assign one; incoming update numbers are the caller's
- * own and are replaced by the server, which returns the messages bearing the new ones in the
- * BusinessSyncInResponse.
+ * Stores the shopping cart and the orders of a customer in one business. The request names no business: the link token in the
+ * AuthTokens of the authorization header does, and it must be a customer's (401 otherwise). The business is not checked to be open.
+ * The server checks every message before it stores any, so one failure fails the request:
+ * - distinct ids, each message an order or a cart with its payload (400)
+ * - a cart has the id of the cart of the business link in the link token: the id of the link with the entity type of a message (see
+ *   Message.getPartyPreferencesMessageId in the merchant app). An order does not have that id (400)
+ * - senderId is the party of the link (401), and status is NOT_YET_PROCESSED (400)
+ * - an order has OrderStatus NOT_STARTED and no paymentReceived, which only an operator sets (400)
+ * - createdAt and updatedAt are set, and not later than the clock skew allows (400)
+ * The server replaces the update number and updateInfo, and marks every order as placed by a customer. An order with id
+ * Constants.ENTITY_ID_NULL gets an id from the server.
+ * A cart is stored as a whole: it replaces the stored cart if its updatedAt is later, and is ignored if it is not. The server reads the
+ * party before the write (see party), and the messages of the customer after it (see BusinessSyncInResponse).
+ * An order is stored only if no message has its id: the server gives it the oldest possible updatedAt, so a later copy never replaces
+ * it. A retry changes nothing, and a customer cannot change an order that the business has started or completed. The createdAt of
+ * the order is the one that was sent.
+ * A request with no messages and no party changes nothing and is answered with no messages: it is not a way to read.
  *
  * @generated from protobuf message com.merabills.storefront.BusinessSyncInRequest
  */
 export interface BusinessSyncInRequest {
     /**
-     * Client-side cursor for the customer's orders and shopping cart (Constants.MESSAGE_ENTITY_TYPE_ID):
-     * how far the client's sync outs of them have got, which is not moved by a push. The answer to a push
-     * is only the messages that were pushed, so, it does not depend on this.
+     * Client-side cursor for the customer's orders and shopping cart (Constants.MESSAGE_ENTITY_TYPE_ID): how far the client's sync
+     * outs of them have got, as in BusinessSyncOutRequest. The response carries the messages that are newer than it.
      *
      * @generated from protobuf field: int64 messageUpdateNumber = 1
      */
     messageUpdateNumber: bigint;
     /**
-     * The shopping cart (a PartyPreferencesPayload) and orders (a SalesOrderPayload) of the customer -
-     * entity type Constants.MESSAGE_ENTITY_TYPE_ID, the only entity type a customer may push.
+     * The shopping cart (a PartyPreferencesPayload) and orders (a SalesOrderPayload) of the customer - entity type
+     * Constants.MESSAGE_ENTITY_TYPE_ID, the only entity type a customer may send.
      *
      * @generated from protobuf field: repeated com.merabills.storefront.Message messages = 2
      */
     messages: Message[];
+    /**
+     * The customer, with an order. A client sends it with every order: the business needs the party to show the order and to record
+     * payments against it. The server stores it with the messages, in one transaction. It is a 400 without an order in the request, and a
+     * 401 if its phone number is not the one the authentication token verified.
+     *
+     * @generated from protobuf field: com.merabills.storefront.Party party = 3
+     */
+    party?: Party;
 }
 declare class BusinessSyncInRequest$Type extends MessageType<BusinessSyncInRequest> {
     constructor();

package/dist/generated/BusinessSyncInRequest.js

@@ -2,13 +2,15 @@ import { WireType } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
+import { Party } from "./Party";
 import { Message } from "./Message";
 // @generated message type with reflection information, may provide speed optimized methods
 class BusinessSyncInRequest$Type extends MessageType {
     constructor() {
         super("com.merabills.storefront.BusinessSyncInRequest", [
             { no: 1, name: "messageUpdateNumber", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
-            { no: 2, name: "messages", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Message }
+            { no: 2, name: "messages", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Message },
+            { no: 3, name: "party", kind: "message", T: () => Party }
         ]);
     }
     create(value) {
@@ -30,6 +32,9 @@ class BusinessSyncInRequest$Type extends MessageType {
                 case /* repeated com.merabills.storefront.Message messages */ 2:
                     message.messages.push(Message.internalBinaryRead(reader, reader.uint32(), options));
                     break;
+                case /* com.merabills.storefront.Party party */ 3:
+                    message.party = Party.internalBinaryRead(reader, reader.uint32(), options, message.party);
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -48,6 +53,9 @@ class BusinessSyncInRequest$Type extends MessageType {
         /* repeated com.merabills.storefront.Message messages = 2; */
         for (let i = 0; i < message.messages.length; i++)
             Message.internalBinaryWrite(message.messages[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* com.merabills.storefront.Party party = 3; */
+        if (message.party)
+            Party.internalBinaryWrite(message.party, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/dist/generated/BusinessSyncInResponse.d.ts

@@ -7,11 +7,14 @@ import { MessageType } from "@protobuf-ts/runtime";
 import { Message } from "./Message";
 import { AuthTokens } from "./AuthTokens";
 /**
- * Not implemented yet (the route answers 501): this is the contract that it is to meet.
- * The answer to a BusinessSyncInRequest: the messages the server now holds for what was pushed,
- * which bear the update numbers it assigned, and any tokens it renewed. A push is not a read, so, do
- * not move the message cursor with these update numbers: a change somebody else made, with an update
- * number below them, would then never be sent. The next sync out returns what was pushed as well.
+ * The answer to a BusinessSyncInRequest: a sync out of the messages of the customer, made after the write, and any tokens the server
+ * renewed. It carries the messages that are newer than BusinessSyncInRequest.messageUpdateNumber, in the order of their update
+ * numbers, deleted ones included, and at most as many as a sync out sends: a client that gets that many reads on with a sync out. A
+ * client moves its message cursor with them as it does with a sync out.
+ * They are the stored messages, so an update number in the response is always one that a message is stored under. They include the
+ * incoming messages that were stored. One that was not stored (an order whose id exists, or a cart that is not later than the stored
+ * one) is in the response only if the stored message is newer than the cursor, and is then the stored message. The messages are not in
+ * the order of the request: a client finds its own by id.
  *
  * @generated from protobuf message com.merabills.storefront.BusinessSyncInResponse
  */
@@ -24,7 +27,7 @@ export interface BusinessSyncInResponse {
      */
     authTokens?: AuthTokens;
     /**
-     * The orders of the customer, and their shopping cart
+     * The messages of the customer that are newer than the cursor of the request: the orders and the shopping cart
      *
      * @generated from protobuf field: repeated com.merabills.storefront.Message messages = 2
      */

package/dist/generated/Constants.d.ts

@@ -134,12 +134,6 @@ export declare enum Constants {
      * @generated from protobuf enum value: ATTACHMENT_FILE_HASH_SIZE_BYTES = 16;
      */
     ATTACHMENT_FILE_NAME_MAX_LENGTH = 16,
-    /**
-     * Message.senderName
-     *
-     * @generated from protobuf enum value: MESSAGE_SENDER_NAME_MAX_LENGTH = 65;
-     */
-    MESSAGE_SENDER_NAME_MAX_LENGTH = 65,
     /**
      * SalesOrderPayload.note
      *
@@ -316,9 +310,7 @@ export declare enum Constants {
      */
     PACKAGE_ENTITY_TYPE_ID = 64,
     /**
-     * Message.senderName
-     *
-     * @generated from protobuf enum value: MESSAGE_SENDER_NAME_MAX_LENGTH = 65;
+     * @generated from protobuf enum value: PRODUCT_ENTITY_TYPE_ID = 65;
      */
     PRODUCT_ENTITY_TYPE_ID = 65,
     /**
@@ -393,9 +385,7 @@ export declare enum Constants {
      */
     MERABILLS_ONLINE_PRICE_LIST = 64,
     /**
-     * Message.senderName
-     *
-     * @generated from protobuf enum value: MESSAGE_SENDER_NAME_MAX_LENGTH = 65;
+     * @generated from protobuf enum value: PRODUCT_ENTITY_TYPE_ID = 65;
      */
     AMAZON_SELLER_PRICE_LIST = 65,
     /**

package/dist/generated/Constants.js

@@ -139,12 +139,6 @@ export var Constants;
      * @generated from protobuf enum value: ATTACHMENT_FILE_HASH_SIZE_BYTES = 16;
      */
     Constants[Constants["ATTACHMENT_FILE_NAME_MAX_LENGTH"] = 16] = "ATTACHMENT_FILE_NAME_MAX_LENGTH";
-    /**
-     * Message.senderName
-     *
-     * @generated from protobuf enum value: MESSAGE_SENDER_NAME_MAX_LENGTH = 65;
-     */
-    Constants[Constants["MESSAGE_SENDER_NAME_MAX_LENGTH"] = 65] = "MESSAGE_SENDER_NAME_MAX_LENGTH";
     /**
      * SalesOrderPayload.note
      *
@@ -321,9 +315,7 @@ export var Constants;
      */
     Constants[Constants["PACKAGE_ENTITY_TYPE_ID"] = 64] = "PACKAGE_ENTITY_TYPE_ID";
     /**
-     * Message.senderName
-     *
-     * @generated from protobuf enum value: MESSAGE_SENDER_NAME_MAX_LENGTH = 65;
+     * @generated from protobuf enum value: PRODUCT_ENTITY_TYPE_ID = 65;
      */
     Constants[Constants["PRODUCT_ENTITY_TYPE_ID"] = 65] = "PRODUCT_ENTITY_TYPE_ID";
     /**
@@ -398,9 +390,7 @@ export var Constants;
      */
     Constants[Constants["MERABILLS_ONLINE_PRICE_LIST"] = 64] = "MERABILLS_ONLINE_PRICE_LIST";
     /**
-     * Message.senderName
-     *
-     * @generated from protobuf enum value: MESSAGE_SENDER_NAME_MAX_LENGTH = 65;
+     * @generated from protobuf enum value: PRODUCT_ENTITY_TYPE_ID = 65;
      */
     Constants[Constants["AMAZON_SELLER_PRICE_LIST"] = 65] = "AMAZON_SELLER_PRICE_LIST";
     /**

package/dist/generated/Message.d.ts

@@ -18,6 +18,8 @@ import { Entity } from "./Entity";
  * its message, so, a deleted message that carries a sales order is an order that the business has
  * completed, and is the whole of what a customer is shown of it afterwards. A deleted message is not
  * a cart, whatever it carries.
+ * Excluded: senderName, senderPhone. The merchant app makes a Party from them only for a message whose sender has none. A storefront
+ * sends the party with its order (see Party), and a customer is sent only the messages of their own party.
  *
  * @generated from protobuf message com.merabills.storefront.Message
  */
@@ -29,8 +31,7 @@ export interface Message {
     /**
      * Id of the party that sent this message - Java Message.senderId, which is a party id and not the id
      * of a User: the party of the BusinessLink of the sender (BusinessLink.partyId). Carried by a business
-     * sync out, which sends a customer only the messages whose sender is their own party. senderName /
-     * senderPhone below say who it was without resolving the party.
+     * sync out, which sends a customer only the messages whose sender is their own party.
      *
      * @generated from protobuf field: int64 senderId = 2
      */
@@ -43,31 +44,19 @@ export interface Message {
      * @generated from protobuf field: com.merabills.storefront.TaskStatus status = 4
      */
     status: TaskStatus;
-    /**
-     * At most Constants.MESSAGE_SENDER_NAME_MAX_LENGTH
-     *
-     * @generated from protobuf field: optional string senderName = 5
-     */
-    senderName?: string;
-    /**
-     * E.164 formatted phone number of the sender
-     *
-     * @generated from protobuf field: optional string senderPhone = 6
-     */
-    senderPhone?: string;
     /**
      * @generated from protobuf oneof: payload
      */
     payload: {
         oneofKind: "salesOrder";
         /**
-         * @generated from protobuf field: com.merabills.storefront.SalesOrderPayload salesOrder = 7
+         * @generated from protobuf field: com.merabills.storefront.SalesOrderPayload salesOrder = 5
          */
         salesOrder: SalesOrderPayload;
     } | {
         oneofKind: "partyPreferences";
         /**
-         * @generated from protobuf field: com.merabills.storefront.PartyPreferencesPayload partyPreferences = 8
+         * @generated from protobuf field: com.merabills.storefront.PartyPreferencesPayload partyPreferences = 6
          */
         partyPreferences: PartyPreferencesPayload;
     } | {

package/dist/generated/Message.js

@@ -15,10 +15,8 @@ class Message$Type extends MessageType$ {
             { no: 2, name: "senderId", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
             { no: 3, name: "messageType", kind: "enum", T: () => ["com.merabills.storefront.MessageType", MessageType] },
             { no: 4, name: "status", kind: "enum", T: () => ["com.merabills.storefront.TaskStatus", TaskStatus] },
-            { no: 5, name: "senderName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
-            { no: 6, name: "senderPhone", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
-            { no: 7, name: "salesOrder", kind: "message", oneof: "payload", T: () => SalesOrderPayload },
-            { no: 8, name: "partyPreferences", kind: "message", oneof: "payload", T: () => PartyPreferencesPayload }
+            { no: 5, name: "salesOrder", kind: "message", oneof: "payload", T: () => SalesOrderPayload },
+            { no: 6, name: "partyPreferences", kind: "message", oneof: "payload", T: () => PartyPreferencesPayload }
         ]);
     }
     create(value) {
@@ -48,19 +46,13 @@ class Message$Type extends MessageType$ {
                 case /* com.merabills.storefront.TaskStatus status */ 4:
                     message.status = reader.int32();
                     break;
-                case /* optional string senderName */ 5:
-                    message.senderName = reader.string();
-                    break;
-                case /* optional string senderPhone */ 6:
-                    message.senderPhone = reader.string();
-                    break;
-                case /* com.merabills.storefront.SalesOrderPayload salesOrder */ 7:
+                case /* com.merabills.storefront.SalesOrderPayload salesOrder */ 5:
                     message.payload = {
                         oneofKind: "salesOrder",
                         salesOrder: SalesOrderPayload.internalBinaryRead(reader, reader.uint32(), options, message.payload.salesOrder)
                     };
                     break;
-                case /* com.merabills.storefront.PartyPreferencesPayload partyPreferences */ 8:
+                case /* com.merabills.storefront.PartyPreferencesPayload partyPreferences */ 6:
                     message.payload = {
                         oneofKind: "partyPreferences",
                         partyPreferences: PartyPreferencesPayload.internalBinaryRead(reader, reader.uint32(), options, message.payload.partyPreferences)
@@ -90,18 +82,12 @@ class Message$Type extends MessageType$ {
         /* com.merabills.storefront.TaskStatus status = 4; */
         if (message.status !== 0)
             writer.tag(4, WireType.Varint).int32(message.status);
-        /* optional string senderName = 5; */
-        if (message.senderName !== undefined)
-            writer.tag(5, WireType.LengthDelimited).string(message.senderName);
-        /* optional string senderPhone = 6; */
-        if (message.senderPhone !== undefined)
-            writer.tag(6, WireType.LengthDelimited).string(message.senderPhone);
-        /* com.merabills.storefront.SalesOrderPayload salesOrder = 7; */
+        /* com.merabills.storefront.SalesOrderPayload salesOrder = 5; */
         if (message.payload.oneofKind === "salesOrder")
-            SalesOrderPayload.internalBinaryWrite(message.payload.salesOrder, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
-        /* com.merabills.storefront.PartyPreferencesPayload partyPreferences = 8; */
+            SalesOrderPayload.internalBinaryWrite(message.payload.salesOrder, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* com.merabills.storefront.PartyPreferencesPayload partyPreferences = 6; */
         if (message.payload.oneofKind === "partyPreferences")
-            PartyPreferencesPayload.internalBinaryWrite(message.payload.partyPreferences, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+            PartyPreferencesPayload.internalBinaryWrite(message.payload.partyPreferences, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/dist/generated/Party.d.ts

@@ -0,0 +1,52 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Address } from "./Address";
+/**
+ * The customer that places an order, as the business knows them: the party of the business link in the link token. It is sent with an
+ * order in BusinessSyncInRequest, so that the business has a party for the customer, and the party has its ledger, as when a customer
+ * places an order in the merchant app. It carries no id: the party is the one of the link (BusinessLink.partyId).
+ * The server creates the party and its ledger if the business has none. Otherwise it sets the name if the party has none, sets the
+ * phone number if it differs, and adds the addresses to the party, or replaces those with the same id. Nothing else of an existing
+ * party changes.
+ * Excluded: the id (the party is the one of the link) and what only an operator of the business sets: the nickname, the translations of
+ * the name and nickname, the contact link, the payment methods, the description and the disabled flag. An existing party keeps them.
+ *
+ * @generated from protobuf message com.merabills.storefront.Party
+ */
+export interface Party {
+    /**
+     * Required. The name of the party, if it has none. The server shortens a name that is longer than a party's, which is 32 characters,
+     * to its first 32 characters.
+     *
+     * @generated from protobuf field: string name = 1
+     */
+    name: string;
+    /**
+     * Required, E.164 formatted. It has to be the phone number that the authentication token verified (401).
+     *
+     * @generated from protobuf field: string mobilePhoneNumber = 2
+     */
+    mobilePhoneNumber: string;
+    /**
+     * The addresses to add to the party, such as the delivery address of the order. An address replaces the one with the same id.
+     * Each has a non-zero id. At most Constants.MAX_ADDRESSES.
+     *
+     * @generated from protobuf field: repeated com.merabills.storefront.Address addresses = 3
+     */
+    addresses: Address[];
+}
+declare class Party$Type extends MessageType<Party> {
+    constructor();
+    create(value?: PartialMessage<Party>): Party;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Party): Party;
+    internalBinaryWrite(message: Party, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message com.merabills.storefront.Party
+ */
+export declare const Party: Party$Type;
+export {};