@shaxpir/duiduidui-models 1.0.0

package/dist/models/content/Migration.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration = exports.MigrationStatus = void 0;
+const ShareSync_1 = require("../../repo/ShareSync");
+const CachingHasher_1 = require("../../util/CachingHasher");
+const markup_1 = require("../markup");
+const Content_1 = require("./Content");
+const ContentKind_1 = require("./ContentKind");
+const Time_1 = require("./Time");
+var MigrationStatus;
+(function (MigrationStatus) {
+    MigrationStatus["MIGRATED"] = "MIGRATED";
+    MigrationStatus["CANT_MIGRATE"] = "CANT_MIGRATE";
+    MigrationStatus["REPAIRED"] = "REPAIRED";
+    MigrationStatus["CANT_REPAIR"] = "CANT_REPAIR";
+    MigrationStatus["SKIPPED"] = "SKIPPED";
+    MigrationStatus["UPDATED"] = "UPDATED";
+})(MigrationStatus || (exports.MigrationStatus = MigrationStatus = {}));
+class Migration extends Content_1.Content {
+    constructor(doc, shouldAcquire, shareSync) {
+        super(doc, shouldAcquire, shareSync);
+    }
+    static makeMigrationId(userId) {
+        return CachingHasher_1.CachingHasher.makeMd5ContentId(userId + "-" + ContentKind_1.ContentKind.MIGRATION);
+    }
+    static create(userId, isPrimary, deviceId) {
+        const now = Time_1.MultiClock.now();
+        const migrationId = Migration.makeMigrationId(userId);
+        const migrationRef = Content_1.Content.makeContentRef(migrationId, now.utc_time);
+        return ShareSync_1.ShareSyncFactory.get().createContent({
+            meta: {
+                ref: migrationRef,
+                is_head: false,
+                kind: ContentKind_1.ContentKind.MIGRATION,
+                id: migrationId,
+                owner: userId,
+                created_at: now,
+                updated_at: now
+            },
+            payload: {
+                start: now,
+                end: now,
+                is_complete: false,
+                is_primary: isPrimary,
+                device_id: deviceId,
+                legacy_snapshot_count: 0,
+                migrated_count: 0,
+                cant_migrate_count: 0,
+                repaired_count: 0,
+                cant_repair_count: 0,
+                updated_count: 0,
+                skipped_count: 0,
+                duration_minutes: 0,
+                migration_entries: []
+            }
+        });
+    }
+    get payload() {
+        this.checkDisposed("Migration.payload");
+        return this.doc.data.payload;
+    }
+    get durationMinutes() {
+        this.checkDisposed("Migration.durationMinutes");
+        return this.payload.duration_minutes;
+    }
+    get isPrimary() {
+        this.checkDisposed("Migration.isPrimary");
+        return this.payload.is_primary;
+    }
+    get isComplete() {
+        this.checkDisposed("Migration.isComplete");
+        return this.payload.is_complete;
+    }
+    setIsComplete(value) {
+        this.checkDisposed("Migration.setIsComplete");
+        if (this.isComplete != value) {
+            const batch = new markup_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'is_complete'], value);
+            this.touch(batch, batch.at);
+            batch.commit();
+        }
+    }
+    get legacySnapshotCount() {
+        this.checkDisposed("Migration.legacySnapshotCount");
+        return this.payload.legacy_snapshot_count;
+    }
+    setLegacySnapshotCount(value) {
+        this.checkDisposed("Migration.setLegacySnapshotCount");
+        if (this.legacySnapshotCount != value) {
+            const batch = new markup_1.BatchOperation(this);
+            batch.setPathValue(['payload', 'legacy_snapshot_count'], value);
+            this.touch(batch, batch.at);
+            batch.commit();
+        }
+    }
+    get repairedCount() {
+        this.checkDisposed("Migration.repairedCount");
+        return this.payload.repaired_count;
+    }
+    get cantRepairCount() {
+        this.checkDisposed("Migration.cantRepairCount");
+        return this.payload.cant_repair_count;
+    }
+    get migratedCount() {
+        this.checkDisposed("Migration.migratedCount");
+        return this.payload.migrated_count;
+    }
+    get cantMigrateCount() {
+        this.checkDisposed("Migration.cantMigrateCount");
+        return this.payload.cant_migrate_count;
+    }
+    get updatedCount() {
+        this.checkDisposed("Migration.updatedCount");
+        return this.payload.updated_count;
+    }
+    get skippedCount() {
+        this.checkDisposed("Migration.skippedCount");
+        return this.payload.skipped_count;
+    }
+    addMigrationEntry(entry) {
+        this.checkDisposed("Migration.addMigrationEntry");
+        const batch = new markup_1.BatchOperation(this, entry.at);
+        const modelCount = entry.models.length;
+        batch.pushIntoArray(['payload', 'migration_entries'], entry);
+        this.touch(batch, entry.at);
+        switch (entry.status) {
+            case MigrationStatus.MIGRATED:
+                batch.setPathValue(['payload', 'migrated_count'], this.migratedCount + modelCount);
+                break;
+            case MigrationStatus.CANT_MIGRATE:
+                batch.setPathValue(['payload', 'cant_migrate_count'], this.cantMigrateCount + modelCount);
+                break;
+            case MigrationStatus.REPAIRED:
+                batch.setPathValue(['payload', 'repaired_count'], this.repairedCount + modelCount);
+                break;
+            case MigrationStatus.CANT_REPAIR:
+                batch.setPathValue(['payload', 'cant_repair_count'], this.cantRepairCount + modelCount);
+                break;
+            case MigrationStatus.UPDATED:
+                batch.setPathValue(['payload', 'updated_count'], this.updatedCount + modelCount);
+                break;
+            case MigrationStatus.SKIPPED:
+                batch.setPathValue(['payload', 'skipped_count'], this.skippedCount + modelCount);
+                break;
+        }
+        batch.commit();
+    }
+    touch(batch, at) {
+        const minutes = Time_1.Time.absDiffMinutes(at.utc_time, this.payload.start.utc_time);
+        batch.setPathValue(['payload', 'duration_minutes'], minutes);
+        batch.setPathValue(['payload', 'end', 'utc_time'], at.utc_time);
+        batch.setPathValue(['payload', 'end', 'local_time'], at.local_time);
+    }
+}
+exports.Migration = Migration;

package/dist/models/content/Model.d.ts

@@ -0,0 +1,45 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { DispatchTopic } from '../../util/Dispatch';
+import { ContentId, ContentMeta, ContentRef } from './Content';
+import { ContentKind } from './ContentKind';
+import { ManifestBody } from './Manifest';
+import { PermissionType } from './Permissions';
+import { CompactDateTime } from './Time';
+export declare abstract class Model {
+    static CHANGED: DispatchTopic;
+    doc: Doc;
+    private _isDisposed;
+    private _isForbidden;
+    private _shouldPerformModelChangeAnalysis;
+    private _dataBeforeOpBatch;
+    private _clearEventListeners;
+    protected shareSync: ShareSync;
+    private _subscribingPromise;
+    private _acquireCount;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get kind(): ContentKind;
+    get ref(): ContentRef;
+    get compoundKey(): string;
+    exists(): boolean;
+    get isForbidden(): boolean;
+    get isSubscribed(): boolean;
+    get acquireCount(): number;
+    acquire(minVersion?: CompactDateTime): Promise<Model>;
+    release(): void;
+    dispose(): void;
+    disposeAndDestroy(): void;
+    disposeAndUnsubscribe(): void;
+    fetch(): Promise<Model>;
+    subscribe(): Promise<Model>;
+    unsubscribe(): Promise<Model>;
+    isDisposed(): boolean;
+    checkDisposed(source: string): void;
+    ensureData(): Promise<Model>;
+    ensureRecentData(minVersion: CompactDateTime): Promise<Model>;
+    doesUserHavePermission(userId: ContentId, type: PermissionType): boolean;
+    static doesUserHaveManifestPermission(data: ManifestBody, userId: ContentId, type: PermissionType): boolean;
+    static doesUserHaveContentPermission(kind: ContentKind, meta: ContentMeta, userId: ContentId, type: PermissionType): boolean;
+    private log;
+}

package/dist/models/content/Model.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const Struct_1 = require("../../util/Struct");
+const Dispatch_1 = require("../../util/Dispatch");
+const ChangeModel_1 = require("../markup/ChangeModel");
+const ContentKind_1 = require("./ContentKind");
+const Permissions_1 = require("./Permissions");
+class Model {
+    constructor(doc, shouldAcquire, shareSync) {
+        this._dataBeforeOpBatch = null;
+        this._clearEventListeners = null;
+        this._subscribingPromise = null;
+        this._acquireCount = 0;
+        const model = this;
+        model.doc = doc;
+        model.shareSync = shareSync;
+        model._isDisposed = false;
+        model._isForbidden = false;
+        // When a model is newly created, or retrieved via a "fetch query", treat that as an implicit
+        // call to "acquire", since the SharedDB doc object will eventually need to be disposed.
+        if (shouldAcquire) {
+            this._acquireCount++;
+        }
+        const onBeforeOpBatch = function (op, source) {
+            if (model._shouldPerformModelChangeAnalysis) {
+                model._dataBeforeOpBatch = Struct_1.Struct.clone(model.doc.data);
+            }
+        };
+        const onOpBatch = function (op, source) {
+            if (model._shouldPerformModelChangeAnalysis) {
+                // Use tuple-arrays to perform a diff...
+                const dataAfterOpBatch = Struct_1.Struct.clone(model.doc.data);
+                let changeItems = ChangeModel_1.ChangeModel.between(model._dataBeforeOpBatch, dataAfterOpBatch);
+                model._dataBeforeOpBatch = null;
+                // FROM https://share.github.io/sharedb/api/doc ...
+                // The 'source' value will be false for remote ops received from other clients, or will be truthy
+                // for ops submitted from this doc instance. For local ops, it will be the value of source supplied
+                // to submitOp, or true if no value was supplied
+                const isLocalChange = !!source;
+                const change = {
+                    local: isLocalChange,
+                    model: model,
+                    items: changeItems,
+                    op: op
+                };
+                Dispatch_1.Dispatch.publish(Model.CHANGED, change);
+            }
+        };
+        model.doc.on('before op batch', onBeforeOpBatch);
+        model.doc.on('op batch', onOpBatch);
+        this._clearEventListeners = function () {
+            if (model.doc && model.doc.off) {
+                model.doc.off('before op batch', onBeforeOpBatch);
+                model.doc.off('op batch', onOpBatch);
+            }
+        };
+    }
+    get kind() {
+        return this.doc.collection;
+    }
+    get ref() {
+        return this.doc.id;
+    }
+    get compoundKey() {
+        return `${this.doc.collection}/${this.doc.id}`;
+    }
+    exists() {
+        return (!!this.doc.type) && !this.isForbidden;
+    }
+    get isForbidden() {
+        return this._isForbidden;
+    }
+    get isSubscribed() {
+        return this.doc.subscribed;
+    }
+    get acquireCount() {
+        return this._acquireCount;
+    }
+    async acquire(minVersion) {
+        this._acquireCount++;
+        if (minVersion) {
+            this.log(`ACQUIRE: (${this.compoundKey}) at minVersion '${minVersion}'; acquireCount = ${this.acquireCount}`);
+            return this.ensureRecentData(minVersion);
+        }
+        else {
+            this.log(`ACQUIRE: (${this.compoundKey}); acquireCount = ${this.acquireCount}`);
+            return this.ensureData();
+        }
+    }
+    release() {
+        this._acquireCount--;
+        this.log(`RELEASE: (${this.compoundKey}); acquireCount = ${this.acquireCount}`);
+        if (this._acquireCount <= 0) {
+            this._acquireCount = 0;
+            this.dispose();
+        }
+    }
+    dispose() {
+        const model = this;
+        model._clearEventListeners();
+        model.shareSync.dispose(model);
+    }
+    disposeAndDestroy() {
+        this.log(`DISPOSE (AND DESTROY): (${this.compoundKey})`);
+        this._isDisposed = true;
+        this.doc.destroy();
+    }
+    disposeAndUnsubscribe() {
+        this.log(`DISPOSE (AND UNSUBSCRIBE): (${this.compoundKey})`);
+        this._isDisposed = true;
+        if (this.isSubscribed) {
+            this.unsubscribe();
+        }
+    }
+    async fetch() {
+        this.log(`FETCH: (${this.compoundKey})`);
+        const model = this;
+        return new Promise((resolve, reject) => {
+            model.doc.fetch((fetchErr) => {
+                if (fetchErr) {
+                    if (fetchErr.message == 'forbidden') {
+                        model._isForbidden = true;
+                        resolve(model);
+                    }
+                    else {
+                        const message = `error fetching model ${model.compoundKey}: ${fetchErr}`;
+                        console.log(message);
+                        model.release();
+                        reject(message);
+                    }
+                }
+                else {
+                    model.shareSync.isDebug() && console.log(`fetched model ${model.compoundKey}`);
+                    resolve(model);
+                }
+            });
+        });
+    }
+    async subscribe() {
+        this.log(`SUBSCRIBE: (${this.compoundKey})`);
+        if (this._subscribingPromise != null) {
+            return this._subscribingPromise;
+        }
+        if (this.isSubscribed) {
+            return this;
+        }
+        const model = this;
+        this._subscribingPromise = new Promise((resolve, reject) => {
+            this.doc.subscribe((subscribeErr) => {
+                model._subscribingPromise = null;
+                if (subscribeErr) {
+                    if (subscribeErr.message == 'forbidden') {
+                        model._isForbidden = true;
+                        resolve(model);
+                    }
+                    else {
+                        const message = `error subscribing to Model ${model.compoundKey}: ${subscribeErr}`;
+                        console.log(message);
+                        reject(message);
+                    }
+                }
+                else {
+                    model.shareSync.isDebug() && console.log(`subscribed to Model ${model.compoundKey}`);
+                    resolve(model);
+                }
+            });
+        });
+        return this._subscribingPromise;
+    }
+    async unsubscribe() {
+        this.log(`UNSUBSCRIBE: (${this.compoundKey})`);
+        if (this._subscribingPromise != null) {
+            await this._subscribingPromise;
+        }
+        if (!this.isSubscribed) {
+            return this;
+        }
+        const model = this;
+        return new Promise((resolve, reject) => {
+            this.doc.unsubscribe((unsubscribeErr) => {
+                if (unsubscribeErr) {
+                    const message = `error unsubscribing from Model ${model.compoundKey}: ${unsubscribeErr}`;
+                    console.log(message);
+                    reject(message);
+                }
+                else {
+                    model.shareSync.isDebug() && console.log(`subscribed to Model ${model.compoundKey}`);
+                    resolve(model);
+                }
+            });
+        });
+    }
+    isDisposed() {
+        return this._isDisposed;
+    }
+    checkDisposed(source) {
+        if (this._isDisposed) {
+            console.error(`*** MODEL ALREDY DISPOSED: (${this.compoundKey}); source = ${source}`);
+        }
+    }
+    async ensureData() {
+        const model = this;
+        return new Promise((resolve, reject) => {
+            this.doc.ensureDocHasData((ensureErr) => {
+                if (ensureErr) {
+                    if (ensureErr.message == 'forbidden') {
+                        model._isForbidden = true;
+                        resolve(model);
+                    }
+                    else {
+                        const message = `error ensuring doc has data in Model ${model.compoundKey}: ${ensureErr}`;
+                        console.log(message);
+                        reject(message);
+                    }
+                }
+                else {
+                    model.shareSync.isDebug() && console.log(`ensured doc has data for Model ${model.compoundKey}`);
+                    resolve(model);
+                }
+            });
+        });
+    }
+    async ensureRecentData(minVersion) {
+        const model = this;
+        return new Promise((resolve, reject) => {
+            this.doc.ensureDocHasRecentData(minVersion, (ensureErr) => {
+                if (ensureErr) {
+                    if (ensureErr.message == 'forbidden') {
+                        model._isForbidden = true;
+                        resolve(model);
+                    }
+                    else {
+                        const message = `error ensuring doc has recent data in Model ${model.compoundKey} with minVersion ${minVersion}: ${ensureErr}`;
+                        console.log(message);
+                        reject(message);
+                    }
+                }
+                else {
+                    model.shareSync.isDebug() && console.log(`ensured doc has recent data for Model ${model.compoundKey} with minVersion ${minVersion}`);
+                    resolve(model);
+                }
+            });
+        });
+    }
+    doesUserHavePermission(userId, type) {
+        this.checkDisposed("Model.doesUserHavePermission");
+        if (this.kind === ContentKind_1.ContentKind.MANIFEST) {
+            return Model.doesUserHaveManifestPermission(this.doc.data, userId, type);
+        }
+        else {
+            // Content objects and checkpoints all have a PermissionsMeta
+            const meta = this.doc.data.meta;
+            return Model.doesUserHaveContentPermission(this.kind, meta, userId, type);
+        }
+    }
+    static doesUserHaveManifestPermission(data, userId, type) {
+        return data.meta.owner === userId;
+    }
+    static doesUserHaveContentPermission(kind, meta, userId, type) {
+        // Users are allowed to read any of their own content, but they are not allowed to write their User or Billing objects.
+        if (meta.owner === userId) {
+            if (type === Permissions_1.PermissionType.READ) {
+                return true;
+            }
+            else if (type === Permissions_1.PermissionType.WRITE) {
+                return kind !== ContentKind_1.ContentKind.USER && kind !== ContentKind_1.ContentKind.BILLING;
+            }
+        }
+        // If all else fails, deny permission.
+        return false;
+    }
+    log(message) {
+        if (this.shareSync.isDebug()) {
+            console.log(message);
+        }
+    }
+}
+exports.Model = Model;
+Model.CHANGED = "MODEL_CHANGED";

package/dist/models/content/Permissions.d.ts

@@ -0,0 +1,7 @@
+export declare enum PermissionType {
+    READ = 0,
+    WRITE = 1
+}
+export declare class PermissionModel {
+    static shouldAllow(grantedPermission: PermissionType, necessaryPermission: PermissionType): boolean;
+}

package/dist/models/content/Permissions.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionModel = exports.PermissionType = void 0;
+var PermissionType;
+(function (PermissionType) {
+    PermissionType[PermissionType["READ"] = 0] = "READ";
+    PermissionType[PermissionType["WRITE"] = 1] = "WRITE";
+})(PermissionType || (exports.PermissionType = PermissionType = {}));
+class PermissionModel {
+    static shouldAllow(grantedPermission, necessaryPermission) {
+        if (grantedPermission == necessaryPermission) {
+            return true;
+        }
+        else if (grantedPermission == PermissionType.WRITE && necessaryPermission == PermissionType.READ) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.PermissionModel = PermissionModel;

package/dist/models/content/Phrase.d.ts

@@ -0,0 +1,8 @@
+import { ContentBody, ContentMeta } from "./Content";
+import { Definable, DictionaryEntry, Pronouncable } from "./DictionaryEntry";
+export interface PhrasePayload extends DictionaryEntry, Pronouncable, Definable {
+}
+export interface PhraseBody extends ContentBody {
+    meta: ContentMeta;
+    payload: PhrasePayload;
+}

package/dist/models/content/Phrase.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/content/Placeholder.d.ts

@@ -0,0 +1,8 @@
+import { Content } from './Content';
+import { Stub } from './Stub';
+export declare class Placeholder {
+    static readonly PREFIX = "untitled";
+    static forCategory(name: string): string;
+    static forContent(content: Content): string;
+    static forStub(stub: Stub): string;
+}

package/dist/models/content/Placeholder.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Placeholder = void 0;
+const Text_1 = require("../../util/Text");
+const Book_1 = require("./Book");
+const ContentKind_1 = require("./ContentKind");
+const Fragment_1 = require("./Fragment");
+class Placeholder {
+    static forCategory(name) {
+        let placeholder = "untitled ";
+        if (typeof (name) !== "undefined") { // TODO: does anyone call this without an arg?
+            placeholder += name.trim();
+        }
+        return Text_1.Text.capitalizeWords(placeholder.trim());
+    }
+    static forContent(content) {
+        if (content instanceof Book_1.Book) {
+            return Placeholder.forCategory(ContentKind_1.ContentKind.BOOK);
+        }
+        else if (content instanceof Fragment_1.Fragment) {
+            return Placeholder.forCategory(content.category);
+        }
+        return Text_1.Text.capitalizeWords(content.kind);
+    }
+    static forStub(stub) {
+        if (stub.kind === ContentKind_1.ContentKind.BOOK) {
+            return Placeholder.forCategory(ContentKind_1.ContentKind.BOOK);
+        }
+        else if (stub.kind === ContentKind_1.ContentKind.FRAGMENT) {
+            return Placeholder.forCategory(stub.category);
+        }
+        return Text_1.Text.capitalizeWords(stub.kind);
+    }
+}
+exports.Placeholder = Placeholder;
+Placeholder.PREFIX = 'untitled';

package/dist/models/content/Profile.d.ts

@@ -0,0 +1,30 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { MediaCropping } from './Media';
+export interface ProfilePayload {
+    username: string;
+    full_name: string;
+    avatar_media_ref: ContentId;
+    avatar_cropping: MediaCropping;
+}
+export interface ProfileBody extends ContentBody {
+    meta: ContentMeta;
+    payload: ProfilePayload;
+}
+export declare class Profile extends Content {
+    static makeProfileId(userId: ContentId): ContentId;
+    static create(userId: ContentId): Profile;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): ProfilePayload;
+    get username(): string;
+    setUsername(value: string): void;
+    get fullName(): string;
+    setFullName(value: string): void;
+    get avatarMediaRef(): ContentId;
+    setAvatarMediaRef(value: ContentId): void;
+    get avatarCropping(): MediaCropping;
+    setAvatarCropping(value: MediaCropping): void;
+    static findByUsername(username: string): Promise<Profile[]>;
+}