@shaxpir/duiduidui-models 1.0.1 → 1.2.0

package/lib/models/Progress.ts

@@ -0,0 +1,66 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { CachingHasher, CompactDateTime, MultiClock } from "@shaxpir/shaxpir-common";
+import { ShareSync, ShareSyncFactory } from '../repo';
+import { BayesianScore } from './BayesianScore';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { ContentKind } from './ContentKind';
+
+export interface PhraseProgress extends BayesianScore {
+  text:string;
+  sense_rank:number;
+  learn_rank: number;
+  last_review_utc?: CompactDateTime;
+}
+
+// The Proficiency model represents our assessment of the user's overall language level (user_rank)
+// as well as a map of phrases with their learn_rank, alpha, beta, and pr
+export interface ProgressPayload {
+  user_rank:number;
+  phrases:Record<string, PhraseProgress>;
+  cognitive_load:number;
+}
+
+export interface ProgressBody extends ContentBody {
+  meta:ContentMeta;
+  payload:ProgressPayload;
+}
+
+export class Progress extends Content {
+
+  public static makeProgressId(userId:ContentId):ContentId {
+    return CachingHasher.makeMd5Base62Hash(userId + "-" + ContentKind.PROGRESS) as ContentId;
+  }
+
+  public static create(
+    userId:ContentId
+  ):Progress {
+    const now = MultiClock.now();
+    const progressId = Progress.makeProgressId(userId);
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : progressId,
+          kind : ContentKind.PROGRESS,
+          id : progressId,
+          owner : userId,
+          created_at : now,
+          updated_at : now
+        },
+        payload : {
+          user_rank : 0,
+          phrases : {},
+          cognitive_load : 0
+        }
+      }
+    ) as Progress;
+  }
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get payload():ProgressPayload {
+    this.checkDisposed("Progress.payload");
+    return this.doc.data.payload as ProgressPayload;
+  }
+}

package/lib/models/Review.ts

@@ -0,0 +1,18 @@
+import { MultiTime } from "@shaxpir/shaxpir-common";
+
+export type ReviewResult  = 'FAIL' | 'HARD' | 'GOOD' | 'EASY';
+
+export interface ReviewLike {
+  result: ReviewResult;
+  at: MultiTime;
+}
+
+export interface Review extends ReviewLike {
+  text: string;
+  sense_rank: number;
+}
+
+export interface ImpliedReview extends ReviewLike {
+  context: string;
+  weight: number;
+}

package/lib/models/Session.ts

@@ -0,0 +1,140 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { CachingHasher, CompactDateTime, MultiClock, MultiTime, Time } from "@shaxpir/shaxpir-common";
+import { ShareSync, ShareSyncFactory } from '../repo';
+import { Content, ContentBody, ContentId, ContentMeta, ContentRef } from "./Content";
+import { ContentKind } from './ContentKind';
+import { Metric, MetricName } from './Metric';
+import { BatchOperation } from './Operation';
+import { Review } from './Review';
+import { Workspace } from './Workspace';
+
+
+export interface SessionPayload {
+  start:MultiTime;
+  end:MultiTime;
+  tz_offset:number;
+  device_id:ContentId;
+  duration_minutes:number;
+  reviews:Review[];
+}
+
+export interface SessionBody extends ContentBody {
+  meta:ContentMeta;
+  payload:SessionPayload;
+}
+
+export class Session extends Content {
+
+  public static makeSessionId(userId:ContentId):ContentId {
+    return CachingHasher.makeMd5Base62Hash(userId + "-" + ContentKind.SESSION) as ContentId;
+  }
+
+  public static makeSessionRef(userId:ContentId, at:MultiTime):ContentRef {
+    let sessionId = Session.makeSessionId(userId);
+    return `${sessionId}_${at.utc_time}` as ContentRef;
+  }
+
+  public static create(
+    userId:ContentId,
+    deviceId:ContentId
+  ):Session {
+
+    let now:MultiTime = MultiClock.now();
+    let sessionId = Session.makeSessionId(userId);
+    let sessionRef = Session.makeSessionRef(userId, now);
+
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : sessionRef,
+          kind : ContentKind.SESSION,
+          id : sessionId,
+          owner : userId,
+          created_at : now,
+          updated_at : now
+        },
+        payload : {
+          start : now,
+          end: now,
+          tz_offset : (new Date()).getTimezoneOffset(),
+          duration_minutes : 0,
+          device_id : deviceId,
+          reviews : []
+        }
+      }
+    ) as Session;
+  }
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get payload():SessionPayload {
+    this.checkDisposed("Session.payload");
+    return this.doc.data.payload;
+  }
+
+  public touch():void {
+    this.checkDisposed("Session.touch");
+
+    const batch = new BatchOperation(this);
+
+    let nowUtc:CompactDateTime = batch.at.utc_time;
+    let nowLocal:CompactDateTime = batch.at.local_time;
+    let minutes:number = Time.absDiffMinutes(nowUtc, this.start.utc_time);
+
+    batch.setPathValue([ 'payload', 'duration_minutes' ] , minutes);
+    batch.setPathValue([ 'payload', 'end', 'utc_time' ] , nowUtc);
+    batch.setPathValue([ 'payload', 'end', 'local_time' ] , nowLocal);
+
+    batch.commit();
+  }
+
+  public get start():MultiTime {
+    this.checkDisposed("Session.start");
+    return this.payload.start;
+  }
+
+  public get end():MultiTime {
+    this.checkDisposed("Session.end");
+    return this.payload.end;
+  }
+
+  public get tzOffset():number {
+    this.checkDisposed("Session.tzOffset");
+    return this.payload.tz_offset;
+  }
+
+  public get durationMinutes():number {
+    this.checkDisposed("Session.durationMinutes");
+    return this.payload.duration_minutes;
+  }
+
+  public get deviceId():ContentId {
+    this.checkDisposed("Session.deviceId");
+    return this.payload.device_id;
+  }
+
+  public async modelUpdated():Promise<void> {
+    this.checkDisposed("Session.modelUpdated");
+    await super.modelUpdated();
+    const shareSync = this.shareSync;
+    const sessionId = this.id;
+    const userId = this.owner;
+    const date = Time.dateFrom(this.createdAt.local_time);
+    const workspaceId = Workspace.makeWorkspaceId(userId);
+    const workspace = await this.shareSync.acquire(ContentKind.WORKSPACE, workspaceId) as Workspace;
+    const sessionsOnDate:Session[] = await workspace.acquireSessionsFromDate(sessionId, date);
+    workspace.release();
+    let minutesWritingOnDate:number = 0;
+    for (let i = 0, len = sessionsOnDate.length; i < len; i++) {
+      const sessionOnDate = sessionsOnDate[i] as Session;
+      minutesWritingOnDate += sessionOnDate.durationMinutes;
+      sessionOnDate.release();
+    }
+    const minutesWritingMetricId = Metric.makeMetricId(userId, MetricName.MINUTES_WRITING);
+    const minutesWritingMetric = await shareSync.acquire(ContentKind.METRIC, minutesWritingMetricId) as Metric;
+    minutesWritingMetric.setDateAmount(date, minutesWritingOnDate);
+    minutesWritingMetric.release();
+  }
+}

package/lib/models/Term.ts

@@ -0,0 +1,139 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { CachingHasher, CompactDateTime, MultiClock } from "@shaxpir/shaxpir-common";
+import { BayesianScore } from './BayesianScore';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { BuiltInPhrase, Phrase, PhraseExample } from './Phrase';
+import { ReviewLike } from "./Review";
+import { ContentKind } from './ContentKind';
+import { ShareSync, ShareSyncFactory } from '../repo';
+
+export interface TermPayload extends BayesianScore {
+
+  // These fields are always populated. Note that for non-builtin entries, the sense_rank is always zero
+  text: string;
+  sense_rank: number;
+  learn_rank: number;
+  phrase_id: number | null;
+  starred_at: CompactDateTime | null;
+
+  // these phrase fields are omitted for builtin entries (e.g., when phrase_id is not null)
+  // TODO: what about server-provided entries with numeric 'phrase_id' (e.g., if we split the *huge* local
+  // db into a smaller local db with all beginner content, and a bigger cloud db with more advanced content)
+  hanzi_count?: number;
+  pinyin?: string;
+  pinyin_tokenized?: string;
+  transliteration?: string;
+  translation?: string;
+  notes?: string;
+  components?: PhraseExample[];
+  examples?: PhraseExample[];
+  keywords?: string[];
+
+  // if this is a builtin entry, these tags overlay the builtin tags
+  tags: string[];
+
+  reviews: ReviewLike[];
+}
+
+export interface TermBody extends ContentBody {
+  meta:ContentMeta;
+  payload:TermPayload;
+}
+
+export class Term extends Content {
+
+  public static makeTermId(userId:ContentId, text:string, senseRank:number):ContentId {
+    return CachingHasher.makeMd5Base62Hash(`${ContentKind.TERM}-${userId}-${text}-${senseRank}`) as ContentId;
+  }
+
+  public static forUserPhrase(
+    userId:ContentId,
+    phrase:Phrase
+  ):Term {
+    const now = MultiClock.now();
+    const termId = CachingHasher.makeMd5Base62Hash(`${userId}-${phrase.text}-${phrase.sense_rank}`) as ContentId;
+    const initalAlpha = phrase.learn_rank < 100 ? 1 : 2;
+    const initalBeta = phrase.learn_rank < 100 ? 1 : 2;
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : termId,
+          kind : ContentKind.TERM,
+          id : termId,
+          owner : userId,
+          created_at : now,
+          updated_at : now
+        },
+        payload : {
+
+          phrase_id : null,
+          text : phrase.text,
+          sense_rank : phrase.sense_rank,
+          hanzi_count : phrase.hanzi_count,
+          learn_rank : phrase.learn_rank,
+          pinyin : phrase.pinyin,
+          pinyin_tokenized : phrase.pinyin_tokenized,
+          transliteration : phrase.transliteration,
+          translation : phrase.translation,
+          notes : phrase.notes,
+
+          examples : phrase.examples,
+          keywords : phrase.keywords,
+          tags : phrase.tags,
+
+          starred_at : null,
+
+          alpha: 1,
+          beta: 1,
+          theta: 0.5,
+          reviews: []
+        }
+      }
+    ) as Term;
+  }
+
+  public static forBuiltinPhrase(
+    userId:ContentId,
+    phrase:BuiltInPhrase
+  ):Term {
+    const now = MultiClock.now();
+    const termId = CachingHasher.makeMd5Base62Hash(`${userId}-${phrase.text}-${phrase.sense_rank}`) as ContentId;
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : termId,
+          kind : ContentKind.TERM,
+          id : termId,
+          owner : userId,
+          created_at : now,
+          updated_at : now
+        },
+        payload : {
+
+          text: phrase.text,
+          sense_rank: phrase.sense_rank,
+          learn_rank: phrase.learn_rank,
+          phrase_id : phrase.id,
+          starred_at: null,
+
+          tags : [],
+
+          alpha: 1,
+          beta: 1,
+          theta: 0.5,
+
+          reviews: []
+        }
+      }
+    ) as Term;
+  }
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+  }
+
+  public get payload():TermPayload {
+    this.checkDisposed("Term.payload");
+    return this.doc.data.payload as TermPayload;
+  }
+}

package/lib/models/User.ts

@@ -0,0 +1,97 @@
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { CompactDateTime, MultiClock, MultiTime } from '@shaxpir/shaxpir-common';
+import { ArrayView } from './ArrayView';
+import { Content, ContentId, ContentMeta } from "./Content";
+import { ContentKind } from './ContentKind';
+import { BatchOperation } from './Operation';
+import { ShareSync, ShareSyncFactory } from '../repo';
+
+export interface VerifiablePhone {
+  phone:string;
+  verified_at:CompactDateTime;
+}
+
+export interface VerifiableEmail {
+  email:string;
+  verified_at:CompactDateTime;
+}
+
+export interface UserPayload {
+  emails:VerifiableEmail[];
+  phones:VerifiablePhone[];
+}
+
+export interface UserBody {
+  meta:ContentMeta;
+  payload:UserPayload;
+}
+
+export class User extends Content {
+
+  private _emails:ArrayView<VerifiableEmail>;
+  private _phones:ArrayView<VerifiablePhone>;
+
+  constructor(doc:Doc, shouldAcquire:boolean, shareSync:ShareSync) {
+    super(doc, shouldAcquire, shareSync);
+    this._emails = new ArrayView<VerifiableEmail>(this, [ 'payload', 'emails' ]);
+    this._phones = new ArrayView<VerifiablePhone>(this, [ 'payload', 'phones' ]);
+  }
+
+  public get payload():UserPayload {
+    return this.doc.data.payload as UserPayload;
+  }
+
+  public static create(
+    userId:ContentId,
+    payload:UserPayload,
+    createdAt?:MultiTime
+  ):User {
+    // User creation always happens in UTC time
+    const now = MultiClock.utcNow();
+    // If the createdAt time is not provided, use the current time
+    createdAt ??= now;
+    return ShareSyncFactory.get().createContent(
+      {
+        meta : {
+          ref : userId,
+          kind : ContentKind.USER,
+          id : userId,
+          owner : userId,
+          created_at : createdAt,
+          updated_at : now
+        },
+        payload : payload
+      }
+    ) as User;
+  }
+
+  public get emails():ArrayView<VerifiableEmail> {
+    return this._emails;
+  }
+
+  public get phones():ArrayView<VerifiablePhone> {
+    return this._phones;
+  }
+
+  public verifyEmail(email:string, time:CompactDateTime):void {
+    const idx = this._emails.firstIndexWhere(e => e.email === email);
+    if (idx >= 0 && this._emails.get(idx).verified_at !== time) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'emails', idx, 'verified_at' ], time);
+      batch.commit();
+    } else if (idx < 0) {
+      this._emails.push({ email, verified_at: time });
+    }
+  }
+
+  public verifyPhone(phone:string, time:CompactDateTime):void {
+    const idx = this._phones.firstIndexWhere(p => p.phone === phone);
+    if (idx >= 0 && this._phones.get(idx).verified_at !== time) {
+      const batch = new BatchOperation(this);
+      batch.setPathValue([ 'payload', 'phones', idx, 'verified_at' ], time);
+      batch.commit();
+    } else if (idx < 0) {
+      this._phones.push({ phone, verified_at: time });
+    }
+  }
+}

package/lib/models/Workspace.ts

@@ -0,0 +1,129 @@
+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,4 +1,24 @@
 // created from 'create-ts-index'
 
-export * from './content';
-export * from './markup';
+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/ShareSync.ts

@@ -1,18 +1,16 @@
 import ShareDB, { Connection, Doc } from '@shaxpir/sharedb/lib/client';
+import { CompactDateTime } from '@shaxpir/shaxpir-common';
 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 { 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 { Encryption } from '../util/Encryption';
 import * as Json1 from './PermissiveJson1';
 
 const RichText = require('@shaxpir/rich-text');
@@ -376,11 +374,9 @@ export class ShareSync {
     if (kind === ContentKind.MANIFEST) {
       return new Manifest(doc, shouldAcquire, shareSync);
     } else if (kind === ContentKind.USER) {
-      return new ModernUser(doc, shouldAcquire, shareSync);
+      return new User(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);
     }

package/lib/repo/index.ts

@@ -3,3 +3,4 @@
 export * from './ConnectionListener';
 export * from './PermissiveJson1';
 export * from './ShareSync';
+export * from './TextEditOps';

package/lib/util/Encryption.ts

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

package/lib/util/index.ts

@@ -1,10 +1,4 @@
 // created from 'create-ts-index'
 
-export * from './Base62';
-export * from './CachingHasher';
-export * from './Dispatch';
 export * from './Encryption';
 export * from './Logging';
-export * from './NumberFormat';
-export * from './Struct';
-export * from './Tuples';