@ossy/sdk-react 0.1.4 → 0.1.6

package/src/useResources.ts

@@ -1,163 +0,0 @@
-import { useCallback, useMemo, useEffect } from 'react'
-import { useCache } from './Cache'
-import { removeBy } from './removeBy'
-import { replaceBy } from './replaceBy'
-import { AsyncStatus } from './asyncStatus'
-import { useSdk } from './useSdk'
-
-export const useResources = (location?: string) => {
-  const sdk = useSdk()
-  const workspaceId = sdk.workspaceId
-
-  const statusCachePath = useMemo(
-    () => ['resources', workspaceId, 'status', location],
-    [workspaceId, location]
-  )
-
-  const dataCachePath = useMemo(
-    () => ['resources', workspaceId, 'data'],
-    [workspaceId]
-  )
-
-  const {
-    data: status,
-    set: setStatus
-  } = useCache(statusCachePath, AsyncStatus.NotInitialized)
-
-  const {
-    data: resources,
-    set: setResources
-  } = useCache(dataCachePath, [])
-
-  const locationSpecificResources = useMemo(
-    () => resources.filter((resource: { location: string }) => resource.location === location),
-    [resources, location]
-  )
-
-  const loadResource = useCallback(
-    (id: string) => {
-      const cachedResource = resources.find((resource: { id: string }) => resource.id === id)
-      return !!cachedResource
-        ? Promise.resolve(cachedResource)
-        : sdk.resources.get({ id })
-          .then((resource: any) => {
-            setResources((resources = []) => replaceBy('id', resource, resources))
-            return resource
-          })
-    },
-    [sdk, resources, setResources]
-  )
-
-  const loadResources = useCallback(() => {
-    setStatus(AsyncStatus.Loading)
-    sdk.resources.list({ location })
-      .then((requestedResources: any) => {
-        setStatus(AsyncStatus.Success)
-        // TODO: Duplicated resources can occur when you move a resource into a directory
-        // then navigate to that directory, causing it to load the recently moved resource from BE into the resources list
-        // Should probably use another data structure that ensures uniqueness.
-        // temp fix is the resourcesWithStaleResourcesRemoved
-        setResources((resources: any[] = []) => {
-          const requestedResourcesIds = requestedResources.map((resource: { id: string }) => resource.id)
-
-          const resourcesWithStaleResourcesRemoved = resources.filter(
-            resource => !requestedResourcesIds.includes(resource.id)
-          )
-
-          return [...requestedResources, ...resourcesWithStaleResourcesRemoved]
-        })
-      })
-      .catch(() => { setStatus(AsyncStatus.Error) })
-  }, [sdk, location, setStatus, setResources])
-
-  const createDocument = useCallback(
-   (document: any) => sdk.resources.create({
-      type: document.type,
-      location: document.location,
-      name: document.name,
-      content: document.content
-    })
-      .then((resource: any) => {
-        setResources((resources = []) => [...resources, resource])
-        return resource
-      }),
-    [sdk, setResources]
-  )
-
-  const uploadFile = useCallback(
-    (location: string, file: File) => sdk.resources.upload({ location, file })
-      .then((resource: any) => {
-        setResources((resources = []) => [...resources, resource])
-        return resource
-      }),
-    [sdk, setResources]
-  )
-
-  const createDirectory = useCallback(
-    ({ location, name }: { location: string, name: string }) => sdk.resources.createDirectory({ type: 'directory', location, name })
-      .then((resource: any) => {
-        setResources((resources = []) => [...resources, resource])
-        return resource
-      }),
-    [sdk, setResources]
-  )
-
-  const removeResource = useCallback(
-    (id: string) => sdk.resources.remove({ id })
-      .then(() => setResources((resources = []) => removeBy('id', id, resources))),
-    [sdk, setResources]
-  )
-
-  const updateResourceContent = useCallback(
-    (id: string, content: any) => sdk.resources.updateContent({ id, content})
-      .then((resource: any) => {
-        setResources((resources = []) => replaceBy('id', resource, resources))
-        return resource
-      }),
-    [sdk, workspaceId, setResources]
-  )
-
-  const moveResource = useCallback(
-    // TODO: how should we add this to the new location in cache?
-    // TODO: if recource is a direcotry, how should we move the nested resources from cache?
-    (id: string, target: string) => sdk.resources.move({ id, target })
-      .then((resource: string) => {
-        setResources((resources = []) => replaceBy('id', resource, resources))
-        return resource
-      }),
-    [sdk, workspaceId, setResources]
-  )
-
-  const renameResource = useCallback(
-    // TODO: how should we update the cache for individual resources
-    // mabye by making this an internal function and only use it through useResource?
-    (id: string, name: string) => sdk.resources.rename({ id, name })
-      .then((resource: any) => {
-        setResources((resources = []) => replaceBy('id', resource, resources))
-        return resource
-      }),
-    [sdk, workspaceId, setResources]
-  )
-
-  useEffect(() => {
-    if (!workspaceId) return
-    if (!location) return
-    if (status !== AsyncStatus.NotInitialized) return
-
-    loadResources()
-
-  }, [workspaceId, location, status])
-
-  return {
-    status,
-    resources: locationSpecificResources,
-    removeResource,
-    createDocument,
-    createDirectory,
-    loadResource,
-    updateResourceContent,
-    moveResource,
-    renameResource,
-    uploadFile
-  }
-}

package/src/useSdk.ts

@@ -1,7 +0,0 @@
-import { useContext } from 'react'
-import { Context } from './WorkspaceProvider'
-
-export function useSdk() {
-    return useContext(Context).sdk
-  }
-  

package/src/useUser.ts

@@ -1,55 +0,0 @@
-import { useCallback, useEffect } from 'react'
-import { useCache } from './Cache'
-import { useSdk } from './useSdk'
-import { AsyncStatus } from './asyncStatus'
-
-const statusPath = ['user', 'status']
-const userPath = ['user', 'data']
-
-export const useUser = () => {
-  const sdk = useSdk()
-
-  const {
-    data: status = AsyncStatus.NotInitialized,
-    set: setStatus
-  } = useCache(statusPath)
-
-  const {
-    data: user = {},
-    set: setUser
-  } = useCache(userPath)
-
-  const update = useCallback(
-    (user: any) => {
-      return sdk.currentUser.update(user)
-        .then((updatedUser: any) => {
-          setUser(updatedUser)
-          return updatedUser
-        })
-    },
-    [sdk]
-  )
-
-  useEffect(() => {
-    if (status !== AsyncStatus.NotInitialized) return
-    setStatus(() => AsyncStatus.Loading)
-
-    sdk.currentUser.get()
-      .then((user: any) => {
-        if (!user) return Promise.reject()
-        setUser(user)
-        setStatus(() => AsyncStatus.Success)
-      })
-      .catch(() => {
-        setUser({})
-        setStatus(() => AsyncStatus.Error)
-      })
-
-  }, [status, sdk])
-
-  return {
-    status,
-    user,
-    update
-  }
-}

package/src/useUsers.ts

@@ -1,38 +0,0 @@
-import { useCallback, useEffect, useMemo } from 'react'
-import { useCache } from './Cache'
-import { AsyncStatus } from './asyncStatus'
-import { useSdk } from './useSdk'
-
-export const useUsers = () => {
-  const sdk = useSdk()
-  const workspaceId = sdk.workspaceId
-  const cachePath = useMemo(() => ['workspace', workspaceId, 'users'], [workspaceId])
-
-  const {
-    data: users = { status: AsyncStatus.NotInitialized, data: [] },
-    set: setUsers
-  } = useCache(cachePath)
-
-  const load = useCallback(() => {
-    setUsers({ status: AsyncStatus.Loading, data: [] })
-
-    sdk.users.list()
-      .then((users: any[]) => setUsers({ data: users, status: AsyncStatus.Success }))
-      .catch(() => setUsers({ status: AsyncStatus.Error, data: [] }))
-
-  }, [sdk])
-
-  useEffect(() => {
-    if (!workspaceId) return
-    if (users.status === AsyncStatus.NotInitialized) {
-      load()
-    }
-  }, [workspaceId, users])
-
-  return {
-    status: users.status,
-    users: users.data,
-    load,
-  }
-
-}

package/src/useWorkspace.ts

@@ -1,67 +0,0 @@
-import { useCallback, useEffect, useMemo } from 'react'
-import { useCache } from './Cache'
-import { AsyncStatus } from './asyncStatus'
-import { useSdk } from './useSdk'
-
-export const useWorkspace = () => {
-  const sdk = useSdk()
-  const workspaceId = sdk.workspaceId
-  const cachePath = useMemo(() => ['workspace', workspaceId], [workspaceId])
-
-  const {
-    data: workspace = { status: AsyncStatus.NotInitialized, data: {} },
-    set: setWorkspace
-  } = useCache(cachePath)
-
-  const loadWorkspace = useCallback(() => {
-    setWorkspace({ status: AsyncStatus.Loading, data: {} })
-    sdk.workspaces.current()
-      .then((workspace: any) => setWorkspace({ data: workspace, status: AsyncStatus.Success }))
-      .catch(() => setWorkspace({ status: AsyncStatus.Error, data: {} }))
-  }, [sdk, workspaceId])
-
-  const createApiToken = useCallback(
-    (description: string) => sdk.workspaces.createApiToken({ description })
-      .then(({ id, token }: { id: string, token: string }) => {
-
-        setWorkspace({
-          status: workspace.status,
-          data: {
-            ...workspace,
-            apiTokens: [...workspace.apiTokens, { id, description }]
-          }
-        })
-
-        return token
-      }),
-    [sdk]
-  )
-
-  const inviteUser = useCallback(
-    (email: string) => sdk.workspaces.inviteUser({ email }),
-    [sdk]
-  )
-
-  const enableService = () => {
-
-  }
-
-  const disabledService = () => {
-    
-  }
-
-  useEffect(() => {
-    if (!workspaceId) return
-    if (workspace.status === AsyncStatus.NotInitialized) {
-      loadWorkspace()
-    }
-  }, [workspaceId, workspace])
-
-  return {
-    status: workspace.status,
-    workspace: workspace.data,
-    loadWorkspace,
-    createApiToken,
-    inviteUser
-  }
-}

package/src/useWorkspaces.ts

@@ -1,49 +0,0 @@
-import { useCallback, useEffect } from 'react'
-import { useCache } from './Cache'
-import { AsyncStatus } from './asyncStatus'
-import { useSdk } from './useSdk'
-
-const cachePath = ['workspaces']
-
-export const useWorkspaces = () => {
-  const sdk = useSdk()
-
-  const {
-    set: setWorkspaces,
-    data: workspaces = { status: AsyncStatus.NotInitialized, data: [] }
-  } = useCache(cachePath)
-
-  const loadWorkspaces = useCallback(() => {
-    setWorkspaces({ status: AsyncStatus.Loading, data: [] })
-    sdk.workspaces.list()
-      .then((workspaces: any[]) => setWorkspaces({ status: AsyncStatus.Success, data: workspaces }))
-      .catch(() => setWorkspaces({ status: AsyncStatus.Error, data: [] }))
-  }, [sdk])
-
-  const createWorkspace = useCallback(
-    (name: string) => sdk.workspaces.create({ name })
-      .then((workspace: any) => {
-
-        setWorkspaces({
-          status: workspaces.status,
-          data: [...workspaces.data, workspace]
-        })
-
-        return workspace
-      }),
-    [sdk]
-  )
-
-  useEffect(() => {
-    if (workspaces.status === AsyncStatus.NotInitialized) {
-      loadWorkspaces()
-    }
-  }, [workspaces, loadWorkspaces])
-
-  return {
-    status: workspaces.status,
-    workspaces: workspaces.data,
-    loadWorkspaces,
-    createWorkspace
-  }
-}

package/tsconfig.json

@@ -1,27 +0,0 @@
-{
-    "compilerOptions": {
-      "target": "es5",
-      "lib": ["dom", "dom.iterable", "esnext"],
-      "allowJs": true,
-      "skipLibCheck": true,
-      "strict": true,
-      "forceConsistentCasingInFileNames": true,
-      "esModuleInterop": true,
-      "module": "esnext",
-      "moduleResolution": "node",
-      "resolveJsonModule": true,
-      "isolatedModules": true,
-      "jsx": "react",
-      "incremental": false,
-      "declaration": true,
-      "declarationDir": "./build/types"
-    },
-    "exclude": [
-      "build",
-      "node_modules",
-      "src/**/*.test.tsx",
-      "src/**/*.stories.tsx",
-      "rollup.config.js",
-      "src/data.mock.ts"
-    ]
-  }