@furystack/rest-service 5.0.3 → 6.0.1

package/src/endpoint-generators/create-delete-endpoint.spec.ts

@@ -4,12 +4,15 @@ import { DeleteEndpoint } from '@furystack/rest'
 import { createDeleteEndpoint } from './create-delete-endpoint'
 import got from 'got'
 import { MockClass, setupContext } from './utils'
+import { useRestService } from '../helpers'
+import { getDataSetFor } from '@furystack/repository'
 
 describe('createDeleteEndpoint', () => {
   it('Should delete the entity and report the success', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ DELETE: { '/:id': DeleteEndpoint<MockClass, 'id'> } }>({
+      await useRestService<{ DELETE: { '/:id': DeleteEndpoint<MockClass, 'id'> } }>({
+        injector: i,
         root: '/api',
         port: 1111,
         api: {
@@ -18,16 +21,16 @@ describe('createDeleteEndpoint', () => {
           },
         },
       })
-      await i.getDataSetFor(MockClass, 'id').add(i, { id: 'mock', value: 'mock' })
+      await getDataSetFor(i, MockClass, 'id').add(i, { id: 'mock', value: 'mock' })
 
-      const countBeforeDelete = await i.getDataSetFor(MockClass, 'id').count(i)
+      const countBeforeDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countBeforeDelete).toBe(1)
 
       const response = await got('http://127.0.0.1:1111/api/mock', { method: 'DELETE' })
       expect(response.statusCode).toBe(204)
       expect(response.body).toBe('')
 
-      const countAfterDelete = await i.getDataSetFor(MockClass, 'id').count(i)
+      const countAfterDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countAfterDelete).toBe(0)
     })
   })

package/src/endpoint-generators/create-delete-endpoint.ts

@@ -2,6 +2,7 @@ import { Constructable } from '@furystack/inject'
 import { DeleteEndpoint } from '@furystack/rest'
 import '@furystack/repository'
 import { JsonResult, RequestAction } from '../request-action-implementation'
+import { getRepository } from '@furystack/repository'
 
 /**
  * Creates a DELETE endpoint for removing entities
@@ -17,7 +18,7 @@ export const createDeleteEndpoint = <T extends object, TPrimaryKey extends keyof
 }) => {
   const endpoint: RequestAction<DeleteEndpoint<T, TPrimaryKey>> = async ({ injector, getUrlParams }) => {
     const { id } = getUrlParams()
-    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
     await dataSet.remove(injector, id)
     return JsonResult({}, 204)
   }

package/src/endpoint-generators/create-get-collection-endpoint.spec.ts

@@ -5,9 +5,11 @@ import { MockClass, setupContext } from './utils'
 import { createGetCollectionEndpoint } from './create-get-collection-endpoint'
 import { GetCollectionEndpoint, GetCollectionResult, serializeToQueryString } from '@furystack/rest'
 import { FindOptions } from '@furystack/core'
+import { getDataSetFor, getRepository } from '@furystack/repository'
+import { useRestService } from '../helpers'
 
 const addMockEntities = async (i: Injector) =>
-  await i
+  await getRepository(i)
     .getDataSetFor(MockClass, 'id')
     .add(
       i,
@@ -21,7 +23,8 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return the collection without filter / order', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+      await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        injector: i,
         root: '/api',
         port: 1112,
         api: {
@@ -32,8 +35,8 @@ describe('createGetCollectionEndpoint', () => {
       })
       await addMockEntities(i)
 
-      const count = await i.getDataSetFor(MockClass, 'id').count(i)
-      const allEntities = await i.getDataSetFor(MockClass, 'id').find(i, {})
+      const count = await getDataSetFor(i, MockClass, 'id').count(i)
+      const allEntities = await getDataSetFor(i, MockClass, 'id').find(i, {})
 
       const response = await got('http://127.0.0.1:1112/api/entities', { method: 'GET' })
       const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
@@ -45,7 +48,8 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities in order', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+      await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        injector: i,
         root: '/api',
         port: 1113,
         api: {
@@ -56,8 +60,8 @@ describe('createGetCollectionEndpoint', () => {
       })
       await addMockEntities(i)
       const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = { order: { value: 'ASC' } }
-      const count = await i.getDataSetFor(MockClass, 'id').count(i, findOptions.filter)
-      const orderedEntities = await i.getDataSetFor(MockClass, 'id').find(i, findOptions)
+      const count = await getDataSetFor(i, MockClass, 'id').count(i, findOptions.filter)
+      const orderedEntities = await getDataSetFor(i, MockClass, 'id').find(i, findOptions)
       const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
@@ -70,7 +74,8 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities with filtering', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+      await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        injector: i,
         root: '/api',
         port: 1113,
         api: {
@@ -84,8 +89,8 @@ describe('createGetCollectionEndpoint', () => {
         filter: { id: { $ne: 'mock2' } },
       }
 
-      const count = await i.getDataSetFor(MockClass, 'id').count(i, findOptions.filter)
-      const filteredEntities = await i.getDataSetFor(MockClass, 'id').find(i, findOptions)
+      const count = await getDataSetFor(i, MockClass, 'id').count(i, findOptions.filter)
+      const filteredEntities = await getDataSetFor(i, MockClass, 'id').find(i, findOptions)
 
       expect(filteredEntities).not.toContainEqual({ id: 'mock2', value: '3' })
 
@@ -101,7 +106,8 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities with selecting specific fields', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+      await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        injector: i,
         root: '/api',
         port: 1113,
         api: {
@@ -115,8 +121,8 @@ describe('createGetCollectionEndpoint', () => {
         select: ['id'],
       }
 
-      const count = await i.getDataSetFor(MockClass, 'id').count(i, findOptions.filter)
-      const selectedEntities = await i.getDataSetFor(MockClass, 'id').find(i, findOptions)
+      const count = await getDataSetFor(i, MockClass, 'id').count(i, findOptions.filter)
+      const selectedEntities = await getDataSetFor(i, MockClass, 'id').find(i, findOptions)
 
       selectedEntities.forEach((e) => expect(e.value).toBeUndefined())
 
@@ -132,7 +138,8 @@ describe('createGetCollectionEndpoint', () => {
   it('Should return entities with top/skip', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+      await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        injector: i,
         root: '/api',
         port: 1113,
         api: {
@@ -147,8 +154,8 @@ describe('createGetCollectionEndpoint', () => {
         top: 2,
       }
 
-      const count = await i.getDataSetFor(MockClass, 'id').count(i, findOptions.filter)
-      const topSkipEntities = await i.getDataSetFor(MockClass, 'id').find(i, findOptions)
+      const count = await getDataSetFor(i, MockClass, 'id').count(i, findOptions.filter)
+      const topSkipEntities = await getDataSetFor(i, MockClass, 'id').find(i, findOptions)
 
       expect(topSkipEntities).not.toContainEqual({ id: 'mock1', value: '4' })
       expect(topSkipEntities).not.toContainEqual({ id: 'mock4', value: '1' })

package/src/endpoint-generators/create-get-collection-endpoint.ts

@@ -2,6 +2,7 @@ import { Constructable } from '@furystack/inject'
 import { GetCollectionEndpoint } from '@furystack/rest'
 import '@furystack/repository'
 import { JsonResult, RequestAction } from '../request-action-implementation'
+import { getRepository } from '@furystack/repository'
 
 /**
  * Creates a GetCollection endpoint for the given model. The model should have a Repository DataSet
@@ -17,7 +18,7 @@ export const createGetCollectionEndpoint = <T, TPrimaryKey extends keyof T>(opti
 }) => {
   const endpoint: RequestAction<GetCollectionEndpoint<T>> = async ({ injector, getQuery }) => {
     const { findOptions } = getQuery()
-    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
     const entriesPromise = dataSet.find<any>(injector, findOptions || {})
     const countPromise = dataSet.count(injector, findOptions?.filter)
     const [entries, count] = await Promise.all([entriesPromise, countPromise])

package/src/endpoint-generators/create-get-entity-endpoint.spec.ts

@@ -4,12 +4,15 @@ import { GetEntityEndpoint, serializeToQueryString } from '@furystack/rest'
 import got, { HTTPError } from 'got'
 import { MockClass, setupContext } from './utils'
 import { createGetEntityEndpoint } from './create-get-entity-endpoint'
+import { getDataSetFor } from '@furystack/repository'
+import { useRestService } from '../helpers'
 
 describe('createGetEntityEndpoint', () => {
   it('Should return the entity', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
+      await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
+        injector: i,
         root: '/api',
         port: 1113,
         api: {
@@ -19,7 +22,7 @@ describe('createGetEntityEndpoint', () => {
         },
       })
       const mockEntity: MockClass = { id: 'mock', value: 'mock' }
-      await i.getDataSetFor(MockClass, 'id').add(i, mockEntity)
+      await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
 
       const response = await got('http://127.0.0.1:1113/api/mock', { method: 'GET' })
       expect(JSON.parse(response.body)).toStrictEqual(mockEntity)
@@ -29,7 +32,8 @@ describe('createGetEntityEndpoint', () => {
   it('Should return the entity with the selected fields', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
+      await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
+        injector: i,
         root: '/api',
         port: 1114,
         api: {
@@ -39,7 +43,7 @@ describe('createGetEntityEndpoint', () => {
         },
       })
       const mockEntity: MockClass = { id: 'mock', value: 'mock' }
-      await i.getDataSetFor(MockClass, 'id').add(i, mockEntity)
+      await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
 
       const response = await got(`http://127.0.0.1:1114/api/mock?${serializeToQueryString({ select: ['id'] })}`, {
         method: 'GET',
@@ -51,7 +55,8 @@ describe('createGetEntityEndpoint', () => {
   it('Should return 404 if no entity has been found', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
+      await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
+        injector: i,
         root: '/api',
         port: 1115,
         api: {

package/src/endpoint-generators/create-get-entity-endpoint.ts

@@ -2,6 +2,7 @@ import { Constructable } from '@furystack/inject'
 import { RequestError, GetEntityEndpoint } from '@furystack/rest'
 import '@furystack/repository'
 import { JsonResult, RequestAction } from '../request-action-implementation'
+import { getRepository } from '@furystack/repository'
 
 /**
  * Creates a simple Get Entity endpoint for a specified model.
@@ -18,7 +19,7 @@ export const createGetEntityEndpoint = <T extends object, TPrimaryKey extends ke
   const endpoint: RequestAction<GetEntityEndpoint<T, TPrimaryKey>> = async ({ injector, getUrlParams, getQuery }) => {
     const { id } = getUrlParams()
     const { select } = getQuery()
-    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
     const entry = await dataSet.get(injector, id, select)
     if (!entry) {
       throw new RequestError('Entity not found', 404)

package/src/endpoint-generators/create-patch-endpoint.spec.ts

@@ -4,12 +4,15 @@ import { PatchEndpoint } from '@furystack/rest'
 import { createPatchEndpoint } from './create-patch-endpoint'
 import got from 'got'
 import { MockClass, setupContext } from './utils'
+import { getDataSetFor } from '@furystack/repository'
+import { useRestService } from '../helpers'
 
 describe('createPatchEndpoint', () => {
   it('Should update the entity and report the success', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ PATCH: { '/:id': PatchEndpoint<MockClass, 'id'> } }>({
+      await useRestService<{ PATCH: { '/:id': PatchEndpoint<MockClass, 'id'> } }>({
+        injector: i,
         root: '/api',
         port: 1116,
         api: {
@@ -18,9 +21,9 @@ describe('createPatchEndpoint', () => {
           },
         },
       })
-      await i.getDataSetFor(MockClass, 'id').add(i, { id: 'mock', value: 'mock' })
+      await getDataSetFor(i, MockClass, 'id').add(i, { id: 'mock', value: 'mock' })
 
-      const countBeforeDelete = await i.getDataSetFor(MockClass, 'id').count(i)
+      const countBeforeDelete = await getDataSetFor(i, MockClass, 'id').count(i)
       expect(countBeforeDelete).toBe(1)
 
       const response = await got('http://127.0.0.1:1116/api/mock', {
@@ -29,7 +32,7 @@ describe('createPatchEndpoint', () => {
       })
       expect(response.statusCode).toBe(200)
       expect(response.body).toBe('{}')
-      const updated = await i.getDataSetFor(MockClass, 'id').get(i, 'mock')
+      const updated = await getDataSetFor(i, MockClass, 'id').get(i, 'mock')
       expect(updated?.value).toBe('updated')
     })
   })

package/src/endpoint-generators/create-patch-endpoint.ts

@@ -3,6 +3,7 @@ import { PatchEndpoint } from '@furystack/rest'
 import '@furystack/repository'
 import '../incoming-message-extensions'
 import { JsonResult, RequestAction } from '../request-action-implementation'
+import { getRepository } from '@furystack/repository'
 
 /**
  * Creates a PATCH endpoint for updating entities
@@ -19,7 +20,7 @@ export const createPatchEndpoint = <T extends object, TPrimaryKey extends keyof
   const endpoint: RequestAction<PatchEndpoint<T, TPrimaryKey>> = async ({ injector, request, getUrlParams }) => {
     const { id } = getUrlParams()
     const patchData = await request.readPostBody<T>()
-    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
     await dataSet.update(injector, id, patchData)
     return JsonResult({})
   }

package/src/endpoint-generators/create-post-endpoint.spec.ts

@@ -4,12 +4,15 @@ import { PostEndpoint } from '@furystack/rest'
 import { createPostEndpoint } from './create-post-endpoint'
 import got from 'got'
 import { MockClass, setupContext } from './utils'
+import { useRestService } from '../helpers'
+import { getDataSetFor } from '@furystack/repository'
 
 describe('createPostEndpoint', () => {
   it('Should create the entity and report the success', async () => {
     await usingAsync(new Injector(), async (i) => {
       setupContext(i)
-      await i.useRestService<{ POST: { '/:id': PostEndpoint<MockClass, 'id'> } }>({
+      await useRestService<{ POST: { '/:id': PostEndpoint<MockClass, 'id'> } }>({
+        injector: i,
         root: '/api',
         port: 1117,
         api: {
@@ -25,7 +28,7 @@ describe('createPostEndpoint', () => {
       })
       expect(response.statusCode).toBe(201)
       expect(JSON.parse(response.body)).toStrictEqual(entityToPost)
-      const posted = await i.getDataSetFor(MockClass, 'id').get(i, entityToPost.id)
+      const posted = await getDataSetFor(i, MockClass, 'id').get(i, entityToPost.id)
       expect(posted?.value).toBe('posted')
     })
   })

package/src/endpoint-generators/create-post-endpoint.ts

@@ -4,6 +4,7 @@ import '@furystack/repository'
 import '../incoming-message-extensions'
 import { JsonResult, RequestAction } from '../request-action-implementation'
 import { WithOptionalId } from '@furystack/core'
+import { getRepository } from '@furystack/repository'
 /**
  * Creates a POST endpoint for updating entities
  *
@@ -17,7 +18,7 @@ export const createPostEndpoint = <T extends object, TPrimaryKey extends keyof T
   primaryKey: TPrimaryKey
 }) => {
   const endpoint: RequestAction<PostEndpoint<T, TPrimaryKey>> = async ({ injector, request }) => {
-    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
 
     const entityToCreate = await request.readPostBody<WithOptionalId<T, typeof dataSet['primaryKey']>>()
     const { created } = await dataSet.add(injector, entityToCreate)

package/src/endpoint-generators/utils.ts

@@ -1,8 +1,9 @@
 import { Injector } from '@furystack/inject'
-import { InMemoryStore, User } from '@furystack/core'
+import { addStore, InMemoryStore, User } from '@furystack/core'
 import { DefaultSession } from '../models/default-session'
 import '@furystack/repository'
-import '../injector-extensions'
+import '../helpers'
+import { getRepository } from '@furystack/repository'
 
 export class MockClass {
   id!: string
@@ -10,25 +11,24 @@ export class MockClass {
 }
 
 export const setupContext = (i: Injector) => {
-  i.setupStores((b) =>
-    b
-      .addStore(
-        new InMemoryStore({
-          model: MockClass,
-          primaryKey: 'id',
-        }),
-      )
-      .addStore(
-        new InMemoryStore({
-          model: User,
-          primaryKey: 'username',
-        }),
-      )
-      .addStore(
-        new InMemoryStore({
-          model: DefaultSession,
-          primaryKey: 'sessionId',
-        }),
-      ),
-  ).setupRepository((r) => r.createDataSet(MockClass, 'id'))
+  addStore(
+    i,
+    new InMemoryStore({
+      model: MockClass,
+      primaryKey: 'id',
+    }),
+  )
+    .addStore(
+      new InMemoryStore({
+        model: User,
+        primaryKey: 'username',
+      }),
+    )
+    .addStore(
+      new InMemoryStore({
+        model: DefaultSession,
+        primaryKey: 'sessionId',
+      }),
+    )
+  getRepository(i).createDataSet(MockClass, 'id')
 }

package/src/helpers.spec.ts

@@ -0,0 +1,24 @@
+import { Injector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { useHttpAuthentication } from './helpers'
+
+describe('Injector extensions', () => {
+  describe('useHttpAuthentication', () => {
+    it('Should set up HTTP Authentication', async () => {
+      await usingAsync(new Injector(), async (i) => {
+        useHttpAuthentication(i)
+        // TODO: Check if HTTP Auth has been set up
+      })
+    })
+  })
+
+  describe('useRestService()', () => {
+    it.todo(
+      'Should set up a REST service',
+      // await usingAsync(new Injector(), async (i) => {
+      //   useRestService({ injector: i, api: {},  })
+      //   TODO: Assert if REST service has been set up
+      // })
+    )
+  })
+})

package/src/helpers.ts

@@ -0,0 +1,28 @@
+import { User } from '@furystack/core'
+import { Injector } from '@furystack/inject'
+import { HttpAuthenticationSettings } from './http-authentication-settings'
+import { RestApi } from '@furystack/rest'
+import { ApiManager, ImplementApiOptions } from './api-manager'
+import { DefaultSession } from './models/default-session'
+
+/**
+ * Sets up the @furystack/rest-service with the provided settings
+ *
+ * @param api The API implementation details
+ */
+export const useRestService = async <T extends RestApi>(api: ImplementApiOptions<T>) => {
+  await api.injector.getInstance(ApiManager).addApi({ ...api })
+  return this
+}
+
+/**
+ * Sets up the HTTP Authentication
+ *
+ * @param injector  The Injector instance
+ * @param settings Settings for HTTP Authentication
+ * @returns void
+ */
+export const useHttpAuthentication = <TUser extends User, TSession extends DefaultSession>(
+  injector: Injector,
+  settings?: Partial<HttpAuthenticationSettings<TUser, TSession>>,
+) => injector.setExplicitInstance({ ...new HttpAuthenticationSettings(), ...settings }, HttpAuthenticationSettings)

package/src/http-user-context.spec.ts

@@ -1,22 +1,18 @@
 import { IncomingMessage, ServerResponse } from 'http'
 import { usingAsync } from '@furystack/utils'
 import { Injector } from '@furystack/inject'
-import { User, StoreManager, InMemoryStore } from '@furystack/core'
+import { User, StoreManager, InMemoryStore, addStore } from '@furystack/core'
 import { DefaultSession } from './models/default-session'
 import { HttpUserContext } from './http-user-context'
-import './injector-extensions'
 import { PasswordAuthenticator, PasswordCredential, UnauthenticatedError } from '@furystack/security'
+import { useHttpAuthentication } from './helpers'
 
 export const prepareInjector = async (i: Injector) => {
-  i.setupStores((sm) =>
-    sm
-      .addStore(new InMemoryStore({ model: User, primaryKey: 'username' }))
-      .addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
-      .addStore(new InMemoryStore({ model: PasswordCredential, primaryKey: 'userName' })),
-  )
+  addStore(i, new InMemoryStore({ model: User, primaryKey: 'username' }))
+    .addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
+    .addStore(new InMemoryStore({ model: PasswordCredential, primaryKey: 'userName' }))
 
-  i.useHttpAuthentication()
-  // await i.getInstance(ServerManager).getOrCreate({ port: 19999 })
+  useHttpAuthentication(i)
 }
 
 const setupUser = async (i: Injector, userName: string, password: string) => {

package/src/http-user-context.ts

@@ -1,10 +1,10 @@
 import { IncomingMessage, ServerResponse } from 'http'
 import { User, StoreManager } from '@furystack/core'
 import { Injectable } from '@furystack/inject'
-import { v1 } from 'uuid'
 import { HttpAuthenticationSettings } from './http-authentication-settings'
-import { DefaultSession } from 'models/default-session'
+import { DefaultSession } from './models/default-session'
 import { PasswordAuthenticator, UnauthenticatedError } from '@furystack/security'
+import { randomBytes } from 'crypto'
 
 /**
  * Injectable UserContext for FuryStack HTTP Api
@@ -142,7 +142,7 @@ export class HttpUserContext {
    * @returns the current User
    */
   public async cookieLogin(user: User, serverResponse: ServerResponse): Promise<User> {
-    const sessionId = v1()
+    const sessionId = randomBytes(32).toString('hex')
     await this.getSessionStore().add({ sessionId, username: user.username })
     serverResponse.setHeader('Set-Cookie', `${this.authentication.cookieName}=${sessionId}; Path=/; HttpOnly`)
     this.user = user

package/src/index.ts

@@ -1,4 +1,4 @@
-import './injector-extensions'
+export * from './helpers'
 export * from './api-manager'
 export * from './actions'
 export * from './authenticate'

package/src/rest-service.integration.spec.ts

@@ -1,12 +1,13 @@
 import { Injector } from '@furystack/inject'
-import './injector-extensions'
+import './helpers'
 import { usingAsync, PathHelper } from '@furystack/utils'
 import { GetCurrentUser, IsAuthenticated, LoginAction, LogoutAction } from './actions'
 import { RestApi } from '@furystack/rest'
-import { User, InMemoryStore } from '@furystack/core'
+import { User, InMemoryStore, addStore } from '@furystack/core'
 import { DefaultSession } from './models/default-session'
 import got from 'got'
 import { JsonResult } from './request-action-implementation'
+import { useHttpAuthentication, useRestService } from './helpers'
 
 class UserWithPassword extends User {
   password!: string
@@ -30,43 +31,42 @@ const port = 19090
 const hostName = 'localhost'
 const root = 'test-api'
 
-const prepareInjector = (i: Injector) =>
-  i
-    .setupStores((sm) =>
-      sm
-        .addStore(new InMemoryStore({ model: User, primaryKey: 'username' }))
-        .addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' })),
-    )
-    .useHttpAuthentication({
-      getUserStore: (sm) => sm.getStoreFor(UserWithPassword, 'username'),
-      getSessionStore: (sm) => sm.getStoreFor(DefaultSession, 'sessionId'),
-    })
-    .useRestService<IntegrationTestApi>({
-      root,
-      port,
-      hostName,
-      cors: {
-        credentials: true,
-        origins: ['http://localhost:8080'],
-        headers: ['cache', 'content-type'],
+const prepareInjector = async (i: Injector) => {
+  addStore(i, new InMemoryStore({ model: User, primaryKey: 'username' })).addStore(
+    new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }),
+  )
+  useHttpAuthentication(i, {
+    getUserStore: (sm) => sm.getStoreFor(UserWithPassword, 'username'),
+    getSessionStore: (sm) => sm.getStoreFor(DefaultSession, 'sessionId'),
+  })
+  await useRestService<IntegrationTestApi>({
+    injector: i,
+    root,
+    port,
+    hostName,
+    cors: {
+      credentials: true,
+      origins: ['http://localhost:8080'],
+      headers: ['cache', 'content-type'],
+    },
+    api: {
+      GET: {
+        '/currentUser': GetCurrentUser,
+        '/isAuthenticated': IsAuthenticated,
+        '/testQuery': async (options) => JsonResult({ param1Value: options.getQuery().param1 }),
+        '/testUrlParams/:urlParam': async (options) => JsonResult({ urlParamValue: options.getUrlParams().urlParam }),
       },
-      api: {
-        GET: {
-          '/currentUser': GetCurrentUser,
-          '/isAuthenticated': IsAuthenticated,
-          '/testQuery': async (options) => JsonResult({ param1Value: options.getQuery().param1 }),
-          '/testUrlParams/:urlParam': async (options) => JsonResult({ urlParamValue: options.getUrlParams().urlParam }),
-        },
-        POST: {
-          '/login': LoginAction,
-          '/logout': LogoutAction,
-          '/testPostBody': async (options) => {
-            const body = await options.getBody()
-            return JsonResult({ bodyValue: body.value })
-          },
+      POST: {
+        '/login': LoginAction,
+        '/logout': LogoutAction,
+        '/testPostBody': async (options) => {
+          const body = await options.getBody()
+          return JsonResult({ bodyValue: body.value })
         },
       },
-    })
+    },
+  })
+}
 
 const apiUrl = PathHelper.joinPaths(`http://${hostName}:${port}`, root)