@ossy/sdk-react 0.0.16 → 0.1.1

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 0.1.1 (2025-10-31)
+
+**Note:** Version bump only for package @ossy/sdk-react
+
+
+
+
+
+# 0.1.0 (2025-10-30)
+
+
+### Features
+
+* **sdk:** get current workspace ([#4](https://github.com/ossy-se/packages/issues/4)) ([afce7d5](https://github.com/ossy-se/packages/commit/afce7d5787af42691f62c9eba672ea1be000e19e))
+
+
+
+
+
 ## 0.0.16 (2025-10-30)
 
 **Note:** Version bump only for package @ossy/sdk-react

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@ossy/sdk-react",
-  "description": "Sofware Development Kit for interactive with our services in React",
-  "version": "0.0.16",
+  "description": "Sofware Development Kit React",
+  "version": "0.1.1",
   "url": "git://github.com/ossy-se/packages/sdk-react",
-  "source": "src/index.js",
-  "module": "build/index.esm.js",
+  "source": "src/public.index.ts",
+  "module": "build/public.index.js",
+  "types": "build/public.index.d.ts",
+  "type": "module",
   "author": "Ossy <yourfriends@ossy.se> (https://ossy.se)",
   "repository": {
     "type": "git",
@@ -33,15 +35,17 @@
     "ramda": "^0.32.0"
   },
   "devDependencies": {
-    "@babel/core": "^7.14.5",
+    "@babel/cli": "^7.21.5",
+    "@babel/core": "^7.26.0",
     "@babel/eslint-parser": "^7.15.8",
-    "@babel/preset-react": "^7.14.5",
-    "babel-loader": "^10.0.0",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
-    "rollup-plugin-babel": "^4.4.0"
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-react": "^7.24.1",
+    "@babel/preset-typescript": "^7.26.0",
+    "@rollup/plugin-babel": "6.1.0",
+    "@types/ramda": "^0.31.1"
   },
   "peerDependencies": {
+    "@ossy/sdk": ">=0.1.0 <1.0.0",
     "react": ">=19.0.0 <20.0.0",
     "react-dom": ">=19.0.0 <20.0.0"
   },
@@ -49,5 +53,5 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "gitHead": "6cf3fe944bcbd61a2deb8d2e24f982374415e6d4"
+  "gitHead": "84a2ce92ad013ccf992a009f84581880a7cb1acc"
 }

package/rollup.config.js

@@ -1,26 +1,44 @@
-import babel from 'rollup-plugin-babel'
-import { nodeResolve } from '@rollup/plugin-node-resolve'
+import babel from '@rollup/plugin-babel'
+import { nodeResolve as resolveDependencies } from '@rollup/plugin-node-resolve'
+import resolveCommonJsDependencies from '@rollup/plugin-commonjs'
 import removeOwnPeerDependencies from 'rollup-plugin-peer-deps-external'
-import commonjs from '@rollup/plugin-commonjs'
 import minifyJS from '@rollup/plugin-terser'
+import typescript from '@rollup/plugin-typescript'
+import preserveDirectives from "rollup-plugin-preserve-directives"
+import { dts } from "rollup-plugin-dts"
 import pkg from './package.json'
 
-export default {
-  input: pkg.source,
-  output: [
-    {
-      file: pkg.module,
-      format: 'esm'
-    }
-  ],
-  plugins: [
-    nodeResolve(),
-    commonjs(),
-    babel({
-      exclude: ['**/node_modules/**/*'],
-      presets: ['@babel/preset-react']
-    }),
-    removeOwnPeerDependencies(),
-    minifyJS()
-  ]
-}
+export default [
+  {
+    input: pkg.source,
+    output: [
+      {
+        dir: 'build',
+        preserveModules: true,
+        format: 'esm'
+      }
+    ],
+    plugins: [
+      resolveCommonJsDependencies(),
+      resolveDependencies(),
+      removeOwnPeerDependencies(),
+      babel({
+        exclude: ['**/node_modules/**/*'],
+        presets: ['@babel/preset-react']
+      }),
+      minifyJS(),
+      preserveDirectives(),
+      typescript({
+        tsconfig: "./tsconfig.json",
+        outDir: 'build',
+      }),
+    ]
+  },
+  {
+    input: "build/types/public.index.d.ts",
+    output: [{ file: "build/public.index.d.ts", format: "es" }],
+    plugins: [
+      dts()
+    ],
+  },
+]

package/src/{Cache.jsx → Cache.tsx}

@@ -1,5 +1,3 @@
-// TODO: We should use Cache from @ossy-se/components when it becomes public
-
 import React, {
   createContext,
   useReducer,
@@ -8,18 +6,15 @@ import React, {
 } from 'react'
 
 const getInitialState = () => ({})
-export const CacheContext = createContext()
+export const CacheContext = createContext<any>({})
 
 const Actions = {
   Set: 'SET'
 }
 
-// get: (path, state)
-// set: (path, value, state)
-
-const createReducer = ({ set, get }) => (
+const createReducer = ({ set, get }: { set: any, get: any }) => (
   state = getInitialState(),
-  action
+  action: any
 ) => {
   switch (action.type) {
 
@@ -42,18 +37,18 @@ const createReducer = ({ set, get }) => (
   }
 }
 
-export const createCache = ({ get: _get, set: _set }) => props => {
+export const createCache = ({ get: _get, set: _set }: { get: any, set: any}) => (props: any) => {
 
   const [state, updateState] = useReducer(
     createReducer({ set: _set, get: _get }),
     getInitialState()
   )
 
-  const set = useCallback(cachePath => data => {
+  const set = useCallback((cachePath: any) => (data: any) => {
     updateState({ type: Actions.Set, cachePath, data })
   }, [updateState])
 
-  const get = useCallback(cachePath =>
+  const get = useCallback((cachePath: any) =>
     _get(cachePath, state),
   [state, _get]
   )
@@ -63,7 +58,7 @@ export const createCache = ({ get: _get, set: _set }) => props => {
   )
 }
 
-export const useCache = (cachePath, defaultValue) => {
+export const useCache = (cachePath: any, defaultValue?: any) => {
   // TODO: Add default value to context here, otherwise it will be undefined in the set((data) => { ...  }) function
   const { get, set } = useContext(CacheContext)
 

package/src/WorkspaceProvider.tsx

@@ -0,0 +1,27 @@
+import React, { createContext, PropsWithChildren } from 'react'
+import { createCache } from './Cache'
+import { path, set, lensPath } from 'ramda'
+import { type SDK } from '@ossy/sdk'
+
+export const Context = createContext<Config>({} as Config)
+
+const Cache = createCache({
+  get: path,
+  set: (path: any, value: any, data: any) => set(lensPath(path), value, data)
+})
+
+export interface Config {
+  sdk: SDK
+}
+
+export const WorkspaceProvider = ({ sdk, children }: PropsWithChildren<Config>) => {
+  return (
+    <Cache>
+      <Context.Provider value={{ sdk }}>
+        {children}
+      </Context.Provider>
+    </Cache>
+  )
+}
+
+

package/src/public.index.ts

@@ -0,0 +1,13 @@
+export * from './asyncStatus'
+export * from './useApiTokens'
+export * from './useAuthentication'
+export * from './useWorkspace'
+export * from './useWorkspaces'
+export * from './useQuery'
+export * from './useResource'
+export * from './useResourceTemplate'
+export * from './useResources'
+export * from './WorkspaceProvider'
+export * from './useSdk'
+export * from './useUser'
+export * from './useUsers'

package/src/{useApiTokens.js → useApiTokens.ts}

@@ -1,8 +1,8 @@
 import { useCallback, useEffect } from 'react'
-import { useCache } from './Cache.jsx'
-import { AsyncStatus } from './asyncStatus.js'
-import { useSdk } from './useSdk.js'
-import { removeBy } from './removeBy.js'
+import { useCache } from './Cache'
+import { AsyncStatus } from './asyncStatus'
+import { useSdk } from './useSdk'
+import { removeBy } from './removeBy'
 
 const statusPath = ['apiTokens', 'status']
 const dataPath = ['apiTokens', 'data']
@@ -21,24 +21,28 @@ export const useApiTokens = () => {
   } = useCache(dataPath)
 
   const createApiToken = useCallback(
-    description => sdk.apiTokens.create(description)
-      .then(newToken => {
-        setTokens(tokens => [...tokens, newToken])
-        return newToken
+    (token: {
+      name: string;
+      description: string;
+      expiresAt: string;
+  }) => sdk.apiTokens.create(token)
+      .then((token: any) => {
+        setTokens((tokens: any[]) => [...tokens, token])
+        return token
       }),
     [sdk]
   )
 
   const invalidateApiToken = useCallback(
-    tokenId => sdk.apiTokens.invalidate(tokenId)
-      .then(() => setTokens(tokens => removeBy('id', tokenId, tokens))),
+    (id: string) => sdk.apiTokens.invalidate({ id })
+      .then(() => setTokens((tokens: any[]) => removeBy('id', id, tokens))),
     [sdk]
   )
 
   const loadApiTokens = useCallback(() => {
     setStatus(AsyncStatus.Loading)
-    sdk.apiTokens.getAll()
-      .then(tokens => {
+    sdk.apiTokens.list()
+      .then((tokens: any[]) => {
         setTokens(tokens)
         setStatus(AsyncStatus.Success)
       })

package/src/{useAuthentication.js → useAuthentication.ts}

@@ -1,6 +1,6 @@
 import { useCallback, useEffect } from 'react'
-import { useCache } from './Cache.jsx'
-import { useSdk } from './useSdk.js'
+import { useCache } from './Cache'
+import { useSdk } from './useSdk'
 
 export const AuthenticationStatus = {
   AuthenticationError: 'AuthenticationError',
@@ -22,11 +22,11 @@ export const useAuthentication = () => {
   } = useCache(statusPath)
 
   const signUp = useCallback(
-    email => {
+    (email: string) => {
       setStatus(() => AuthenticationStatus.Verifying)
-      return sdk.auth.signUp(email)
+      return sdk.auth.signUp({ email })
         .then(() => setStatus(AuthenticationStatus.VerifySignIn))
-        .catch(error => {
+        .catch((error: any) => {
           setStatus(AuthenticationStatus.AuthenticationError)
           return Promise.reject(error)
         })
@@ -35,11 +35,11 @@ export const useAuthentication = () => {
   )
 
   const signIn = useCallback(
-    email => {
+    (email: any) => {
       setStatus(() => AuthenticationStatus.Verifying)
       return sdk.auth.signIn(email)
         .then(() => setStatus(AuthenticationStatus.VerifySignIn))
-        .catch((error) => {
+        .catch((error: any) => {
           setStatus(AuthenticationStatus.AuthenticationError)
           return Promise.reject(error)
         })
@@ -48,11 +48,11 @@ export const useAuthentication = () => {
   )
 
   const verifySignIn = useCallback(
-    token => {
+    (token: string) => {
       setStatus(() => AuthenticationStatus.Verifying)
-      return sdk.auth.verifySignIn(token)
+      return sdk.auth.verifySignIn({ token })
         .then(() => setStatus(AuthenticationStatus.Authenticated))
-        .catch((error) => {
+        .catch((error: any) => {
           setStatus(AuthenticationStatus.AuthenticationError)
           return Promise.reject(error)
         })
@@ -61,11 +61,11 @@ export const useAuthentication = () => {
   )
 
   const verifyInvitation = useCallback(
-    (workspaceId, token) => {
+    (workspaceId: string, token: string) => {
       setStatus(() => AuthenticationStatus.Verifying)
-      return sdk.auth.verifyInvitation(workspaceId, token)
+      return sdk.auth.verifyInvitation({ workspaceId, token})
         .then(() => setStatus(AuthenticationStatus.Authenticated))
-        .catch((error) => {
+        .catch((error: any) => {
           setStatus(AuthenticationStatus.AuthenticationError)
           return Promise.reject(error)
         })
@@ -84,7 +84,7 @@ export const useAuthentication = () => {
     setStatus(() => AuthenticationStatus.Verifying)
 
     sdk.auth.getAuthenticatedUser()
-      .then(user => {
+      .then((user: any) => {
         if (!user) return Promise.reject()
         setStatus(() => AuthenticationStatus.Authenticated)
       })

package/src/{useQuery.js → useQuery.ts}

@@ -1,13 +1,12 @@
 import { useCallback, useMemo, useEffect } from 'react'
-import { useCache } from './Cache.jsx'
-import { AsyncStatus } from './asyncStatus.js'
-import { useSdk } from './useSdk.js'
+import { useCache } from './Cache'
+import { AsyncStatus } from './asyncStatus'
+import { useSdk } from './useSdk'
 
-export const useQuery = incomingQuery => {
+export const useQuery = (incomingQuery: any) => {
   const sdk = useSdk()
   const workspaceId = sdk.workspaceId
   const queryString = new URLSearchParams(incomingQuery).toString()
-  console.log('useQuery', incomingQuery, queryString)
 
   const statusCachePath = useMemo(
     () => [workspaceId, 'queries', queryString, 'status'],
@@ -29,18 +28,17 @@ export const useQuery = incomingQuery => {
     set: setResources
   } = useCache(dataCachePath, [])
 
-  const loadResources = useCallback(query => {
+  const loadResources = useCallback((query: any) => {
     setStatus(AsyncStatus.Loading)
     sdk.resources.get(query)
-      .then(matchedResources => {
+      .then((resources: any) => {
         setStatus(AsyncStatus.Success)
-        setResources(matchedResources)
+        setResources(resources)
       })
       .catch(() => { setStatus(AsyncStatus.Error) })
   }, [sdk])
 
   useEffect(() => {
-    console.log('useQuery effect', workspaceId, incomingQuery, status)
     if (!workspaceId) return
     if (!incomingQuery) return
     if (status !== AsyncStatus.NotInitialized) return

package/src/{useResource.js → useResource.ts}

@@ -1,21 +1,21 @@
 import { useCallback, useMemo, useEffect } from 'react'
-import { useCache } from './Cache.jsx'
-import { AsyncStatus } from './asyncStatus.js'
-import { useResources } from './useResources.js'
-import { useSdk } from './useSdk.js'
+import { useCache } from './Cache'
+import { AsyncStatus } from './asyncStatus'
+import { useResources } from './useResources'
+import { useSdk } from './useSdk'
 
-export const useResource = (resourceId) => {
+export const useResource = (id: string) => {
   const sdk = useSdk()
   const workspaceId = sdk.workspaceId
 
   const statusCachePath = useMemo(
-    () => ['resource', workspaceId, resourceId, 'status'],
-    [resourceId, workspaceId]
+    () => ['resource', workspaceId, id, 'status'],
+    [id, workspaceId]
   )
 
   const dataCachePath = useMemo(
-    () => ['resource', workspaceId, resourceId, 'data'],
-    [resourceId, workspaceId]
+    () => ['resource', workspaceId, id, 'data'],
+    [id, workspaceId]
   )
 
   const {
@@ -38,8 +38,8 @@ export const useResource = (resourceId) => {
   const loadResource = useCallback(() => {
     setStatus(AsyncStatus.Loading)
     setResource({})
-    _loadResource(resourceId)
-      .then(resource => {
+    _loadResource(id)
+      .then((resource: any) => {
         setStatus(AsyncStatus.Success)
         setResource(resource)
       })
@@ -47,38 +47,38 @@ export const useResource = (resourceId) => {
         setStatus(AsyncStatus.Error)
         setResource({})
       })
-  }, [resourceId, _loadResource])
+  }, [id, _loadResource])
 
   const removeResource = useCallback(
-    () => _removeResource(resourceId)
+    () => _removeResource(id)
       .then(() => {
         setStatus(AsyncStatus.NotInitialized)
         setResource({})
       }),
-    [resourceId, _removeResource]
+    [id, _removeResource]
   )
 
   const updateResourceContent = useCallback(
-    resourceContent => _updateResourceContent(resourceId, resourceContent)
-      .then(updatedResource => setResource(updatedResource)),
-    [resourceId, _updateResourceContent]
+    (content: any) => _updateResourceContent(id, content)
+      .then((resource: any) => setResource(resource)),
+    [id, _updateResourceContent]
   )
 
   const renameResource = useCallback(
-    newName => _renameResource(resourceId, newName)
-      .then(updatedResource => setResource(updatedResource)),
-    [resourceId, _renameResource]
+    (name: string) => _renameResource(id, name)
+      .then((resource: any) => setResource(resource)),
+    [id, _renameResource]
   )
 
   useEffect(() => {
 
     if (!workspaceId) return
-    if (!resourceId) return
+    if (!id) return
     if (status !== AsyncStatus.NotInitialized) return
 
     loadResource()
 
-  }, [workspaceId, resourceId, loadResource])
+  }, [workspaceId, id, loadResource])
 
   return {
     status,

package/src/useResourceTemplate.ts

@@ -0,0 +1,8 @@
+import { useWorkspace } from './useWorkspace'
+
+export const useResourceTemplate = (id: string) => {
+  const { workspace } = useWorkspace()
+  // TODO: workspace.resourceTemplates might not exist yet
+  const template = workspace.resourceTemplates.find((template: { id: string }) => template.id === id)
+  return template
+}

package/src/{useResources.js → useResources.ts}

@@ -1,11 +1,11 @@
 import { useCallback, useMemo, useEffect } from 'react'
-import { useCache } from './Cache.jsx'
-import { removeBy } from './removeBy.js'
-import { replaceBy } from './replaceBy.js'
-import { AsyncStatus } from './asyncStatus.js'
-import { useSdk } from './useSdk.js'
+import { useCache } from './Cache'
+import { removeBy } from './removeBy'
+import { replaceBy } from './replaceBy'
+import { AsyncStatus } from './asyncStatus'
+import { useSdk } from './useSdk'
 
-export const useResources = (location) => {
+export const useResources = (location?: string) => {
   const sdk = useSdk()
   const workspaceId = sdk.workspaceId
 
@@ -30,19 +30,19 @@ export const useResources = (location) => {
   } = useCache(dataCachePath, [])
 
   const locationSpecificResources = useMemo(
-    () => resources.filter(resource => resource.location === location),
+    () => resources.filter((resource: { location: string }) => resource.location === location),
     [resources, location]
   )
 
   const loadResource = useCallback(
-    resourceId => {
-      const cachedResource = resources.find(resource => resource.id === resourceId)
+    (id: string) => {
+      const cachedResource = resources.find((resource: { id: string }) => resource.id === id)
       return !!cachedResource
         ? Promise.resolve(cachedResource)
-        : sdk.resources.byId(resourceId)
-          .then(requestedResource => {
-            setResources((resources = []) => replaceBy('id', requestedResource, resources))
-            return requestedResource
+        : sdk.resources.get({ id })
+          .then((resource: any) => {
+            setResources((resources = []) => replaceBy('id', resource, resources))
+            return resource
           })
     },
     [sdk, resources, setResources]
@@ -50,15 +50,15 @@ export const useResources = (location) => {
 
   const loadResources = useCallback(() => {
     setStatus(AsyncStatus.Loading)
-    sdk.resources.byLocation(location)
-      .then(requestedResources => {
+    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 = []) => {
-          const requestedResourcesIds = requestedResources.map(resource => resource.id)
+        setResources((resources: any[] = []) => {
+          const requestedResourcesIds = requestedResources.map((resource: { id: string }) => resource.id)
 
           const resourcesWithStaleResourcesRemoved = resources.filter(
             resource => !requestedResourcesIds.includes(resource.id)
@@ -71,48 +71,48 @@ export const useResources = (location) => {
   }, [sdk, location, setStatus, setResources])
 
   const createDocument = useCallback(
-    document => sdk.resources.create({
+   (document: any) => sdk.resources.create({
       type: document.type,
       location: document.location,
       name: document.name,
       content: document.content
     })
-      .then(newResource => {
-        setResources((resources = []) => [...resources, newResource])
-        return newResource
+      .then((resource: any) => {
+        setResources((resources = []) => [...resources, resource])
+        return resource
       }),
     [sdk, setResources]
   )
 
   const uploadFile = useCallback(
-    (location, file) => sdk.resources.upload({ location, file })
-      .then(newResource => {
-        setResources((resources = []) => [...resources, newResource])
-        return newResource
+    (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 }) => sdk.resources.createDirectory({ location, name })
-      .then(newResource => {
-        setResources((resources = []) => [...resources, newResource])
-        return newResource
+    ({ 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(
-    resourceId => sdk.resources.remove(resourceId)
-      .then(() => setResources((resources = []) => removeBy('id', resourceId, resources))),
+    (id: string) => sdk.resources.remove({ id })
+      .then(() => setResources((resources = []) => removeBy('id', id, resources))),
     [sdk, setResources]
   )
 
   const updateResourceContent = useCallback(
-    (resourceId, content) => sdk.resources.updateContent(resourceId, content)
-      .then(updatedResource => {
-        setResources((resources = []) => replaceBy('id', updatedResource, resources))
-        return updatedResource
+    (id: string, content: any) => sdk.resources.updateContent({ id, content})
+      .then((resource: any) => {
+        setResources((resources = []) => replaceBy('id', resource, resources))
+        return resource
       }),
     [sdk, workspaceId, setResources]
   )
@@ -120,10 +120,10 @@ export const useResources = (location) => {
   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?
-    (resourceId, newLocation) => sdk.resources.move(resourceId, newLocation)
-      .then(movedResource => {
-        setResources((resources = []) => replaceBy('id', movedResource, resources))
-        return movedResource
+    (id: string, target: string) => sdk.resources.move({ id, target })
+      .then((resource: string) => {
+        setResources((resources = []) => replaceBy('id', resource, resources))
+        return resource
       }),
     [sdk, workspaceId, setResources]
   )
@@ -131,10 +131,10 @@ export const useResources = (location) => {
   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?
-    (resourceId, newName) => sdk.resources.rename(resourceId, newName)
-      .then(updatedResource => {
-        setResources((resources = []) => replaceBy('id', updatedResource, resources))
-        return updatedResource
+    (id: string, name: string) => sdk.resources.rename({ id, name })
+      .then((resource: any) => {
+        setResources((resources = []) => replaceBy('id', resource, resources))
+        return resource
       }),
     [sdk, workspaceId, setResources]
   )

package/src/{useSdk.js → useSdk.ts}

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

package/src/{useUser.js → useUser.ts}

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

package/src/{useUsers.js → useUsers.ts}

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo } from 'react'
-import { useCache } from './Cache.jsx'
-import { AsyncStatus } from './asyncStatus.js'
-import { useSdk } from './useSdk.js'
+import { useCache } from './Cache'
+import { AsyncStatus } from './asyncStatus'
+import { useSdk } from './useSdk'
 
 export const useUsers = () => {
   const sdk = useSdk()
@@ -16,8 +16,8 @@ export const useUsers = () => {
   const load = useCallback(() => {
     setUsers({ status: AsyncStatus.Loading, data: [] })
 
-    sdk.workspaces.users()
-      .then(users => setUsers({ data: users, status: AsyncStatus.Success }))
+    sdk.users.list()
+      .then((users: any[]) => setUsers({ data: users, status: AsyncStatus.Success }))
       .catch(() => setUsers({ status: AsyncStatus.Error, data: [] }))
 
   }, [sdk])

package/src/{useWorkspace.js → useWorkspace.ts}

@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useMemo } from 'react'
-import { useCache } from './Cache.jsx'
-import { AsyncStatus } from './asyncStatus.js'
-import { useSdk } from './useSdk.js'
+import { useCache } from './Cache'
+import { AsyncStatus } from './asyncStatus'
+import { useSdk } from './useSdk'
 
 export const useWorkspace = () => {
   const sdk = useSdk()
@@ -15,17 +15,17 @@ export const useWorkspace = () => {
 
   const loadWorkspace = useCallback(() => {
     setWorkspace({ status: AsyncStatus.Loading, data: {} })
-    sdk.workspaces.byId(workspaceId)
-      .then(workspace => setWorkspace({ data: workspace, status: AsyncStatus.Success }))
+    sdk.workspaces.current()
+      .then((workspace: any) => setWorkspace({ data: workspace, status: AsyncStatus.Success }))
       .catch(() => setWorkspace({ status: AsyncStatus.Error, data: {} }))
   }, [sdk, workspaceId])
 
   const createApiToken = useCallback(
-    description => sdk.workspaces.createApiToken(workspaceId, description)
-      .then(({ id, token }) => {
+    (description: string) => sdk.workspaces.createApiToken({ description })
+      .then(({ id, token }: { id: string, token: string }) => {
 
         setWorkspace({
-          status: workspaces.status,
+          status: workspace.status,
           data: {
             ...workspace,
             apiTokens: [...workspace.apiTokens, { id, description }]
@@ -38,7 +38,7 @@ export const useWorkspace = () => {
   )
 
   const inviteUser = useCallback(
-    email => sdk.workspaces.inviteUser(workspaceId, email),
+    (email: string) => sdk.workspaces.inviteUser({ email }),
     [sdk]
   )
 

package/src/{useWorkspaces.js → useWorkspaces.ts}

@@ -1,7 +1,7 @@
 import { useCallback, useEffect } from 'react'
-import { useCache } from './Cache.jsx'
-import { AsyncStatus } from './asyncStatus.js'
-import { useSdk } from './useSdk.js'
+import { useCache } from './Cache'
+import { AsyncStatus } from './asyncStatus'
+import { useSdk } from './useSdk'
 
 const cachePath = ['workspaces']
 
@@ -15,14 +15,14 @@ export const useWorkspaces = () => {
 
   const loadWorkspaces = useCallback(() => {
     setWorkspaces({ status: AsyncStatus.Loading, data: [] })
-    sdk.workspaces.getAll()
-      .then(workspaces => setWorkspaces({ status: AsyncStatus.Success, data: workspaces }))
+    sdk.workspaces.list()
+      .then((workspaces: any[]) => setWorkspaces({ status: AsyncStatus.Success, data: workspaces }))
       .catch(() => setWorkspaces({ status: AsyncStatus.Error, data: [] }))
   }, [sdk])
 
   const createWorkspace = useCallback(
-    workspaceName => sdk.workspaces.create(workspaceName)
-      .then(workspace => {
+    (name: string) => sdk.workspaces.create({ name })
+      .then((workspace: any) => {
 
         setWorkspaces({
           status: workspaces.status,

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "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"
+    ]
+  }

package/src/WorkspaceProvider.jsx

@@ -1,22 +0,0 @@
-import React, { createContext } from 'react'
-import { createCache } from './Cache.jsx' // TODO: We should use Cache from @ossy-se/components when it becomes public
-import { path, set, lensPath } from 'ramda' // TODO: not be dependent on ramda
-
-export const Context = createContext({})
-
-const Cache = createCache({
-  get: path,
-  set: (path, value, data) => set(lensPath(path), value, data)
-})
-
-export const WorkspaceProvider = ({ sdk, children }) => {
-  return (
-    <Cache>
-      <Context.Provider value={{ sdk }}>
-        {children}
-      </Context.Provider>
-    </Cache>
-  )
-}
-
-

package/src/index.js

@@ -1,13 +0,0 @@
-export * from './asyncStatus.js'
-export * from './useApiTokens.js'
-export * from './useAuthentication.js'
-export * from './useWorkspace.js'
-export * from './useWorkspaces.js'
-export * from './useQuery.js'
-export * from './useResource.js'
-export * from './useResourceTemplate.js'
-export * from './useResources.js'
-export * from './WorkspaceProvider.jsx'
-export * from './useSdk.js'
-export * from './useUser.js'
-export * from './useUsers.js'

package/src/useResourceTemplate.js

@@ -1,8 +0,0 @@
-import { useWorkspace } from './useWorkspace.js'
-
-export const useResourceTemplate = templateId => {
-  const { workspace } = useWorkspace()
-  // TODO: workspace.resourceTemplates might not exist yet
-  const template = workspace.resourceTemplates.find(template => template.id === templateId)
-  return template
-}