bookish-press 0.4.45 → 0.4.47

package/src/lib/models/book/Book.ts

@@ -0,0 +1,283 @@
+import type { DocumentReference } from 'firebase/firestore';
+import BookMedia from './BookMedia';
+import type Edition from './Edition';
+
+/** A replication of edition info */
+export type EditionInfo = {
+    ref: DocumentReference;
+    summary: string;
+    number: number;
+    // The author specified edition number, or null if not published.
+    published: number | null;
+    editionuids: string[];
+    chapteruids: string[];
+};
+
+export type BookSpecification = {
+    // All of these are caches from the latest edition, saved when an edition is updated.
+    title: string;
+    authors: string[];
+    description: string;
+    cover: string | null;
+    // True if one of the book's editions is published.
+    published: boolean;
+    editions: EditionInfo[];
+    // An optional subdomain, for use in URLs
+    domain: string | null;
+    // A list of user ids that have access to edit the book.
+    uids: string[];
+    // A derived list of user ids that have read level access to the book via edition or chapter level write access.
+    readuids: string[];
+};
+
+export default class Book {
+    readonly ref: DocumentReference;
+    readonly title: string;
+    readonly authors: string[];
+    readonly description: string;
+    readonly cover: string | null;
+    readonly published: boolean;
+    readonly editions: EditionInfo[];
+    readonly domain: string | null;
+    readonly uids: string[];
+
+    media: BookMedia;
+
+    constructor(
+        ref: DocumentReference,
+        title: string,
+        authors: string[],
+        description: string,
+        cover: string | null,
+        editions: EditionInfo[],
+        domain: string | null,
+        uids: string[]
+    ) {
+        this.ref = ref;
+        this.title = title;
+        this.authors = authors;
+        this.description = description;
+        this.cover = cover;
+        // The published state is always true if some edition's published flag isn't null.
+        this.published = editions.some((edition) => edition.published !== null);
+        // We always keep editions in reversed edition number for easy reference.
+        this.editions = editions.sort((a, b) => a.number - b.number);
+        this.domain = domain;
+        this.uids = uids;
+
+        this.media = new BookMedia(this);
+    }
+
+    getMedia() {
+        return this.media;
+    }
+
+    static fromJSON(ref: DocumentReference, book: BookSpecification): Book {
+        return new Book(
+            ref,
+            book.title,
+            book.authors,
+            book.description,
+            book.cover,
+            book.editions,
+            book.domain,
+            book.uids
+        );
+    }
+
+    toJSON() {
+        const json: BookSpecification = {
+            title: this.title,
+            authors: this.authors,
+            description: this.description,
+            cover: this.cover,
+            published: this.published,
+            domain: this.domain,
+            editions: this.editions,
+            uids: this.uids,
+            readuids: Array.from(
+                new Set(
+                    this.editions
+                        .map((edition) => [
+                            ...edition.editionuids,
+                            ...edition.chapteruids,
+                        ])
+                        .flat()
+                )
+            ),
+        };
+        return json;
+    }
+
+    getSubdomain() {
+        return this.domain;
+    }
+
+    withSubdomain(domain: string) {
+        return new Book(
+            this.ref,
+            this.title,
+            this.authors,
+            this.description,
+            this.cover,
+            this.editions,
+            domain.length === 0 ? null : domain,
+            this.uids
+        );
+    }
+
+    getTitle() {
+        return this.title;
+    }
+
+    withTitle(title: string) {
+        return new Book(
+            this.ref,
+            title,
+            this.authors,
+            this.description,
+            this.cover,
+            this.editions,
+            this.domain,
+            this.uids
+        );
+    }
+
+    getDescription() {
+        return this.description;
+    }
+
+    withDescription(description: string) {
+        return new Book(
+            this.ref,
+            this.title,
+            this.authors,
+            description,
+            this.cover,
+            this.editions,
+            this.domain,
+            this.uids
+        );
+    }
+
+    getCover() {
+        return this.cover;
+    }
+
+    withCover(cover: string | null) {
+        return new Book(
+            this.ref,
+            this.title,
+            this.authors,
+            this.description,
+            cover,
+            this.editions,
+            this.domain,
+            this.uids
+        );
+    }
+
+    getAuthors() {
+        return this.authors;
+    }
+
+    withAuthors(authors: string[]) {
+        return new Book(
+            this.ref,
+            this.title,
+            authors,
+            this.description,
+            this.cover,
+            this.editions,
+            this.domain,
+            this.uids
+        );
+    }
+
+    getRef() {
+        return this.ref;
+    }
+
+    getRefID() {
+        return this.ref.id;
+    }
+
+    getEditionNumberID(number: number) {
+        // Get the ID corresponding to this number.
+        const edition = this.editions.find((ed) => ed.number === number);
+        return edition ? edition.ref.id : undefined;
+    }
+
+    getLatestPublishedEditionID() {
+        return this.editions.filter((ed) => ed.published !== null)[0]?.ref.id;
+    }
+
+    getLatestEditionID(): string | undefined {
+        return this.editions[0]?.ref.id;
+    }
+
+    getEditions() {
+        return this.editions.slice();
+    }
+
+    getPublishedEditionCount() {
+        return this.editions.filter((edition) => edition.published).length;
+    }
+
+    isEditor(uid: string) {
+        return this.uids.includes(uid);
+    }
+
+    withEditors(uids: string[]) {
+        return new Book(
+            this.ref,
+            this.title,
+            this.authors,
+            this.description,
+            this.cover,
+            this.editions,
+            this.domain,
+            uids
+        );
+    }
+
+    withEditions(revisions: EditionInfo[]) {
+        return new Book(
+            this.ref,
+            this.title,
+            this.authors,
+            this.description,
+            this.cover,
+            revisions,
+            this.domain,
+            this.uids
+        );
+    }
+
+    withRevisedEdition(previous: Edition, revised: Edition) {
+        // Get the new info.
+        const info = revised.getInfo();
+        if (info === undefined) return this;
+
+        // If no previous addition, just add it.
+        if (previous === undefined)
+            return this.withEditions([...this.editions, info]);
+
+        // Find the corresponding edition.
+        const index = this.editions.findIndex(
+            (edition) => edition.number === previous.number
+        );
+
+        return index < 0
+            ? this
+            : this.withEditions([
+                  ...this.editions.slice(0, index),
+                  info,
+                  ...this.editions.slice(index + 1),
+              ]);
+    }
+
+    hasPublishedEdition() {
+        return this.editions.some((revision) => revision.published !== null);
+    }
+}

package/src/lib/models/book/BookMedia.ts

@@ -0,0 +1,182 @@
+import type { StorageReference } from 'firebase/storage';
+import {
+    deleteObject,
+    getDownloadURL,
+    listAll,
+    ref,
+    uploadBytes,
+} from 'firebase/storage';
+import type Book from './Book';
+import { v4 as uuidv4 } from 'uuid';
+import { storage } from '../Firebase';
+
+export type Image = {
+    url: string;
+    ref: StorageReference;
+};
+
+export default class BookMedia {
+    readonly book: Book;
+    _images: Image[] | undefined;
+
+    // A list of functions to call when the book media changes.
+    readonly observers: Set<(images: Image[]) => void> = new Set();
+
+    constructor(book: Book) {
+        this.book = book;
+    }
+
+    notify(observer: (images: Image[]) => void) {
+        this.observers.add(observer);
+        // Notify it right away!
+        this.getImages().then((images) => observer(images));
+    }
+
+    stopNotifying(observer: (images: Image[]) => void) {
+        this.observers.delete(observer);
+    }
+
+    /** Get all non-thumbnail images. */
+    async getImages(): Promise<Image[]> {
+        return this._images === undefined ? this.cacheImages() : this._images;
+    }
+
+    getImagePath() {
+        return `images/${this.book.getRefID()}/`;
+    }
+
+    /** Get a listing of all of the images for the book. */
+    async cacheImages(): Promise<Image[]> {
+        if (storage === undefined) return [];
+
+        // Find all the prefixes and items.
+        this._images = (await this.retrieveImages()).filter(
+            (image) => image !== undefined
+        ) as Image[];
+
+        // Notify observers
+        for (const observer of this.observers) observer(this._images.slice());
+
+        return this._images;
+    }
+
+    async retrieveImages(): Promise<(Image | undefined)[]> {
+        if (storage === undefined) return [];
+
+        // Create a reference under which you want to list
+        const listRef = ref(storage, this.getImagePath());
+
+        // Find all the prefixes and items.
+        return listAll(listRef).then((res) =>
+            Promise.all(
+                res.items.map((itemRef) =>
+                    getDownloadURL(itemRef).then((url) => {
+                        const image = {
+                            url: url,
+                            description: '',
+                            ref: itemRef,
+                        };
+                        if (this._images !== undefined) {
+                            this._images.push(image);
+                        }
+                        return image;
+                    })
+                )
+            )
+        );
+    }
+
+    getThumbnailURL(
+        url: string,
+        thumbnailRef: StorageReference,
+        error: (message: string) => void,
+        finished: (url: string, thumbnailURL: string) => void,
+        attempt = 0
+    ) {
+        getDownloadURL(thumbnailRef)
+            .then((thumbnail) => finished(url, thumbnail))
+            // Try again in a bit.
+            .catch(() =>
+                attempt > 25
+                    ? error("Couldn't get the image URL. Connection issues?")
+                    : setTimeout(
+                          () =>
+                              this.getThumbnailURL(
+                                  url,
+                                  thumbnailRef,
+                                  error,
+                                  finished,
+                                  attempt + 1
+                              ),
+                          250
+                      )
+            );
+    }
+
+    upload(
+        file: File,
+        progressHandler: (progress: number) => void,
+        errorHandler: (message: string) => void,
+        finishedHandler: (url: string, thumbnailURL: string) => void
+    ) {
+        progressHandler;
+
+        if (storage === undefined) return;
+
+        // The canonical path format for Bookish images in the store is image/{bookid}/{imageid}
+        // where {bookid} is the Firestore ID of the book being edited and {imageid} is just a random id.
+        const imageName = `image-${uuidv4()}`;
+        const imageRef = ref(storage, `${this.getImagePath()}/${imageName}`);
+        const thumbnailRef = ref(
+            storage,
+            `${this.getImagePath()}/thumbnails/${imageName}`
+        );
+
+        uploadBytes(imageRef, file)
+            .then((snapshot) => {
+                getDownloadURL(snapshot.ref)
+                    .then((url) => {
+                        // Give some time for the cloud function to create a thumbnail, then try to get it's URL.
+                        setTimeout(
+                            () =>
+                                this.getThumbnailURL(
+                                    url,
+                                    thumbnailRef,
+                                    errorHandler,
+                                    finishedHandler
+                                ),
+                            250
+                        );
+                    })
+                    .catch(() => errorHandler('Unable to get image URL.'));
+            })
+            .then(() => this.cacheImages());
+
+        // This seems to be broken in Firebase right now. Switched above to a no-feedback approach.
+        // const uploadTask = uploadBytesResumable(imageRef, file);
+        // uploadTask.on("state_changed",
+        //     // During upload, notify of progress by sending an integer percent complete.
+        //     (snapshot) => progressHandler(Math.round((snapshot.bytesTransferred / snapshot.totalBytes) * 100)),
+        //     // If there's an error, map it to a message.
+        //     // https://firebase.google.com/docs/storage/web/handle-errors
+        //     (error) => {
+        //         console.error(error);
+        //         errorHandler(
+        //             error.code === "storage/unauthorized" ? "Wrong permissions to upload" :
+        //             error.code === "storage/canceled" ? "Upload canceled" :
+        //             error.code === "storage/quota-exceeded" ? "Storage limit reached" :
+        //             error.code === "storage/unauthenticated" ? "Log in again to upload" :
+        //             "Unknown upload error"
+        //         )
+        //     },
+    }
+
+    async remove(image: Image) {
+        if (storage === undefined) return;
+
+        const imageRef = ref(storage, image.ref.fullPath);
+        await deleteObject(imageRef);
+
+        return await this.cacheImages();
+    }
+}

package/src/lib/models/book/BookSaveStatus.ts

@@ -0,0 +1,8 @@
+enum BookSaveStatus {
+    Changed,
+    Saving,
+    Saved,
+    Error,
+}
+
+export default BookSaveStatus;