@shaxpir/duiduidui-models 1.3.2 → 1.3.4

package/lib/models/Workspace.ts

@@ -1,129 +0,0 @@
-import { Doc } from '@shaxpir/sharedb/lib/client';
-import { CachingHasher, CompactDate, CompactDateTime, MultiClock, MultiTime, Time } from "@shaxpir/shaxpir-common";
-import { ShareSync, ShareSyncFactory } from '../repo';
-import { ArrayView } from './ArrayView';
-import { Content, ContentBody, ContentId, ContentMeta, ContentRef } from "./Content";
-import { ContentKind } from './ContentKind';
-import { TagFilterConfig } from './Device';
-import { BatchOperation } from './Operation';
-import { Session } from './Session';
-
-export interface JourneyEntry {
-  key:string;
-  at_utc_time:CompactDateTime;
-}
-
-export interface WorkspacePayload {
-  devices:ContentId[];
-  sessions:MultiTime[];
-  journey?:{[key:string]:CompactDateTime};
-  global_tags?:TagFilterConfig;
-}
-
-export interface WorkspaceBody extends ContentBody {
-  meta:ContentMeta;
-  payload:WorkspacePayload;
-}
-
-export class Workspace extends Content {
-
-  private _devicesView:ArrayView<ContentId>;
-  private _sessionsView:ArrayView<MultiTime>;
-
-  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
-    super(doc, shouldAcquire, shareSync);
-    this._devicesView = new ArrayView<ContentId>(this, [ 'payload', 'devices' ]);
-    this._sessionsView = new ArrayView<MultiTime>(this, [ 'payload', 'sessions' ]);
-  }
-
-  public get payload():WorkspacePayload {
-    return this.doc.data.payload;
-  }
-
-  public static makeWorkspaceId(userId:ContentId):ContentId {
-    return CachingHasher.makeMd5Base62Hash(userId + "-" + ContentKind.WORKSPACE) as ContentId;
-  }
-
-  public static create(
-    userId:ContentId,
-    deviceId:ContentId
-  ):Workspace {
-    const now = MultiClock.now();
-    const workspaceId = Workspace.makeWorkspaceId(userId);
-    return ShareSyncFactory.get().createContent(
-      {
-        meta : {
-          ref : workspaceId,
-          kind : ContentKind.WORKSPACE,
-          id : workspaceId,
-          owner : userId,
-          created_at : now,
-          updated_at : now
-        },
-        payload : {
-          devices: [ deviceId ],
-          journey: {},
-          sessions: [] as MultiTime[]
-        }
-      }
-    ) as Workspace;
-  }
-
-  public get sessions():ArrayView<MultiTime> {
-    this.checkDisposed("Workspace.sessions");
-    return this._sessionsView;
-  }
-
-  // NOTE: As the user adds devices, we will always add new devices to the end of the array.
-  // So the most-recently-added device will always be at the end.
-  public get devices():ArrayView<ContentId> {
-    this.checkDisposed("Workspace.devices");
-    return this._devicesView;
-  }
-
-  public async acquireSessionsFromDate(
-    sessionId:ContentId,
-    localDate:CompactDate
-  ):Promise<Session[]> {
-    this.checkDisposed("Workspace.loadSessionsFromDate");
-    const shareSync = ShareSyncFactory.get();
-    const sessions:Session[] = [];
-    for (let i = 0, len = this.sessions.length; i < len; i++) {
-      const sessionCreatedAt:MultiTime = this.sessions.get(i);
-      const sessionCreatedLocalDate = Time.dateFrom(sessionCreatedAt.local_time);
-      if (localDate == sessionCreatedLocalDate) {
-        const sessionRef:ContentRef = Session.makeSessionRef(sessionId, sessionCreatedAt);
-        const session:Session = await shareSync.acquire(ContentKind.SESSION, sessionRef) as Session;
-        sessions.push(session);
-      }
-    }
-    return sessions;
-  }
-
-  public hasJourneyDate(journeyKey:string):boolean {
-    this.checkDisposed("Workspace.hasJourneyDate");
-    return this.payload.hasOwnProperty('journey') && this.payload.journey.hasOwnProperty(journeyKey);
-  }
-  public getJourneyDate(journeyKey:string):CompactDateTime {
-    this.checkDisposed("Workspace.getJourneyDate");
-    if (this.payload.hasOwnProperty('journey')) {
-      if (this.payload.journey.hasOwnProperty(journeyKey)) {
-        return this.payload.journey[journeyKey];
-      }
-    }
-    return null as CompactDateTime;
-  }
-  public setJourneyDate(journeyKey:string, journeyDate:CompactDateTime):void {
-    this.checkDisposed("Workspace.setJourneyDate");
-    const batch:BatchOperation = new BatchOperation(this);
-    if (this.payload.hasOwnProperty('journey')) {
-      batch.setPathValue([ 'payload', 'journey', journeyKey ], journeyDate);
-    } else {
-      const journey:any = {};
-      journey[journeyKey] = journeyDate;
-      batch.setPathValue([ 'payload', 'journey' ], journey);
-    }
-    batch.commit();
-  }
-
-}

package/lib/models/index.ts

@@ -1,24 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './ArrayView';
-export * from './BayesianScore';
-export * from './ChangeModel';
-export * from './Content';
-export * from './ContentKind';
-export * from './Device';
-export * from './GeoLocation';
-export * from './Hanzi';
-export * from './Manifest';
-export * from './Media';
-export * from './Metric';
-export * from './Model';
-export * from './Operation';
-export * from './Permissions';
-export * from './Phrase';
-export * from './Profile';
-export * from './Progress';
-export * from './Review';
-export * from './Session';
-export * from './Term';
-export * from './User';
-export * from './Workspace';

package/lib/repo/ConnectionListener.ts

@@ -1,25 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,383 +0,0 @@
-import ShareDB, { Connection, Doc } from '@shaxpir/sharedb/lib/client';
-import { Base62, CompactDateTime } from '@shaxpir/shaxpir-common';
-import ReconnectingWebSocket from 'reconnecting-websocket';
-import { Model, Profile } from '../models';
-import { Content, ContentBody, ContentId, ContentRef } from '../models/Content';
-import { ContentKind } from '../models/ContentKind';
-import { Device } from '../models/Device';
-import { Manifest, ManifestBody } from '../models/Manifest';
-import { User } from '../models/User';
-import { Encryption } from '../util/Encryption';
-import { ConnectionListener } from './ConnectionListener';
-
-// Register the ShareDB types
-import * as Json1 from './PermissiveJson1';
-
-const UnicodeText = require('ot-text-unicode');
-
-ShareDB.types.register(Json1.type);
-ShareDB.types.register(UnicodeText.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(Base62.CHARS, 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 User(doc, shouldAcquire, shareSync);
-    } else  if (kind === ContentKind.DEVICE) {
-      return new Device(doc, shouldAcquire, shareSync);
-    } else if (kind === ContentKind.PROFILE) {
-      return new Profile(doc, shouldAcquire, shareSync);
-    }
-    throw new Error(`can't wrap content ${kind}/${doc.id}`);
-  }
-
-}

package/lib/repo/TextEditOps.ts

@@ -1,50 +0,0 @@
-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/index.ts

@@ -1,6 +0,0 @@
-// created from 'create-ts-index'
-
-export * from './ConnectionListener';
-export * from './PermissiveJson1';
-export * from './ShareSync';
-export * from './TextEditOps';

package/lib/util/Encryption.ts

@@ -1,5 +0,0 @@
-export interface Encryption {
-  getRandomString(chars:string, length:number):string;
-  encrypt(cleartext:string, key:string):string;
-  decrypt(cyphertext:string, key:string):string;
-}