@peabody-soft/mbs-model-ts 1.0.0

package/dist/MockDatabase.js

@@ -0,0 +1,73 @@
+// A Database that holds everything in a Map, for tests and training mode to run against with no
+// network. Enforces the eTag rule for real (write only if the new eTag is greater), so a test proves the sync is actually idempotent.
+export default class MockDatabase {
+    constructor() {
+        this._containers = new Map();
+    }
+    async getContainer(name) {
+        let container = this._containers.get(name);
+        if (container === undefined) {
+            container = new MockContainer();
+            this._containers.set(name, container);
+        }
+        return container;
+    }
+    async getContainerNames() {
+        return Object.freeze([...this._containers.keys()]);
+    }
+    async deleteContainer(name) {
+        this._containers.delete(name);
+    }
+    // For a test that wants to look at what was stored without going through a sync
+    getContainerIfPresent(name) {
+        return this._containers.get(name) ?? null;
+    }
+}
+export class MockContainer {
+    constructor() {
+        // Set by a test just before the write it wants to fail
+        this.failNextWrite = false;
+        // How many times write has been called, so that a test can show a sync did not write per entity
+        this.writeCount = 0;
+        this._blobs = new Map();
+    }
+    async read(id) {
+        return this._blobs.get(id) ?? null;
+    }
+    async readAll() {
+        return Object.freeze([...this._blobs.values()]);
+    }
+    async write(blobs, deletes) {
+        ++this.writeCount;
+        // Fails before touching anything, so a test can prove a failed write changes nothing.
+        if (this.failNextWrite) {
+            this.failNextWrite = false;
+            throw new Error("Mock store was told to fail this write");
+        }
+        let appliedCount = 0;
+        for (const blob of blobs) {
+            if (!MockContainer.isNewer(blob, this._blobs.get(blob.id) ?? null))
+                continue;
+            this._blobs.set(blob.id, blob);
+            ++appliedCount;
+        }
+        // Unconditional, and after the writes, exactly as the Database contract says
+        for (const id of deletes)
+            this._blobs.delete(id);
+        return appliedCount;
+    }
+    // Greater eTag wins; a blob with no eTag (or overwriting one with none) is always written.
+    static isNewer(incoming, stored) {
+        if (stored === null)
+            return true;
+        if (incoming.eTag === null || stored.eTag === null)
+            return true;
+        return incoming.eTag > stored.eTag;
+    }
+    get size() {
+        return this._blobs.size;
+    }
+    has(id) {
+        return this._blobs.has(id);
+    }
+}

package/dist/Model.d.ts

@@ -0,0 +1,63 @@
+import { AuthenticationMethod as proto_AuthenticationMethod } from "./generated/AuthenticationMethod";
+import { FulfillmentMode as proto_FulfillmentMode } from "./generated/FulfillmentMode";
+import Address from "./Address";
+import Business from "./Business";
+import Database from "./Database";
+import LiveData from "./LiveData";
+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 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>;
+    signOut(): Promise<void>;
+    setBusinessId(businessId: string): Promise<void>;
+    updateCart(shoppingList: ShoppingList): Promise<void>;
+    updateCartLocalOnly(shoppingList: ShoppingList): Promise<void>;
+    createOrder(fulfillmentMode: proto_FulfillmentMode, deliveryAddressId: bigint, deliveryAddress: Address | null, note: string | null): Promise<void>;
+    private beginSignIn;
+    private pushBusinessMessages;
+    private storeCart;
+    private requireBusinessBeingBrowsed;
+    private requireCustomerOfBusiness;
+    private static requireDeliveryAddress;
+    private businessSyncIn;
+    private syncAnonymousBusiness;
+    private syncBusinessContainer;
+    private requireBusinessLink;
+    private readJoinBusinessId;
+    private static findBusinessEntity;
+    private static findBusinessLink;
+    private static getBusinessContainerName;
+    private requireBusinessAuthTokens;
+    private profileSyncIn;
+    private createProfileOnServer;
+    private static requireJoinedBusiness;
+    private cacheProfileResponse;
+    private writeProfileResponse;
+    private storeIssuedTokens;
+    private getProfileContainerName;
+    private requireProfileContainerName;
+    private buildProfileAuthTokens;
+    private requireProfileAuthTokens;
+    private publishBusiness;
+    private publishProfile;
+    private static getService;
+    private static getCache;
+    private static _service;
+    private static _cache;
+    private static _instance;
+    private _authenticationMethod;
+    private _subjectId;
+    private _authenticationToken;
+    private _businessId;
+    private readonly _business;
+    private readonly _profile;
+}