@shaxpir/duiduidui-models 1.0.0

package/lib/models/content/Model.ts

@@ -0,0 +1,327 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { Struct } from '../../util/Struct';
+import { Dispatch, DispatchTopic } from '../../util/Dispatch';
+import { ChangeModel } from '../markup/ChangeModel';
+import { ContentId, ContentMeta, ContentRef } from './Content';
+import { ContentKind } from './ContentKind';
+import { ManifestBody } from './Manifest';
+import { PermissionType } from './Permissions';
+import { CompactDateTime } from './Time';
+
+export abstract class Model {
+
+  public static CHANGED:DispatchTopic = "MODEL_CHANGED";
+
+  public doc:Doc;
+  private _isDisposed:boolean;
+
+  // The "forbidden" flag is set when the user does not have permission to read or write the model.
+  // We set this flag during fetch, subscribe, and ensureData operations, if the server responds with
+  // 'forbidden'. Rather than throwing an exception or emitting an error event, or calling an error
+  // callback, this technique allows the nornal flow of logic to proceed, and the model can be checked
+  // for the forbidden flag at any time. Callers can (for example) display a 404 page, or a "forbidden"
+  // message, or simply ignore the model, depending on the context, rather than having to handle errors.
+  // But it should be forewarned that any BatchOperation that is attempted on a forbidden model will
+  // throw an exception, because the model data is not allowed to be read or written by this user.
+  private _isForbidden:boolean;
+
+  private _shouldPerformModelChangeAnalysis:boolean;
+  private _dataBeforeOpBatch:any = null;
+  private _clearEventListeners:() => void = null;
+
+  protected shareSync:ShareSync;
+  private _subscribingPromise:Promise<Model> = null;
+  private _acquireCount:number = 0;
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    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:any, source:any) {
+      if (model._shouldPerformModelChangeAnalysis) {
+        model._dataBeforeOpBatch = Struct.clone(model.doc.data);
+      }
+    };
+    const onOpBatch = function (op:any, source:any) {
+      if (model._shouldPerformModelChangeAnalysis) {
+        // Use tuple-arrays to perform a diff...
+        const dataAfterOpBatch = Struct.clone(model.doc.data);
+        let changeItems = 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.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);
+      }
+    };
+  }
+
+  public get kind():ContentKind {
+    return this.doc.collection as ContentKind;
+  }
+
+  public get ref():ContentRef {
+    return this.doc.id as ContentRef;
+  }
+
+  public get compoundKey():string {
+    return `${this.doc.collection}/${this.doc.id}`;
+  }
+
+  public exists():boolean {
+    return (!!this.doc.type) && !this.isForbidden;
+  }
+
+  public get isForbidden():boolean {
+    return this._isForbidden;
+  }
+
+  public get isSubscribed():boolean {
+    return this.doc.subscribed;
+  }
+
+  public get acquireCount():number {
+    return this._acquireCount;
+  }
+
+  public async acquire(minVersion?:CompactDateTime):Promise<Model> {
+    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();
+    }
+  }
+
+  public release():void {
+    this._acquireCount--;
+    this.log(`RELEASE: (${this.compoundKey}); acquireCount = ${this.acquireCount}`);
+    if (this._acquireCount <= 0) {
+      this._acquireCount = 0;
+      this.dispose()
+    }
+  }
+
+  public dispose():void {
+    const model = this;
+    model._clearEventListeners();
+    model.shareSync.dispose(model);
+  }
+
+  public disposeAndDestroy():void {
+    this.log(`DISPOSE (AND DESTROY): (${this.compoundKey})`);
+    this._isDisposed = true;
+    this.doc.destroy();
+  }
+
+  public disposeAndUnsubscribe():void {
+    this.log(`DISPOSE (AND UNSUBSCRIBE): (${this.compoundKey})`);
+    this._isDisposed = true;
+    if (this.isSubscribed) {
+      this.unsubscribe();
+    }
+  }
+
+  public async fetch():Promise<Model> {
+    this.log(`FETCH: (${this.compoundKey})`);
+    const model = this;
+    return new Promise((resolve, reject) => {
+      model.doc.fetch((fetchErr:any) => {
+        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);
+        }
+      });
+    });
+  }
+
+  public async subscribe():Promise<Model> {
+    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:any) => {
+        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;
+  }
+
+  public async unsubscribe():Promise<Model> {
+    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:any) => {
+        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);
+        }
+      });
+    });
+  }
+
+  public isDisposed():boolean {
+    return this._isDisposed;
+  }
+
+  public checkDisposed(source:string):void {
+    if (this._isDisposed) {
+      console.error(`*** MODEL ALREDY DISPOSED: (${this.compoundKey}); source = ${source}`);
+    }
+  }
+
+  public async ensureData():Promise<Model> {
+    const model = this;
+    return new Promise((resolve, reject) => {
+      this.doc.ensureDocHasData((ensureErr:any) => {
+        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);
+        }
+      });
+    });
+  }
+
+  public async ensureRecentData(minVersion:CompactDateTime):Promise<Model> {
+    const model = this;
+    return new Promise((resolve, reject) => {
+      this.doc.ensureDocHasRecentData(minVersion, (ensureErr:any) => {
+        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);
+        }
+      });
+    });
+  }
+
+  public doesUserHavePermission(
+    userId:ContentId,
+    type:PermissionType
+  ):boolean {
+    this.checkDisposed("Model.doesUserHavePermission");
+    if (this.kind === 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 as ContentMeta;
+      return Model.doesUserHaveContentPermission(this.kind, meta, userId, type);
+    }
+  }
+
+  public static doesUserHaveManifestPermission(
+    data:ManifestBody,
+    userId:ContentId,
+    type:PermissionType
+  ):boolean {
+    return data.meta.owner === userId;
+  }
+
+  public static doesUserHaveContentPermission(
+    kind:ContentKind,
+    meta:ContentMeta,
+    userId:ContentId,
+    type:PermissionType
+  ):boolean {
+
+    // 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 === PermissionType.READ) {
+        return true;
+      } else if (type === PermissionType.WRITE) {
+        return kind !== ContentKind.USER && kind !== ContentKind.BILLING;
+      }
+    }
+
+    // If all else fails, deny permission.
+    return false;
+  }
+
+  private log(message:string):void {
+    if (this.shareSync.isDebug()) {
+      console.log(message);
+    }
+  }
+
+}

package/lib/models/content/Permissions.ts

@@ -0,0 +1,21 @@
+import { ContentId } from "./Content";
+
+export enum PermissionType {
+  READ,
+  WRITE
+}
+
+export class PermissionModel {
+
+  public static shouldAllow(
+    grantedPermission:PermissionType,
+    necessaryPermission:PermissionType
+  ):boolean {
+    if (grantedPermission == necessaryPermission) {
+      return true;
+    } else if (grantedPermission == PermissionType.WRITE && necessaryPermission == PermissionType.READ) {
+      return true;
+    }
+    return false;
+  }
+}

package/lib/models/content/Phrase.ts

@@ -0,0 +1,10 @@
+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/lib/models/content/Profile.ts

@@ -0,0 +1,119 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync, ShareSyncFactory } from '../../repo/ShareSync';
+import { CachingHasher } from '../../util/CachingHasher';
+import { BatchOperation } from '../markup/Operation';
+import { Content, ContentBody, ContentId, ContentMeta, ContentRef } from "./Content";
+import { ContentKind } from './ContentKind';
+import { MediaCropping } from './Media';
+import { MultiClock } from './Time';
+
+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 class Profile extends Content {
+
+  public static makeProfileId(userId:ContentId):ContentId {
+    return CachingHasher.makeMd5ContentId(userId + "-" + ContentKind.PROFILE);
+  }
+
+  public static create(userId:ContentId):Profile {
+    const now = MultiClock.now();
+    const profileId = Profile.makeProfileId(userId);
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : profileId,
+          is_head : true,
+          kind : ContentKind.PROFILE,
+          id : profileId,
+          owner : userId,
+          created_at : now,
+          updated_at : now
+        },
+        payload : {
+          username : null,
+          full_name : '',
+          avatar_media_ref : null as ContentRef,
+          avatar_cropping : null
+        }
+      }
+    ) as Profile;
+  }
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get payload():ProfilePayload {
+    this.checkDisposed("Profile.payload");
+    return this.doc.data.payload as ProfilePayload;
+  }
+
+  public get username():string {
+    this.checkDisposed("Profile.username");
+    return this.payload.username;
+  }
+  public setUsername(value:string) {
+    this.checkDisposed("Profile.setUsername");
+    if (this.username != value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'username' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get fullName():string {
+    this.checkDisposed("Profile.fullName");
+    return this.payload.full_name;
+  }
+  public setFullName(value:string) {
+    this.checkDisposed("Profile.setFullName");
+    if (this.fullName !== value) {
+      const batch = new BatchOperation(this);
+      batch.editPathText([ 'payload', 'full_name' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get avatarMediaRef():ContentId {
+    this.checkDisposed("Profile.avatarMediaRef");
+    return this.payload.avatar_media_ref;
+  }
+  public setAvatarMediaRef(value:ContentId) {
+    this.checkDisposed("Profile.setAvatarMediaRef");
+    if (this.avatarMediaRef !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'avatar_media_ref' ] , value);
+      batch.commit();
+    }
+  }
+
+  public get avatarCropping():MediaCropping {
+    this.checkDisposed("Profile.avatarCropping");
+    return this.payload.avatar_cropping;
+  }
+  public setAvatarCropping(value:MediaCropping) {
+    this.checkDisposed("Profile.setAvatarCropping");
+    if (this.avatarCropping !== value) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'avatar_cropping' ] , value);
+      batch.commit();
+    }
+  }
+
+  public static async findByUsername(username:string):Promise<Profile[]> {
+    const shareSync = ShareSyncFactory.get();
+    return shareSync.findAndAcquire(
+      ContentKind.PROFILE, { "payload.username" : username }
+    ) as Promise<Profile[]>;
+  }
+}