Migrate and drop old person database

Signed-off-by: Jack Works <[email protected]>

src/components/InjectedComponents/AddToKeyStore.tsx

@@ -3,10 +3,11 @@ import AsyncComponent from '../../utils/components/AsyncComponent'
 import { AdditionalContent } from './AdditionalPostContent'
 import Services from '../../extension/service'
 import { geti18nString } from '../../utils/i18n'
+import { PersonIdentifier } from '../../database/type'
 
 interface Props {
     provePost: string
-    postBy: string
+    postBy: PersonIdentifier
 }
 export function AddToKeyStore({ provePost, postBy }: Props) {
     return (

src/components/InjectedComponents/DecryptedPost.tsx

@@ -8,6 +8,7 @@ import { geti18nString } from '../../utils/i18n'
 import { makeStyles } from '@material-ui/styles'
 import { Link, Box } from '@material-ui/core'
 import { Person } from '../../database'
+import { PersonIdentifier } from '../../database/type'
 
 interface DecryptPostSuccessProps {
     data: { signatureVerifyResult: boolean; content: string }
@@ -64,8 +65,8 @@ function DecryptPostFailed({ error }: { error: Error }) {
 }
 
 interface DecryptPostProps {
-    postBy: string
-    whoAmI: string
+    postBy: PersonIdentifier
+    whoAmI: PersonIdentifier
     encryptedText: string
     people: Person[]
     alreadySelectedPreviously: Person[]

src/database/migrate/index.ts

@@ -1,5 +1,7 @@
 import avatar from './old.avatar.1'
 import localKeys from './old.localKeys.1'
+import keys from './old.keystore.1'
 
 avatar()
 localKeys()
+keys()

src/database/migrate/old.keystore.1.ts

@@ -0,0 +1,38 @@
+import { deleteDB } from 'idb/with-async-ittr'
+import * as People from '../people'
+import { queryPeopleCryptoKey } from '../../key-management/keystore-db'
+import { PersonIdentifier } from '../type'
+
+/**
+ * ! Migrate old database into new one.
+ * ! Scheduled to remove it after May/31/2019
+ */
+export default async function migrate() {
+    if (indexedDB.databases) {
+        const dbs = await indexedDB.databases()
+        if (!dbs.find(x => x.name === 'maskbook-keystore-demo-v2')) return
+    }
+    // tslint:disable-next-line: deprecation
+    const wait = (await queryPeopleCryptoKey()).map(record => {
+        if (record.username === '$self')
+            return People.storeMyIdentityDB({
+                // TODO: Need to update later !
+                identifier: new PersonIdentifier('facebook.com', '$self'),
+                groups: [],
+                relation: [],
+                relationLastCheckTime: new Date(),
+                publicKey: record.publicKey,
+                privateKey: record.privateKey!,
+            })
+        else
+            return People.storeNewPersonDB({
+                identifier: new PersonIdentifier('facebook.com', record.username),
+                publicKey: record.publicKey,
+                groups: [],
+                relation: [],
+                relationLastCheckTime: new Date('May 1 2019'),
+            })
+    })
+    await Promise.all(wait)
+    await deleteDB('maskbook-keystore-demo-v2')
+}

src/database/type.ts

@@ -60,13 +60,13 @@ export class GroupIdentifier extends Identifier {
         return new GroupIdentifier(network, groupId, virtual === 'virtual')
     }
 }
-export class PostIdentifier extends Identifier {
+export class PostIdentifier<T extends Identifier = Identifier> extends Identifier {
     readonly type = 'post'
     /**
      * If identifier is a PostIdentifier, that means this post is binded with other post in some kind
      * e.g. a comment.
      */
-    constructor(public identifier: Identifier, public postId: string) {
+    constructor(public identifier: T, public postId: string) {
         super()
         noSlash(postId)
     }

src/extension/content-script/injections/Posts.tsx

@@ -8,14 +8,14 @@ import { usePeople } from '../../../components/DataSource/PeopleRef'
 import { useAsync } from '../../../utils/components/AsyncComponent'
 import { deconstructPayload } from '../../../utils/type-transform/Payload'
 import Services from '../../service'
-import { PersonIdentifier } from '../../../database/type'
+import { PersonIdentifier, PostIdentifier } from '../../../database/type'
 import { Person } from '../../../database'
 
 const posts = new LiveSelector().querySelectorAll<HTMLDivElement>('.userContent, .userContent+*+div>div>div>div>div')
 
 interface PostInspectorProps {
     post: string
-    postBy: string
+    postBy: PersonIdentifier
     postId: string
     needZip(): void
 }
@@ -27,11 +27,11 @@ function PostInspector(props: PostInspectorProps) {
     }
     if (type.encryptedPost) {
         props.needZip()
-        const whoAmI = getUsername()!
+        const whoAmI = new PersonIdentifier('facebook.com', getUsername()!)
         const people = usePeople()
         const [alreadySelectedPreviously, setAlreadySelectedPreviously] = useState<Person[]>([])
         const { iv, ownersAESKeyEncrypted } = type.encryptedPost
-        if (whoAmI === postBy) {
+        if (whoAmI.userId === postBy.userId) {
             useAsync(() => Services.Crypto.getSharedListOfPost(iv), [post]).then(p => setAlreadySelectedPreviously(p))
         }
         return (
@@ -48,7 +48,7 @@ function PostInspector(props: PostInspectorProps) {
             />
         )
     } else if (type.provePost) {
-        Services.People.uploadProvePostUrl(postBy, postId)
+        Services.People.uploadProvePostUrl(new PostIdentifier(postBy, postId))
         return <AddToKeyStore postBy={postBy} provePost={post} />
     }
     return null
@@ -57,11 +57,14 @@ new MutationObserverWatcher(posts)
     .assignKeys(node => node.innerText)
     .useNodeForeach((node, key, realNode) => {
         // Get author
-        const postBy = getUsername(node.current.parentElement!.querySelectorAll('a')[1])!
+        const postBy = new PersonIdentifier(
+            'facebook.com',
+            getUsername(node.current.parentElement!.querySelectorAll('a')[1])!,
+        )
         // Save author's avatar
         try {
             const avatar = node.current.parentElement!.querySelector('img')!
-            Services.People.storeAvatar(new PersonIdentifier('facebook.com', postBy), avatar.src)
+            Services.People.storeAvatar(postBy, avatar.src)
         } catch {}
         // Get post id
         let postId = ''

src/extension/content-script/injections/ProfilePage.tsx

@@ -1,6 +1,7 @@
 import { LiveSelector } from '@holoflows/kit/es/DOM/LiveSelector'
 import { MutationObserverWatcher } from '@holoflows/kit/es/DOM/Watchers/MutationObserverWatcher'
 import Services from '../../service'
+import { PersonIdentifier } from '../../../database/type'
 
 const bio = new LiveSelector().querySelector<HTMLDivElement>('#profile_timeline_intro_card')
 function verify(text: string) {
@@ -10,7 +11,7 @@ function verify(text: string) {
     const name = a.href.match(/^https:..www.facebook.com\/(.+)/)
     if (!id && !name) return
     const username = id ? id[1] : name![1]
-    Services.Crypto.verifyOthersProve(text, username)
+    Services.Crypto.verifyOthersProve(text, new PersonIdentifier('facebook.com', username))
 }
 new MutationObserverWatcher(bio)
     .useNodeForeach(node => {

src/key-management/keystore-db.ts

@@ -28,18 +28,20 @@ class CryptoKeyRecord {
 type Exporting = {
     username: string
     publicKey: CryptoKey
+    privateKey?: CryptoKey
 }
 /**
  * @deprecated
  */
-async function queryPeopleCryptoKey(): Promise<Exporting[]> {
+export async function queryPeopleCryptoKey(): Promise<Exporting[]> {
     async function toReadCryptoKey(y: CryptoKeyRecord): Promise<Exporting> {
         const pub = await crypto.subtle.importKey('jwk', y.key.publicKey, y.algor, true, y.usages)
         let priv: CryptoKey | undefined = undefined
         if (y.key.privateKey) priv = await crypto.subtle.importKey('jwk', y.key.privateKey, y.algor, true, y.usages)
         return {
             username: y.username,
             publicKey: pub,
+            privateKey: priv,
         }
     }
     const query = buildQuery(new Db('maskbook-keystore-demo-v2', 1), CryptoKeyRecord)

src/key-management/people-gun.ts

@@ -52,7 +52,10 @@ export async function addPersonPublicKey(user: PersonIdentifier): Promise<Person
     return person
 }
 
-export async function uploadProvePostUrl(username: string, postId: string) {
+export async function uploadProvePostUrl(post: PostIdentifier<PersonIdentifier>) {
+    const { postId, identifier } = post
+    if (!(identifier instanceof PersonIdentifier)) return
+    const { userId: username } = identifier
     if (!postId) return
     return gun.get('users').put({ [username]: { provePostId: postId } }).then!()
 }

src/network/gun/version.2.ts

@@ -1,5 +1,3 @@
-import { PostIdentifier } from '../../database/type'
-
 export const Version2Person = '1edc22d2-ca62-4d0a-b842-148f6faa4269'
 export const Version2Post = 'd7cc9636-be26-447b-a1bb-798b126f7ace'
 

src/utils/type-transform/Username.ts

@@ -19,11 +19,8 @@ export function regularUsername(name: string) {
 /**
  * Normalize post url
  */
-export function getPostUrlAtFacebook(post: PostIdentifier) {
+export function getPostUrlAtFacebook(post: PostIdentifier<PersonIdentifier>) {
     const id = post.identifier
-    // TODO:
-    if (!(id instanceof PersonIdentifier)) throw new Error('Not implemented')
-
     const { postId } = post
     const { userId } = id
     if (!regularUsername(userId)) throw new TypeError(geti18nString('service_username_invalid'))