User creation and authentication (#25)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "fission-sdk",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Fission Typescript SDK",
   "keywords": [],
   "main": "index.cjs.js",
@@ -93,10 +93,11 @@
     "typescript": "^3.8.2"
   },
   "dependencies": {
+    "base58-universal": "^1.0.0",
     "borc": "^2.1.1",
     "get-ipfs": "^1.2.0",
     "ipld-dag-pb": "^0.18.2",
-    "keystore-idb": "^0.8.0",
+    "keystore-idb": "^0.11.1",
     "query-string": "^6.11.1"
   }
 }

src/@types/index.d.ts

@@ -1,2 +1,3 @@
+declare module 'base58-universal/main.js'
 declare module 'ipld-dag-pb'
 declare module 'borc'

src/common.ts

@@ -0,0 +1,24 @@
+import { KeyStore } from 'keystore-idb/types'
+
+
+// CONSTANTS
+
+
+export const API_ENDPOINT = 'https://runfission.com'
+
+
+
+// BASE64
+
+
+export function base64UrlDecode(a: string): string {
+  return atob(a).replace(/\_/g, "/").replace(/\-/g, "+")
+}
+
+export function base64UrlEncode(b: string): string {
+  return makeBase64UrlSafe(btoa(b))
+}
+
+export function makeBase64UrlSafe(a: string): string {
+  return a.replace(/\//g, "_").replace(/\+/g, "-").replace(/=+$/, "")
+}

src/ffs/ffs.ts

@@ -1,6 +1,6 @@
 import PublicTree from './public'
 import PrivateTree from './private'
-import { Tree, File, Links } from './types'
+import { File, Links, SyncHook, Tree } from './types'
 import { CID, FileContent } from '../ipfs'
 import pathUtil from './path'
 import link from './link'
@@ -12,13 +12,16 @@ export class FileSystem {
   root: PublicTree
   publicTree: PublicTree
   privateTree: PrivateTree
+  syncHooks: Array<SyncHook>
+
   private key: string
 
   constructor(root: PublicTree, publicTree: PublicTree, privateTree: PrivateTree, key: string) {
     this.root = root
     this.publicTree = publicTree
     this.privateTree = privateTree
     this.key = key
+    this.syncHooks = []
   }
 
   static async empty(keyName: string = 'filesystem-root'): Promise<FileSystem> {
@@ -92,10 +95,28 @@ export class FileSystem {
     const privCID = await this.privateTree.putEncrypted(this.key)
     const pubLink = link.make('public', pubCID, false)
     const privLink = link.make('private', privCID, false)
+
     this.root = this.root
                   .updateLink(pubLink)
                   .updateLink(privLink)
-    return this.root.put()
+
+    const cid = await this.root.put()
+
+    this.syncHooks.forEach(hook => {
+      hook(cid)
+    })
+
+    return cid
+  }
+
+  addSyncHook(hook: SyncHook): Array<SyncHook> {
+    this.syncHooks = [...this.syncHooks, hook]
+    return this.syncHooks
+  }
+
+  removeSyncHook(hook: SyncHook): Array<SyncHook> {
+    this.syncHooks = this.syncHooks.filter(h => h !== hook)
+    return this.syncHooks
   }
 
   async runOnTree<a>(path: string, updateTree: boolean, fn: (tree: Tree, relPath: string) => Promise<a>): Promise<a> {
@@ -107,7 +128,7 @@ export class FileSystem {
       result = await fn(this.publicTree, relPath)
       if(updateTree && PublicTree.instanceOf(result)){
         this.publicTree = result
-      } 
+      }
     }else if(head === 'private') {
       result = await fn(this.privateTree, relPath)
       if(updateTree && PrivateTree.instanceOf(result)){

src/ffs/types.ts

@@ -1,43 +1,55 @@
 import { FileContent, CID } from '../ipfs'
 
-export type AddLinkOpts = {
-  shouldOverwrite?: boolean
+
+// FILES
+// -----
+
+export interface File {
+  content: FileContent
+  put(): Promise<CID>
 }
 
-export type NonEmptyPath = [string, ...string[]]
+export interface FileStatic {
+  create: (content: FileContent) => File
+  fromCID: (cid: CID) => Promise<File>
+}
 
-export type PrivateTreeData = {
-  key: string
-  links: Links
+export interface PrivateFileStatic extends FileStatic{
+  fromCIDWithKey: (cid: CID, key: string) => Promise<File>
+}
+
+
+// LINKS
+// -----
+
+export type AddLinkOpts = {
+  shouldOverwrite?: boolean
 }
 
 export type Link = {
   name: string
   cid: CID
-  size?: number 
+  size?: number
   mtime?: number
   isFile: boolean
 }
 
 export type Links = { [name: string]: Link }
 
-export interface FileStatic {
-  create: (content: FileContent) => File
-  fromCID: (cid: CID) => Promise<File>
-}
 
-export interface PrivateFileStatic extends FileStatic{
-  fromCIDWithKey: (cid: CID, key: string) => Promise<File>
-}
+// MISC
+// ----
 
-export interface File {
-  content: FileContent
-  put(): Promise<CID>
-}
+export type NonEmptyPath = [string, ...string[]]
+export type SyncHook = (cid: CID) => any
 
-export interface TreeStatic {
-  empty: () => Promise<Tree>
-  fromCID: (cid: CID) => Promise<Tree>
+
+// TREE
+// ----
+
+export type PrivateTreeData = {
+  key: string
+  links: Links
 }
 
 export interface PrivateTreeStatic extends TreeStatic {
@@ -47,18 +59,18 @@ export interface PrivateTreeStatic extends TreeStatic {
 export interface Tree {
   links: Links
   isFile: boolean
+
   static: {
     tree: TreeStatic
     file: FileStatic
   }
 
-
   ls(path: string): Promise<Links>
   mkdir(path: string): Promise<Tree>
   cat(path: string): Promise<FileContent>
   add(path: string, content: FileContent): Promise<Tree>
   get(path: string): Promise<Tree | File | null>
-  pathExists(path: string): Promise<boolean> 
+  pathExists(path: string): Promise<boolean>
   addChild(path: string, toAdd: Tree | File): Promise<Tree>
 
   put(): Promise<CID>
@@ -71,3 +83,8 @@ export interface Tree {
   rmLink(name: string): Tree
   copyWithLinks(links: Links): Tree
 }
+
+export interface TreeStatic {
+  empty: () => Promise<Tree>
+  fromCID: (cid: CID) => Promise<Tree>
+}

src/index.ts

@@ -2,10 +2,12 @@ import auth from './auth'
 import * as ffs from './ffs'
 import ipfs from './ipfs'
 import keystore from './keystore'
+import user from './user'
 
 export default {
   auth,
   ffs,
   ipfs,
-  keystore
+  keystore,
+  user
 }

src/keystore/basic.ts

@@ -1,10 +1,16 @@
 import { getKeystore } from './config'
+import keystore from 'keystore-idb'
+
+export const clear = (): Promise<void> => {
+  return keystore.clear()
+}
 
 export const getKeyByName = async (keyName: string): Promise<string> => {
   const ks = await getKeystore()
   return ks.exportSymmKey(keyName)
 }
 
 export default {
+  clear,
   getKeyByName
 }