@furystack/rest-service 12.3.5 → 14.0.0

package/src/authorize.spec.ts

@@ -1,6 +1,6 @@
 import type { User } from '@furystack/core'
 import { AuthorizationError, IdentityContext } from '@furystack/core'
-import { Injector } from '@furystack/inject'
+import { createInjector } from '@furystack/inject'
 import { usingAsync } from '@furystack/utils'
 import type { IncomingMessage, ServerResponse } from 'http'
 import { describe, expect, it, vi } from 'vitest'
@@ -8,59 +8,57 @@ import { Authorize } from './authorize.js'
 import { EmptyResult } from './request-action-implementation.js'
 
 describe('Authorize', () => {
-  const response = {} as any as ServerResponse
+  const response = {} as ServerResponse
   const request = { url: 'http://google.com' } as IncomingMessage
 
-  it('Should return 403 when failed to get current user', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const isAuthorizedAction = vi.fn(async () => false)
-      i.setExplicitInstance(
-        { isAuthorized: isAuthorizedAction, getCurrentUser: () => Promise.reject(new Error(':(')) },
-        IdentityContext,
-      )
-      const exampleAuthorizedAction = vi.fn(async () => EmptyResult())
-      const authorized = Authorize('Role1')(exampleAuthorizedAction)
+  it('throws AuthorizationError when the current user cannot be resolved', async () => {
+    await usingAsync(createInjector(), async (i) => {
+      const isAuthorized = vi.fn(async () => false)
+      i.bind(IdentityContext, () => ({
+        isAuthorized,
+        getCurrentUser: () => Promise.reject(new Error(':(')),
+        isAuthenticated: () => Promise.resolve(false),
+      }))
+      const exampleAction = vi.fn(async () => EmptyResult())
+      const authorized = Authorize('Role1')(exampleAction)
 
       await expect(() => authorized({ injector: i, request, response })).rejects.toThrow(AuthorizationError)
-      expect(exampleAuthorizedAction).not.toBeCalled()
+      expect(exampleAction).not.toHaveBeenCalled()
     })
   })
 
-  it('Should return 403 if the current user does not have the role', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const isAuthorizedAction = vi.fn(async () => false)
-      i.setExplicitInstance(
-        {
-          isAuthorized: isAuthorizedAction,
-          getCurrentUser: async () => Promise.resolve<User>({ username: 'a', roles: ['Role1'] }),
-        },
-        IdentityContext,
-      )
-      const exampleAuthorizedAction = vi.fn(async () => EmptyResult())
-      const authorized = Authorize('Role2')(exampleAuthorizedAction)
+  it('throws AuthorizationError when the current user does not have the required role', async () => {
+    await usingAsync(createInjector(), async (i) => {
+      const isAuthorized = vi.fn(async () => false)
+      i.bind(IdentityContext, () => ({
+        isAuthorized,
+        getCurrentUser: <TUser extends User>() =>
+          Promise.resolve({ username: 'a', roles: ['Role1'] } as unknown as TUser),
+        isAuthenticated: () => Promise.resolve(true),
+      }))
+      const exampleAction = vi.fn(async () => EmptyResult())
+      const authorized = Authorize('Role2')(exampleAction)
 
       await expect(() => authorized({ injector: i, request, response })).rejects.toThrow(AuthorizationError)
-      expect(exampleAuthorizedAction).not.toBeCalled()
+      expect(exampleAction).not.toHaveBeenCalled()
     })
   })
 
-  it('Should exec the original action if authorized', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const isAuthorizedAction = vi.fn(async () => true)
-      i.setExplicitInstance(
-        {
-          isAuthorized: isAuthorizedAction,
-          getCurrentUser: async () => Promise.resolve<User>({ username: 'a', roles: ['Role1'] }),
-        },
-        IdentityContext,
-      )
-      const exampleAuthorizedAction = vi.fn(async () => EmptyResult())
-      const authorized = Authorize('Role1')(exampleAuthorizedAction)
-      const params = { injector: i, body: undefined, query: undefined, request, response }
+  it('invokes the wrapped action when the current user holds the required role', async () => {
+    await usingAsync(createInjector(), async (i) => {
+      i.bind(IdentityContext, () => ({
+        isAuthorized: () => Promise.resolve(true),
+        getCurrentUser: <TUser extends User>() =>
+          Promise.resolve({ username: 'a', roles: ['Role1'] } as unknown as TUser),
+        isAuthenticated: () => Promise.resolve(true),
+      }))
+      const exampleAction = vi.fn(async () => EmptyResult())
+      const authorized = Authorize('Role1')(exampleAction)
+      const params = { injector: i, request, response }
       const result = await authorized(params)
       expect(result.statusCode).toBe(200)
       expect(result.chunk).toBe(undefined)
-      expect(exampleAuthorizedAction).toBeCalledWith(params)
+      expect(exampleAction).toHaveBeenCalledWith(params)
     })
   })
 })

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

@@ -1,40 +1,32 @@
-import { usingAsync } from '@furystack/utils'
-import { Injector } from '@furystack/inject'
+import { getPort } from '@furystack/core/port-generator'
+import { createInjector } from '@furystack/inject'
 import type { DeleteEndpoint } from '@furystack/rest'
-import { createDeleteEndpoint } from './create-delete-endpoint.js'
-import { MockClass, setupContext } from './utils.js'
+import { usingAsync } from '@furystack/utils'
+import { describe, expect, it } from 'vitest'
 import { useRestService } from '../helpers.js'
-import { getDataSetFor } from '@furystack/repository'
-import { describe, it, expect } from 'vitest'
-import { getPort } from '@furystack/core/port-generator'
+import { createDeleteEndpoint } from './create-delete-endpoint.js'
+import type { MockClass } from './utils.js'
+import { MockDataSet, setupContext } from './utils.js'
 
 describe('createDeleteEndpoint', () => {
-  it('Should delete the entity and report the success', async () => {
-    await usingAsync(new Injector(), async (i) => {
-      const port = getPort()
+  it('deletes the entity and responds 204', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
+      const port = getPort()
       await useRestService<{ DELETE: { '/:id': DeleteEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          DELETE: {
-            '/:id': createDeleteEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { DELETE: { '/:id': createDeleteEndpoint(MockDataSet) } },
       })
-      await getDataSetFor(i, MockClass, 'id').add(i, { id: 'mock', value: 'mock' })
-
-      const countBeforeDelete = await getDataSetFor(i, MockClass, 'id').count(i)
-      expect(countBeforeDelete).toBe(1)
+      const dataSet = i.get(MockDataSet)
+      await dataSet.add(i, { id: 'mock', value: 'mock' })
+      expect(await dataSet.count(i)).toBe(1)
 
       const response = await fetch(`http://127.0.0.1:${port}/api/mock`, { method: 'DELETE' })
       expect(response.status).toBe(204)
-      const txt = await response.text()
-      expect(txt).toBe('')
-
-      const countAfterDelete = await getDataSetFor(i, MockClass, 'id').count(i)
-      expect(countAfterDelete).toBe(0)
+      expect(await response.text()).toBe('')
+      expect(await dataSet.count(i)).toBe(0)
     })
   })
 })

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

@@ -1,25 +1,19 @@
-import type { Constructable } from '@furystack/inject'
+import type { DataSetToken } from '@furystack/repository'
 import type { DeleteEndpoint } from '@furystack/rest'
-import type { RequestAction } from '../request-action-implementation.js'
-import { JsonResult } from '../request-action-implementation.js'
-import { getRepository } from '@furystack/repository'
+import { JsonResult, type RequestAction } from '../request-action-implementation.js'
 
 /**
- * Creates a DELETE endpoint for removing entities
- * @param options The options for endpoint creation
- * @param options.model The Model class
- * @param options.primaryKey The field used as primary key on the model
- * @returns a boolean that indicates the success
+ * Creates a DELETE endpoint that removes the entity identified by the URL's
+ * `:id` parameter. Returns `204 No Content` once the removal has been
+ * persisted to the underlying store.
  */
-export const createDeleteEndpoint = <T extends object, TPrimaryKey extends keyof T>(options: {
-  model: Constructable<T>
-  primaryKey: TPrimaryKey
-}) => {
-  const endpoint: RequestAction<DeleteEndpoint<T, TPrimaryKey>> = async ({ injector, getUrlParams }) => {
+export const createDeleteEndpoint = <T extends object, TPrimaryKey extends keyof T>(
+  dataSet: DataSetToken<T, TPrimaryKey>,
+): RequestAction<DeleteEndpoint<T, TPrimaryKey>> => {
+  return async ({ injector, getUrlParams }) => {
     const { id } = getUrlParams()
-    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
-    await dataSet.remove(injector, id)
+    const ds = injector.get(dataSet)
+    await ds.remove(injector, id)
     return JsonResult({}, 204)
   }
-  return endpoint
 }

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

@@ -1,18 +1,18 @@
-import { usingAsync } from '@furystack/utils'
-import { Injector } from '@furystack/inject'
-import { MockClass, setupContext } from './utils.js'
-import { createGetCollectionEndpoint } from './create-get-collection-endpoint.js'
+import type { FindOptions } from '@furystack/core'
+import { getPort } from '@furystack/core/port-generator'
+import { createInjector, type Injector } from '@furystack/inject'
 import type { GetCollectionEndpoint, GetCollectionResult } from '@furystack/rest'
 import { serializeToQueryString } from '@furystack/rest'
-import type { FindOptions } from '@furystack/core'
-import { getDataSetFor, getRepository } from '@furystack/repository'
+import { usingAsync } from '@furystack/utils'
+import { describe, expect, it } from 'vitest'
 import { useRestService } from '../helpers.js'
-import { describe, it, expect } from 'vitest'
-import { getPort } from '@furystack/core/port-generator'
+import { createGetCollectionEndpoint } from './create-get-collection-endpoint.js'
+import type { MockClass } from './utils.js'
+import { MockDataSet, setupContext } from './utils.js'
 
 const addMockEntities = async (i: Injector) =>
-  await getRepository(i)
-    .getDataSetFor(MockClass, 'id')
+  i
+    .get(MockDataSet)
     .add(
       i,
       { id: 'mock1', value: '4' },
@@ -22,24 +22,21 @@ const addMockEntities = async (i: Injector) =>
     )
 
 describe('createGetCollectionEndpoint', () => {
-  it('Should return the collection without filter / order', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('returns the collection without filter / order', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/entities': createGetCollectionEndpoint(MockDataSet) } },
       })
       await addMockEntities(i)
 
-      const count = await getDataSetFor(i, MockClass, 'id').count(i)
-      const allEntities = await getDataSetFor(i, MockClass, 'id').find(i, {})
+      const dataSet = i.get(MockDataSet)
+      const count = await dataSet.count(i)
+      const allEntities = await dataSet.find(i, {})
 
       const response = await fetch(`http://127.0.0.1:${port}/api/entities`, { method: 'GET' })
       expect(response.ok).toBe(true)
@@ -50,24 +47,21 @@ describe('createGetCollectionEndpoint', () => {
     })
   })
 
-  it('Should return entities in order', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('returns entities in the requested order', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/entities': createGetCollectionEndpoint(MockDataSet) } },
       })
       await addMockEntities(i)
       const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = { order: { value: 'ASC' } }
-      const count = await getDataSetFor(i, MockClass, 'id').count(i, findOptions.filter)
-      const orderedEntities = await getDataSetFor(i, MockClass, 'id').find(i, findOptions)
+      const dataSet = i.get(MockDataSet)
+      const count = await dataSet.count(i, findOptions.filter)
+      const orderedEntities = await dataSet.find(i, findOptions)
       const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
@@ -79,29 +73,21 @@ describe('createGetCollectionEndpoint', () => {
     })
   })
 
-  it('Should return entities with filtering', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('applies a supplied filter', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/entities': createGetCollectionEndpoint(MockDataSet) } },
       })
       await addMockEntities(i)
-      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = {
-        filter: { id: { $ne: 'mock2' } },
-      }
-
-      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' })
+      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = { filter: { id: { $ne: 'mock2' } } }
+      const dataSet = i.get(MockDataSet)
+      const count = await dataSet.count(i, findOptions.filter)
+      const filteredEntities = await dataSet.find(i, findOptions)
 
       const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
@@ -114,67 +100,48 @@ describe('createGetCollectionEndpoint', () => {
     })
   })
 
-  it('Should return entities with selecting specific fields', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('applies select projection', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/entities': createGetCollectionEndpoint(MockDataSet) } },
       })
       await addMockEntities(i)
-      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = {
-        select: ['id'],
-      }
-
-      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())
+      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = { select: ['id'] }
+      const dataSet = i.get(MockDataSet)
+      const count = await dataSet.count(i, findOptions.filter)
+      const selected = await dataSet.find(i, findOptions)
 
       const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
       })
-
       expect(response.ok).toBe(true)
       const json = (await response.json()) as GetCollectionResult<MockClass>
       expect(response.status).toBe(200)
       expect(json.count).toBe(count)
-      expect(json.entries).toEqual(selectedEntities)
+      expect(json.entries).toEqual(selected)
     })
   })
 
-  it('Should return entities with top/skip', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('honours top/skip', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/entities': createGetCollectionEndpoint(MockDataSet) } },
       })
       await addMockEntities(i)
-      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = {
-        skip: 1,
-        top: 2,
-      }
-
-      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' })
+      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = { skip: 1, top: 2 }
+      const dataSet = i.get(MockDataSet)
+      const count = await dataSet.count(i, findOptions.filter)
+      const page = await dataSet.find(i, findOptions)
 
       const response = await fetch(`http://127.0.0.1:${port}/api/entities?${serializeToQueryString({ findOptions })}`, {
         method: 'GET',
@@ -182,7 +149,7 @@ describe('createGetCollectionEndpoint', () => {
       expect(response.status).toBe(200)
       const json = (await response.json()) as GetCollectionResult<MockClass>
       expect(json.count).toBe(count)
-      expect(json.entries).toEqual(topSkipEntities)
+      expect(json.entries).toEqual(page)
     })
   })
 })

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

@@ -1,28 +1,26 @@
-import type { Constructable } from '@furystack/inject'
+import type { DataSetToken } from '@furystack/repository'
 import type { GetCollectionEndpoint } from '@furystack/rest'
-import type { RequestAction } from '../request-action-implementation.js'
-import { JsonResult } from '../request-action-implementation.js'
-import { getRepository } from '@furystack/repository'
+import { JsonResult, type RequestAction } from '../request-action-implementation.js'
 
 /**
- * Creates a GetCollection endpoint for the given model. The model should have a Repository DataSet
- * @param options The options for endpoint creation
- * @param options.model The Model class
- * @param options.primaryKey The field used as primary key on the model
- * @returns The created endpoint
+ * Creates a GetCollection endpoint backed by the DataSet resolved from the
+ * provided {@link DataSetToken}. The token carries the entity model and
+ * primary key, so callers no longer need to pass them separately.
+ *
+ * @example
+ * ```ts
+ * const endpoint = createGetCollectionEndpoint(UserDataSet)
+ * ```
  */
-export const createGetCollectionEndpoint = <T, TPrimaryKey extends keyof T>(options: {
-  model: Constructable<T>
-  primaryKey: TPrimaryKey
-}) => {
-  const endpoint: RequestAction<GetCollectionEndpoint<T>> = async ({ injector, getQuery }) => {
+export const createGetCollectionEndpoint = <T, TPrimaryKey extends keyof T>(
+  dataSet: DataSetToken<T, TPrimaryKey>,
+): RequestAction<GetCollectionEndpoint<T>> => {
+  return async ({ injector, getQuery }) => {
     const { findOptions } = getQuery()
-    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
-    const entriesPromise = dataSet.find(injector, findOptions || {})
-    const countPromise = dataSet.count(injector, findOptions?.filter)
+    const ds = injector.get(dataSet)
+    const entriesPromise = ds.find(injector, findOptions || {})
+    const countPromise = ds.count(injector, findOptions?.filter)
     const [entries, count] = await Promise.all([entriesPromise, countPromise])
-
     return JsonResult({ entries, count })
   }
-  return endpoint
 }

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

@@ -1,83 +1,67 @@
 import { getPort } from '@furystack/core/port-generator'
-import { Injector } from '@furystack/inject'
-import { getDataSetFor } from '@furystack/repository'
+import { createInjector } from '@furystack/inject'
 import type { GetEntityEndpoint } from '@furystack/rest'
 import { serializeToQueryString } from '@furystack/rest'
 import { usingAsync } from '@furystack/utils'
 import { describe, expect, it } from 'vitest'
 import { useRestService } from '../helpers.js'
 import { createGetEntityEndpoint } from './create-get-entity-endpoint.js'
-import { MockClass, setupContext } from './utils.js'
+import type { MockClass } from './utils.js'
+import { MockDataSet, setupContext } from './utils.js'
 
 describe('createGetEntityEndpoint', () => {
-  it('Should return the entity', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('returns the entity by id', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/:id': createGetEntityEndpoint(MockDataSet) } },
       })
       const mockEntity: MockClass = { id: 'mock', value: 'mock' }
-      await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
+      await i.get(MockDataSet).add(i, mockEntity)
 
       const response = await fetch(`http://127.0.0.1:${port}/api/mock`, { method: 'GET' })
       expect(response.status).toBe(200)
-      const body = (await response.json()) as MockClass
-      expect(body).toEqual(mockEntity)
+      expect(await response.json()).toEqual(mockEntity)
     })
   })
 
-  it('Should return the entity with the selected fields', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('honours a select query parameter', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/:id': createGetEntityEndpoint(MockDataSet) } },
       })
-      const mockEntity: MockClass = { id: 'mock', value: 'mock' }
-      await getDataSetFor(i, MockClass, 'id').add(i, mockEntity)
+      await i.get(MockDataSet).add(i, { id: 'mock', value: 'mock' })
 
       const response = await fetch(`http://127.0.0.1:${port}/api/mock?${serializeToQueryString({ select: ['id'] })}`, {
         method: 'GET',
       })
       expect(response.status).toBe(200)
-      const body = (await response.json()) as { id: string }
-      expect(body).toEqual({ id: mockEntity.id })
+      expect(await response.json()).toEqual({ id: 'mock' })
     })
   })
 
-  it('Should return 404 if no entity has been found', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('responds with 404 when the entity does not exist', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          GET: {
-            '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { GET: { '/:id': createGetEntityEndpoint(MockDataSet) } },
       })
       const result = await fetch(`http://127.0.0.1:${port}/api/mock`, { method: 'GET' })
       expect(result.status).toBe(404)
-      const body = (await result.json()) as { message: string }
-      expect(body).toEqual({ message: 'Entity not found' })
+      expect(await result.json()).toEqual({ message: 'Entity not found' })
     })
   })
 })

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

@@ -1,30 +1,24 @@
-import type { Constructable } from '@furystack/inject'
+import type { DataSetToken } from '@furystack/repository'
 import type { GetEntityEndpoint } from '@furystack/rest'
 import { RequestError } from '@furystack/rest'
-import type { RequestAction } from '../request-action-implementation.js'
-import { JsonResult } from '../request-action-implementation.js'
-import { getRepository } from '@furystack/repository'
+import { JsonResult, type RequestAction } from '../request-action-implementation.js'
 
 /**
- * Creates a simple Get Entity endpoint for a specified model.
- * @param options The options for endpoint creation
- * @param options.model The entity model, should have a Repository DataSet
- * @param options.primaryKey The field name used as primary key on the model
- * @returns The generated endpoint
+ * Creates a GET entity endpoint backed by the DataSet resolved from the
+ * provided {@link DataSetToken}. Throws a 404 `RequestError` when the
+ * entity cannot be found.
  */
-export const createGetEntityEndpoint = <T extends object, TPrimaryKey extends keyof T>(options: {
-  model: Constructable<T>
-  primaryKey: TPrimaryKey
-}) => {
-  const endpoint: RequestAction<GetEntityEndpoint<T, TPrimaryKey>> = async ({ injector, getUrlParams, getQuery }) => {
+export const createGetEntityEndpoint = <T extends object, TPrimaryKey extends keyof T>(
+  dataSet: DataSetToken<T, TPrimaryKey>,
+): RequestAction<GetEntityEndpoint<T, TPrimaryKey>> => {
+  return async ({ injector, getUrlParams, getQuery }) => {
     const { id } = getUrlParams()
     const { select } = getQuery()
-    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
-    const entry = await dataSet.get(injector, id, select)
+    const ds = injector.get(dataSet)
+    const entry = await ds.get(injector, id, select)
     if (!entry) {
       throw new RequestError('Entity not found', 404)
     }
     return JsonResult(entry)
   }
-  return endpoint
 }