@shaxpir/duiduidui-models 1.3.2 → 1.3.4

package/lib/models/Model.ts

@@ -1,325 +0,0 @@
-import { Doc } from '@shaxpir/sharedb/lib/client';
-import { CompactDateTime, Dispatch, DispatchTopic, Struct } from '@shaxpir/shaxpir-common';
-import { ShareSync } from '../repo';
-import { ContentId, ContentMeta, ContentRef } from "./Content";
-import { ContentKind } from './ContentKind';
-import { ManifestBody } from './Manifest';
-import { PermissionType } from './Permissions';
-import { ChangeModel } from './ChangeModel';
-
-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/Operation.ts

@@ -1,205 +0,0 @@
-import { Doc } from '@shaxpir/sharedb/lib/client';
-import { MultiClock, MultiTime, Struct } from '@shaxpir/shaxpir-common';
-import { TextEditOps } from '../repo/TextEditOps';
-
-import * as Json1 from '../repo/PermissiveJson1';
-import { Model } from './Model';
-import { ShareSyncFactory } from '../repo';
-import { Content } from './Content';
-
-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 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/Permissions.ts

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

@@ -1,53 +0,0 @@
-import { CompactDateTime } from "@shaxpir/shaxpir-common";
-import { ContentId } from "./Content";
-import { ReviewLike } from "./Review";
-
-export interface PhraseExample {
-  id: number;
-  text: string;
-  pinyin: string;
-  translation: string;
-  learn_rank: number;
-  sense_rank: number;
-}
-
-export interface Phrase {
-  text: string;
-  hanzi_count: number;
-  sense_rank: number;
-  learn_rank: number;
-  pinyin: string;
-  pinyin_tokenized: string;
-  transliteration: string;
-  translation: string;
-  notes: string;
-  examples?: PhraseExample[];
-  components?: PhraseExample[];
-  keywords?: string[];
-  tags?: string[];
-}
-
-export interface BuiltInPhrase extends Phrase {
-  id: number;
-}
-
-export interface AnnotatedPhrase extends Phrase {
-
-  // Always populated. If this is a builtin entry, it will be `phrase-${phrase_id}`.
-  // If this is a user-specific entry, it will be `term-${term_id}`.
-  id: string;
-
-  // if this is populated, the Phrase comes from the built-in database
-  phrase_id?: number;
-
-  // if this is populated, then there is a user-specific Term model associated with this Phrase
-  content_id?: ContentId;
-
-  // All these fields come from the Term model, if it exists. If it doesn't exist, then these fields
-  // have default values (null for starred_at, numbers are zero, arrays are empty, etc.)
-  starred_at: CompactDateTime | null; 
-  alpha: number;
-  beta: number;
-  proficiency: number;
-  reviews: ReviewLike[];
-}