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

package/dist/Constants.d.ts

@@ -9,3 +9,4 @@ export declare function quantityFromScaledValue(scaledQuantity: number): number;
 export declare function quantityToScaledValue(quantity: number): number;
 export declare function taxRateFromScaledValue(scaledTaxRate: number): number;
 export declare function taxRateToScaledValue(taxRate: number): number;
+export declare const MAX_PROFILE_STALENESS_MS: number;

package/dist/Constants.js

@@ -44,3 +44,6 @@ export function taxRateFromScaledValue(scaledTaxRate) {
 export function taxRateToScaledValue(taxRate) {
     return Math.round(taxRate * (proto_Constants.TAX_RATE_FACTOR / 100));
 }
+// How long a signed-in customer's profile may go without a read before Model.refreshProfileIfStale
+// reads it again. A profile changes only when the customer edits it, on this or another device.
+export const MAX_PROFILE_STALENESS_MS = 60 * 60 * 1000;

package/dist/Exceptions.d.ts

@@ -2,3 +2,8 @@ export declare class InvalidArgumentException extends Error {
 }
 export declare class IllegalOperationException extends Error {
 }
+export declare class StoreCorruptException extends Error {
+    readonly containerName: string;
+    readonly reason: unknown;
+    constructor(containerName: string, reason: unknown);
+}

package/dist/Exceptions.js

@@ -1,8 +1,22 @@
-// The two programming errors this library throws. A UI does not recover from either. A sync
-// failure is a rejected promise (see ServiceExceptions.ts).
+// The two programming errors this library throws, and the exception for a store it cannot read. A
+// UI does not recover from a programming error. A sync failure is a rejected promise (see
+// ServiceExceptions.ts).
 // A caller passed something this library cannot work with
 export class InvalidArgumentException extends Error {
 }
 // A caller did something in an order this library does not allow
 export class IllegalOperationException extends Error {
 }
+// The store holds data that cannot be decoded, for example a blob cut short or one written by an
+// incompatible version. Everything in a store came from a server, except a cart that was not sent
+// and the id of a sign up that is under way. So deleting the containers and calling
+// Model.initialize again recovers: SyncCache keeps the containers it has opened, so a new
+// Model.initialize is needed after a delete.
+// containerName is the container that failed, and reason is what the decoder threw.
+export class StoreCorruptException extends Error {
+    constructor(containerName, reason) {
+        super(`The store holds data in container ${containerName} that cannot be read`);
+        this.containerName = containerName;
+        this.reason = reason;
+    }
+}

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/InMemoryLock.d.ts

@@ -0,0 +1,5 @@
+import Lock from "./Lock";
+export default class InMemoryLock implements Lock {
+    runExclusive<TValue>(key: string, action: () => Promise<TValue>): Promise<TValue>;
+    private readonly _tails;
+}

package/dist/InMemoryLock.js

@@ -0,0 +1,20 @@
+// A Lock that excludes only callers of this object, in order. For a test, or for a caller whose
+// store is used by one tab.
+export default class InMemoryLock {
+    constructor() {
+        this._tails = new Map();
+    }
+    runExclusive(key, action) {
+        const previous = this._tails.get(key) ?? Promise.resolve();
+        const result = previous.then(action);
+        // The next caller starts when this one settles, whether or not it failed
+        const tail = result.then(() => undefined, () => undefined);
+        this._tails.set(key, tail);
+        // Forget the key when nobody is waiting, so the map does not grow with every key used
+        void tail.then(() => {
+            if (this._tails.get(key) === tail)
+                this._tails.delete(key);
+        });
+        return result;
+    }
+}

package/dist/Lock.d.ts

@@ -0,0 +1,3 @@
+export default interface Lock {
+    runExclusive<TValue>(key: string, action: () => Promise<TValue>): Promise<TValue>;
+}

package/dist/Lock.js

@@ -0,0 +1 @@
+export {};

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

@@ -4,26 +4,29 @@ import Address from "./Address";
 import Business from "./Business";
 import Database from "./Database";
 import LiveData from "./LiveData";
+import Lock from "./Lock";
 import Profile from "./Profile";
 import Service from "./Service";
 import ShoppingList from "./ShoppingList";
 import UserProfile from "./UserProfile";
 export default class Model {
     private constructor();
-    static initialize(service: Service, database: Database): void;
+    static initialize(service: Service, database: Database, lock?: Lock): void;
     static getInstance(): Model;
     get business(): LiveData<Business | null>;
     get profile(): LiveData<Profile | null>;
     signIn(authenticationMethod: proto_AuthenticationMethod, subjectId: string, authenticationToken: string): Promise<void>;
     createUser(authenticationMethod: proto_AuthenticationMethod, subjectId: string, authenticationToken: string, userToCreate: UserProfile): Promise<void>;
     updateUser(userProfile: UserProfile): Promise<void>;
+    changeUser(change: (current: UserProfile) => UserProfile): Promise<void>;
+    refreshProfileIfStale(): Promise<boolean>;
     signOut(): Promise<void>;
     setBusinessId(businessId: string): Promise<void>;
     updateCart(shoppingList: ShoppingList): Promise<void>;
     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,34 +38,44 @@ 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 syncProfile;
+    private readStoredUser;
+    private sendUserUpdate;
     private createProfileOnServer;
+    private readProfilePages;
     private static requireJoinedBusiness;
-    private cacheProfileResponse;
-    private writeProfileResponse;
     private storeIssuedTokens;
     private getProfileContainerName;
     private requireProfileContainerName;
     private buildProfileAuthTokens;
     private requireProfileAuthTokens;
+    private static getProfileCursorsKey;
     private publishBusiness;
     private publish;
     private static buildPublishable;
     private publishProfile;
+    private publishProfileFromStore;
+    private refreshProfile;
     private static getService;
     private static getCache;
     private static _service;
     private static _cache;
+    private static _lock;
     private static _instance;
     private _authenticationMethod;
     private _subjectId;
     private _authenticationToken;
     private _businessId;
     private _isPublishedBusinessVetted;
+    private _profileReadAt;
+    private _publishedProfileCursors;
+    private _profileRefresh;
     private readonly _business;
     private readonly _profile;
 }