@shaxpir/duiduidui-models 1.0.0

package/lib/models/markup/Operation.ts

@@ -0,0 +1,215 @@
+import { Op as DeltaOp } from "@shaxpir/quill-delta";
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSyncFactory } from '../../repo/ShareSync';
+import { Struct } from '../../util/Struct';
+import { Content } from '../content/Content';
+import { Model } from '../content/Model';
+import { MultiClock, MultiTime } from '../content/Time';
+import { TextEditOps } from './TextEditOps';
+
+import * as Json1 from '../../repo/PermissiveJson1';
+
+const RichText = require('@shaxpir/rich-text');
+const UnicodeText = require('ot-text-unicode');
+
+export type JsonPathElement = string | number;
+export type JsonPath = JsonPathElement[];
+
+export interface PathVal {
+  path:JsonPath,
+  val:any
+};
+
+export class JsonPathSelect {
+
+  public static getValueAtPath(doc:Doc, path:JsonPath):any {
+    let currentNode = doc.data;
+    for (let i = 0; i < path.length; i++) {
+      let pathElement:JsonPathElement = path[i];
+      if (currentNode !== undefined && currentNode !== null) {
+        if (typeof(pathElement) === "string" && currentNode.hasOwnProperty(pathElement)) {
+          currentNode = currentNode[pathElement];
+        } else if (typeof(pathElement) === "number" && currentNode.length > pathElement) {
+          currentNode = currentNode[pathElement];
+        } else  {
+          return undefined;
+        }
+      } else {
+        console.error(`no value at path ${JSON.stringify(path)} at index ${i} in object '${doc.collection}/${doc.id}' with value ${JSON.stringify(doc.data)}`);
+        break;
+      }
+    }
+    return currentNode;
+  }
+}
+
+export class BatchOperation {
+
+  private model:Model;
+  private time:MultiTime;
+  private ops:any[];
+
+  // TODO: maybe just use the timestamp on the Content?
+  constructor(model:Model, time?:MultiTime) {
+    if (model.isForbidden) {
+      throw new Error(`cannot create a BatchOperation on forbidden model: ${model.compoundKey}`);
+    }
+    this.model = model;
+    if (time) {
+      this.time = time;
+    } else {
+      this.time = MultiClock.now()
+    }
+    this.ops = [];
+  }
+
+  public get at():MultiTime {
+    return Struct.clone(this.time);
+  }
+
+  public hasOps():boolean {
+    return this.ops.length > 0;
+  }
+
+  public editPathText(
+    path:JsonPath,
+    value:string
+  ):void {
+    const prevValue = JsonPathSelect.getValueAtPath(this.model.doc, path);
+    if (prevValue !== undefined) {
+      // If we're trying to edit a text value, but the previous value is null, then the
+      // 'editOp' will throw an exception. So we need to use a 'replaceOp' instead.
+      if (prevValue === null) {
+        this.ops.push(Json1.replaceOp(path, prevValue, value));
+      } else if (!Struct.equals(prevValue, value)) {
+        const textEditOps = TextEditOps.between(prevValue, value);
+        this.ops.push(Json1.editOp(path, UnicodeText.type, textEditOps));
+      }
+    } else {
+      this.ops.push(Json1.insertOp(path, value));
+    }
+  }
+
+  public setPathValue(
+    path:JsonPath,
+    value:any
+  ):void {
+    const prevValue = JsonPathSelect.getValueAtPath(this.model.doc, path);
+    if (prevValue !== undefined) {
+      if (!Struct.equals(prevValue, value)) {
+        this.ops.push(Json1.replaceOp(path, prevValue, value));
+      }
+    } else {
+      this.ops.push(Json1.insertOp(path, value));
+    }
+  }
+
+  public move(
+    originPath:JsonPath,
+    destinationPath:JsonPath
+  ):void {
+    this.ops.push(Json1.moveOp(originPath, destinationPath));
+  }
+
+  public insertIntoArray(
+    arrayPath:JsonPath,
+    index:number,
+    value:any
+  ):void {
+    let array = JsonPathSelect.getValueAtPath(this.model.doc, arrayPath);
+    if (array === undefined) {
+      this.ops.push(Json1.insertOp(arrayPath, [ value ]));
+    } else {
+      if (!Array.isArray(array)) {
+        throw new Error(`path '${JSON.stringify(arrayPath)}' does not refer to an array: ${JSON.stringify(this.model.doc.data)}`);
+      }
+      const path = Struct.clone(arrayPath);
+      path.push(index);
+      this.ops.push(Json1.insertOp(path, value));
+    }
+  }
+
+  public unshiftIntoArray(
+    path:JsonPath,
+    value:any
+  ):void {
+    path = Struct.clone(path);
+    let array = JsonPathSelect.getValueAtPath(this.model.doc, path);
+    if (array === undefined) {
+      this.ops.push(Json1.insertOp(path, [ value ]));
+    } else {
+      if (!Array.isArray(array)) {
+        throw new Error(`path '${JSON.stringify(path)}' does not refer to an array: ${JSON.stringify(this.model.doc.data)}`);
+      }
+      path.push(0);
+      this.ops.push(Json1.insertOp(path, value));
+    }
+  }
+
+  public pushIntoArray(
+    path:JsonPath,
+    value:any
+  ):void {
+    path = Struct.clone(path);
+    let array = JsonPathSelect.getValueAtPath(this.model.doc, path);
+    if (array === undefined) {
+      this.ops.push(Json1.insertOp(path, [ value ]));
+    } else {
+      if (!Array.isArray(array)) {
+        throw new Error(`path '${JSON.stringify(path)}' does not refer to an array: ${JSON.stringify(this.model.doc.data)}`);
+      }
+      path.push(array.length);
+      this.ops.push(Json1.insertOp(path, value));
+    }
+  }
+
+  public removeValueAtPath(
+    path:JsonPath
+  ):void {
+    let prevValue:any = JsonPathSelect.getValueAtPath(this.model.doc, path);
+    if (prevValue !== undefined) {
+      this.ops.push(Json1.removeOp(path, prevValue));
+    }
+  }
+
+  public replaceValueAtPath(
+    path:JsonPath,
+    value:any
+  ):void {
+    let prevValue:any = JsonPathSelect.getValueAtPath(this.model.doc, path);
+    if (prevValue !== undefined) {
+      this.ops.push(Json1.replaceOp(path, prevValue, value));
+    } else {
+      this.ops.push(Json1.insertOp(path, value));
+    }
+  }
+
+  public applyRichText(
+    path:JsonPath,
+    deltaOps:DeltaOp[]
+  ):void {
+    this.ops.push(Json1.editOp(path, RichText.type, deltaOps));
+  }
+
+  public commit():void {
+    const batch = this;
+    if (batch.ops.length > 0) {
+      // Update the timestamp of the model (omitting local-time for Manifest objects (which are not Content)).
+      this.setPathValue([ 'meta', 'updated_at', 'utc_time' ], batch.time.utc_time);
+      if (batch.model instanceof Content) {
+        this.setPathValue([ 'meta', 'updated_at', 'local_time' ], batch.time.local_time);
+      }
+      const reduced = batch.ops.reduce(Json1.type.compose, null);
+      const shareSync = ShareSyncFactory.get();
+      batch.model.doc.submitOp(reduced, (error:any) => {
+        if (error) {
+          shareSync.onOperationError(error);
+        }
+      });
+      if (batch.model instanceof Content) {
+        (batch.model as Content).modelUpdated();
+      }
+    }
+  }
+
+}

package/lib/models/markup/TextEditOps.ts

@@ -0,0 +1,50 @@
+import { getPatch, Patch, PatchItem } from "fast-array-diff";
+
+export type TextEditRetainOp = number;
+export type TextEditInsertOp = string;
+export interface TextEditDeleteOp {
+  d:number|String
+};
+
+export type TextEditOp = TextEditRetainOp | TextEditInsertOp | TextEditDeleteOp;
+
+export class TextEditOps {
+  public static between(before:string, after:string):TextEditOp[] {
+    let ops = [] as TextEditOp[];
+    if (before.length === 0 && after.length === 0) {
+      return ops;
+    } else if (before.length === 0) {
+      ops.push(after);
+    } else if (after.length === 0) {
+      ops.push({ d : before });
+    } else {
+      // First, we split the string into unicode characters. We use this method of splitting (regex with 'u' flag)
+      // in order to split on actual unicode characters, rather than merely on bytes. Even the String.charAt()
+      // function can't be trusted to handle multi-byte characters correctly (e.g., emojis). For more info, read here:
+      // https://stackoverflow.com/questions/35223206/how-to-split-unicode-string-to-characters-in-javascript
+      const beforeChars = before.match(/./ug);
+      const afterChars = after.match(/./ug);
+      // Create a diff-patch between these two character arrays.
+      let patch:Patch<string> = getPatch(beforeChars, afterChars);
+      // console.log(JSON.stringify(patch));
+      let cursor = 0;
+      // Iterate through the patch items, and use them to construct OT operations, in the format expected by ShareDB.
+      for (let i = 0; i < patch.length; i++) {
+        const item:PatchItem<string> = patch[i];
+        const chunk = item.items.join('');
+        if (item.oldPos > cursor) {
+          const charsToRetain = item.oldPos - cursor;
+          ops.push(charsToRetain);
+          cursor += charsToRetain;
+        }
+        if (item.type == 'add') {
+          ops.push(chunk);
+        } else if (item.type == 'remove') {
+          ops.push({ d : chunk });
+          cursor += chunk.length;
+        }
+      }
+    }
+    return ops;
+  }
+}

package/lib/repo/ConnectionListener.ts

@@ -0,0 +1,25 @@
+export abstract class ConnectionListener {
+
+    private _onSocketEvent:(eventName:string, details:any) => void;
+
+    public constructor(
+      onSocketEvent:(eventName:string, details:any) => void
+    ) {
+      this._onSocketEvent = onSocketEvent;
+    }
+
+    public onSocketEvent(eventName:string, details:any):void {
+      this._onSocketEvent(eventName, details);
+    }
+  }
+
+  export class NoOpConnectionListener extends ConnectionListener {
+
+    public constructor() {
+      super(NoOpConnectionListener.onSocketEvent);
+    }
+
+    public static onSocketEvent(eventName:string, details:any):void {
+      // DO NOTHING
+    }
+  }

package/lib/repo/PermissiveJson1.ts

@@ -0,0 +1,14 @@
+import * as Json1 from 'ot-json1';
+
+export * from 'ot-json1';
+
+// Export a version of ot-json1 that allows various conflicts
+export const type = {
+  ...Json1.type.typeAllowingConflictsPred( (conflict) => {
+    return (
+         Json1.type.DROP_COLLISION === conflict.type
+      || Json1.type.BLACKHOLE === conflict.type
+      || Json1.type.RM_UNEXPECTED_CONTENT === conflict.type
+    )
+  })
+};

package/lib/repo/ShareSync.ts

@@ -0,0 +1,390 @@
+import ShareDB, { Connection, Doc } from '@shaxpir/sharedb/lib/client';
+import ReconnectingWebSocket from 'reconnecting-websocket';
+import { Billing } from "../models/content/Billing";
+import { Content, ContentBody, ContentId, ContentRef } from '../models/content/Content';
+import { ContentKind } from "../models/content/ContentKind";
+import { Device } from '../models/content/Device';
+import { Manifest, ManifestBody } from '../models/content/Manifest';
+import { Model } from '../models/content/Model';
+import { Profile } from '../models/content/Profile';
+import { CompactDateTime } from '../models/content/Time';
+import { ModernUser } from '../models/content/User';
+import { ConnectionListener } from './ConnectionListener';
+
+// Register the ShareDB types
+import { Encryption } from '../util/Encryption';
+import * as Json1 from './PermissiveJson1';
+
+const RichText = require('@shaxpir/rich-text');
+const UnicodeText = require('ot-text-unicode');
+
+ShareDB.types.register(Json1.type);
+ShareDB.types.register(RichText.type);
+ShareDB.types.register(UnicodeText.type);
+
+Json1.type.registerSubtype(RichText.type);
+Json1.type.registerSubtype(UnicodeText.type);
+
+export enum ShareSyncDisposalStrategy {
+  UNSUBSCRIBE,
+  DESTROY,
+  NOTHING
+}
+
+export interface ShareSyncOptions {
+  namespace:string;
+  debug:boolean;
+  disposalStrategy:ShareSyncDisposalStrategy;
+  connectionListener:ConnectionListener;
+  urlProvider:() => Promise<string>;
+  opErrorCallback:(error?:any) => void;
+  onReadyCallback?:() => void;
+  pingInterval?:number;
+  encryptionKey?:string;
+  webSocketConstructor?:any;
+}
+
+export class ShareSyncFactory {
+
+  private static INSTANCE:ShareSync = null;
+
+  public static initialize(
+    encryption:Encryption,
+    options:ShareSyncOptions
+  ) {
+    ShareSyncFactory.INSTANCE = new ShareSync(encryption, options);
+  }
+
+  public static get():ShareSync {
+    return ShareSyncFactory.INSTANCE;
+  }
+}
+
+export class ShareSync {
+
+  private _debug:boolean;
+  private _disposalStrategy:ShareSyncDisposalStrategy;
+  private _opErrorCallback:(error?:any) => void;
+
+  private _modelCache:Map<string, Model> = new Map();
+
+  private _encryption:Encryption;
+  private _hasDurableStore:boolean;
+  private _useDurableStoreEncryption:boolean;
+  private _durableStoreEncryptionKey:string;
+  private _socketIsOpen:boolean;
+  private _socket:ReconnectingWebSocket;
+  private _connection:Connection;
+  private _listener:ConnectionListener;
+
+  public constructor(
+    encryption:Encryption,
+    options:ShareSyncOptions
+  ) {
+    const shareSync = this;
+    shareSync._encryption = encryption;
+    shareSync._debug = options.debug;
+    shareSync._disposalStrategy = options.disposalStrategy;
+    shareSync._opErrorCallback = options.opErrorCallback;
+    shareSync._hasDurableStore = options.namespace && options.namespace.length > 0;
+    shareSync._useDurableStoreEncryption = options.encryptionKey && options.encryptionKey.length > 0;
+    shareSync._durableStoreEncryptionKey = options.encryptionKey;
+
+    // Create and configure the socket.
+    if (options.webSocketConstructor) {
+      shareSync._socket = new ReconnectingWebSocket(options.urlProvider, [], { WebSocket : options.webSocketConstructor });
+    } else {
+      shareSync._socket = new ReconnectingWebSocket(options.urlProvider);
+    }
+
+    function updateSocketIsOpen() {
+      shareSync._socketIsOpen = shareSync._socket.readyState === ReconnectingWebSocket.OPEN;
+    }
+
+    // The listener should forward all events: open, message, close, error
+    shareSync._listener = options.connectionListener;
+    shareSync._socket.addEventListener('open', (event:Event) => {
+      updateSocketIsOpen();
+      shareSync._listener.onSocketEvent('open', event);
+    });
+    shareSync._socket.addEventListener('message', (event:Event) => {
+      updateSocketIsOpen();
+      shareSync._listener.onSocketEvent('message', event);
+    });
+    shareSync._socket.addEventListener('close', (event:CloseEvent) => {
+      updateSocketIsOpen();
+      shareSync._listener.onSocketEvent('close', event);
+    });
+    shareSync._socket.addEventListener('error', (event:ErrorEvent) => {
+      updateSocketIsOpen();
+      shareSync._listener.onSocketEvent('error', event);
+    });
+
+    // Create the ShareDB connection from the socket
+    if (shareSync._hasDurableStore) {
+      shareSync._connection = new Connection(
+        shareSync._socket,
+        {
+          durableStore : {
+            namespace : options.namespace,
+            debug : options.debug,
+            useEncryption : shareSync._useDurableStoreEncryption,
+            encryptionCallback : (plaintext:string):string => {
+              return encryption.encrypt(plaintext, shareSync._durableStoreEncryptionKey);
+            },
+            decryptionCallback : (cyphertext:string):string => {
+              return encryption.decrypt(cyphertext, shareSync._durableStoreEncryptionKey);
+            },
+            onReadyCallback : options.onReadyCallback,
+            opErrorCallback : options.opErrorCallback,
+            // Use the 'docData.meta.updated_at.utc_time' field (which is universal to all Model subclasses) as the 'version'
+            // identifier that we use when determining if the doc in the DurableStore is up-to-date. This field won't yet
+            // exist when the doc is newly created (since the 'doc.data' will be undefined), so in that case, we'll return
+            // null as the version string, which will work correctly with the versioning semantics of the DurableStore.
+            extVersionDecoder : (docData:any):string => {
+              if (
+                docData &&
+                docData.meta &&
+                docData.meta.updated_at &&
+                docData.meta.updated_at.utc_time
+              ) {
+                return docData.meta.updated_at.utc_time;
+              }
+              return null;
+            }
+          }
+        }
+      );
+    } else {
+      shareSync._connection = new Connection(shareSync._socket);
+    }
+
+    shareSync._connection.on('error', (err:any) => {
+      console.error(`ShareSync connection error: ${err}\n  Error code: ${err.code}\n  Error message: ${err.message}\n  Error stack: ${err.stack}\n`);
+    });
+
+    // If the client provided a pingInterval option, then set up a periodic ping the
+    // connection alive. Clients who don't provide this option will send pings.
+    if (options.pingInterval && typeof(options.pingInterval) === 'number') {
+      setInterval(() => { shareSync.ping() }, options.pingInterval);
+    }
+
+    if (!shareSync._hasDurableStore && !!options.onReadyCallback) {
+      // If there is no DurableStore, then we can call the onReadyCallback now. However,
+      // we have to use setTimeout to invoke it, because the callback will probably want
+      // to retrieve the ShareSync instance from the factory, and because the constructor
+      // hasn't actually finished yet, the INSTANCE pointer hasn't quite been assigned yet.
+      setTimeout(options.onReadyCallback, 1);
+    }
+  }
+
+  public isDebug():boolean {
+    return this._debug;
+  }
+
+  public isOnline():boolean {
+    return this._socketIsOpen;
+  }
+
+  public ping():void {
+    try {
+      (this._connection as any).ping();
+    } catch (error) {
+      // Ignore the error. We aren't directly concerned with the connection status.
+      // We just need to provoke the connection to attempt sending a ping message,
+      // so that if it fails to send that message, our normal socket-event listeners
+      // will notice the change in status, and trigger our downstream logic for
+      // displaying the offline status to the user.
+    }
+  }
+
+  public makeContentId():ContentId {
+    return this._encryption.getRandomString(Content.ID_LENGTH) as ContentId;
+  }
+
+  public async exists(userId:ContentId, kind:ContentKind, ref:ContentRef):Promise<boolean> {
+    // Check to see if this item exists in the model cache
+    const compoundKey = `${kind}/${ref}`;
+    if (this._modelCache.has(compoundKey)) {
+      const model = this._modelCache.get(compoundKey);
+      return model.exists();
+    }
+    // Check to see if this item exists in the durable-store inventory
+    const existsInDurableStore = this._connection.isDocInInventory(kind, ref as string);
+    if (existsInDurableStore) {
+      return true;
+    }
+    // Check to see if this item is recorded in the manifest.
+    const manifestId:ContentId = Manifest.makeManifestId(userId);
+    const manifest = this.load(ContentKind.MANIFEST, manifestId) as Manifest;
+    await manifest.acquire();
+    const existsInManifest = manifest.doesContentExist(kind, ref);
+    manifest.release();
+    if (existsInManifest) {
+      return true;
+    }
+    // Fetch this model from from the remote ShareDB server.
+    const model = this.load(kind, ref);
+    await model.acquire();
+    const exists = model.exists();
+    model.release();
+    return exists;
+  }
+
+  public createManifest(body:ManifestBody):Manifest {
+    const shareSync = this;
+    // Create or retrieve the doc object for this manifest model.
+    const manifestId = Manifest.makeManifestId(body.meta.owner);
+    const doc = shareSync._connection.get(ContentKind.MANIFEST, manifestId);
+    doc.create(
+      body, Json1.type.uri, (createErr:any) => {
+        if (createErr) {
+          console.log(`error creating manifest ${manifestId}: ${createErr}`);
+        }
+      }
+    );
+    shareSync.isDebug() && console.log(`created manifest ${manifestId}`);
+    const manifest = shareSync.wrap(ContentKind.MANIFEST, doc, true) as Manifest;
+    this._modelCache.set(manifest.compoundKey, manifest);
+    return manifest;
+  }
+
+  public createContent(body:ContentBody):Content {
+    const shareSync = this;
+    // Create or retrieve the doc object for this content model.
+    const compoundKey = `${body.meta.kind}/${body.meta.ref}`;
+    const doc = shareSync._connection.get(body.meta.kind, body.meta.ref);
+    doc.create(
+      body, Json1.type.uri, (createErr:any) => {
+        if (createErr) {
+          console.log(`error creating content ${compoundKey}: ${createErr}`);
+        }
+      }
+    );
+    shareSync.isDebug() && console.log(`created content ${compoundKey}`);
+    const content = shareSync.wrap(body.meta.kind, doc, true) as Content;
+    this._modelCache.set(compoundKey, content);
+    this.updateManifestForContent(content);
+    return content;
+  }
+
+  public async acquire(kind:ContentKind, id:ContentId, timestamp?:CompactDateTime):Promise<Model> {
+    let model = this.load(kind, id);
+    if (timestamp) {
+      model = await model.acquire(timestamp);
+    } else  {
+      model = await model.acquire();
+    }
+    return model;
+  }
+
+  public load(kind:ContentKind, id:ContentId):Model {
+    // First, try getting the content from the cache
+    const compoundKey = `${kind}/${id}`;
+    if (this._modelCache.has(compoundKey)) {
+      return this._modelCache.get(compoundKey);
+    }
+    // If not in the cache, get the model doc from the connection.
+    // Then wrap it and put it in the cache for future reference.
+    const doc = this._connection.get(kind, id);
+    const model = this.wrap(kind, doc, false);
+    this._modelCache.set(compoundKey, model);
+    return model;
+  }
+
+  public async findAndAcquire(kind:ContentKind, query:any):Promise<Content[]> {
+    const shareSync = this;
+    return new Promise((resolve, reject) => {
+      shareSync._connection.createFetchQuery(kind, query, {}, (error, results) => {
+        if (error) {
+          const message = `query error (${error.code}): ${error.message}`;
+          console.log(message);
+          reject(message);
+          return;
+        }
+        const contents:Content[] = [];
+        for (let i = 0; i < results.length; i++) {
+          const doc:Doc = results[i];
+          if (doc.type) {
+            const compoundKey = `${doc.collection}/${doc.id}`;
+            if (shareSync._modelCache.has(compoundKey)) {
+              const content = shareSync._modelCache.get(compoundKey) as Content;
+              content.acquire();
+              contents.push(content);
+            } else {
+              // NOTE: the wrap method calls 'acquire' on the model, so we don't need to do it here.
+              const content = shareSync.wrap(kind, doc, true) as Content;
+              shareSync._modelCache.set(compoundKey, content);
+              contents.push(content);
+            }
+          }
+        }
+        resolve(contents);
+      });
+    });
+  }
+
+  public async updateManifestForContent(content:Content):Promise<void> {
+    // TODO: how will we handle manifest updates in a sharing scenario?
+    // If user A owns a book, and gives B permission to edit that book, and then B makes some
+    // changes to the book. We want B to be able to update their own manifest, but not the
+    // manifest belonging to A. But then how will A know that the book has been updated?
+    this.isDebug() && console.log(`updating manifest for content: ${content.compoundKey}`);
+    content.acquire();
+    const manifestId:ContentId = Manifest.makeManifestId(content.owner);
+    const manifest = this.load(ContentKind.MANIFEST, manifestId) as Manifest;
+    await manifest.acquire();
+    manifest.update(content);
+    manifest.release();
+    content.release();
+  }
+
+  public forEachOfflinePendingModel(
+    callback:(kind:ContentKind, id:ContentId) => void
+  ):void {
+    this._connection.forEachPendingDocCollectionId(callback);
+  }
+
+  public isDocInInventory(kind:ContentKind, ref:ContentRef, minVersion?:CompactDateTime):boolean {
+    // Check to see if this doc is in the DurableStore inventory. And if so, does it have a `minVersion`
+    // greater than or equal to the supplied `minVersion`. In all shaxpir models, the `minVersion` is
+    // extracted from the `meta.updated_at.utc_time` field.
+    return this._connection.isDocInInventory(kind as string, ref as string, minVersion as string);
+  }
+
+  public dispose(model:Model):void {
+    if (this._disposalStrategy == ShareSyncDisposalStrategy.NOTHING) {
+      return;
+    }
+    // Remove the model from the cache
+    const compoundKey = model.compoundKey;
+    this._modelCache.delete(compoundKey);
+    // Dispose of the model's doc object
+    if (this._disposalStrategy == ShareSyncDisposalStrategy.DESTROY) {
+      model.disposeAndDestroy();
+    } else if (this._disposalStrategy == ShareSyncDisposalStrategy.UNSUBSCRIBE) {
+      model.disposeAndUnsubscribe();
+    }
+  }
+
+  public onOperationError(opError:any):void {
+    this._opErrorCallback && this._opErrorCallback(opError);
+  }
+
+  private wrap(kind:ContentKind, doc:Doc, shouldAcquire:boolean):Model {
+    const shareSync = this;
+    if (kind === ContentKind.MANIFEST) {
+      return new Manifest(doc, shouldAcquire, shareSync);
+    } else if (kind === ContentKind.USER) {
+      return new ModernUser(doc, shouldAcquire, shareSync);
+    } else  if (kind === ContentKind.DEVICE) {
+      return new Device(doc, shouldAcquire, shareSync);
+    } else if (kind === ContentKind.BILLING) {
+      return new Billing(doc, shouldAcquire, shareSync);
+    } else if (kind === ContentKind.PROFILE) {
+      return new Profile(doc, shouldAcquire, shareSync);
+    }
+    throw new Error(`can't wrap content ${kind}/${doc.id}`);
+  }
+
+}