@furystack/rest-service 13.0.0 → 14.1.0

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
 }

package/src/endpoint-generators/create-get-openapi-document-action.ts

@@ -1,16 +1,16 @@
 import type { Injector } from '@furystack/inject'
 import type { ApiDocumentMetadata, OpenApiDocument, RestApi, SecuritySchemeObject } from '@furystack/rest'
 
-import type { RestApiImplementation } from '../api-manager.js'
 import { getSchemaFromApi } from '../get-schema-from-api.js'
 import { HttpAuthenticationSettings } from '../http-authentication-settings.js'
 import { mapProvidersToSecuritySchemes } from '../openapi/auth-provider-to-security-scheme.js'
 import { generateOpenApiDocument } from '../openapi/generate-openapi-document.js'
 import { JsonResult, type RequestAction } from '../request-action-implementation.js'
+import type { RestApiImplementation } from '../rest-api-runtime.js'
 
 const getSecuritySchemesFromInjector = (injector: Injector): Record<string, SecuritySchemeObject> | undefined => {
   try {
-    const settings = injector.getInstance(HttpAuthenticationSettings)
+    const settings = injector.get(HttpAuthenticationSettings)
     if (settings.authenticationProviders.length > 0) {
       return mapProvidersToSecuritySchemes(settings.authenticationProviders)
     }

package/src/endpoint-generators/create-get-schema-action.ts

@@ -1,7 +1,7 @@
 import { RequestError } from '@furystack/rest'
-import type { RestApiImplementation } from '../api-manager.js'
 import { getSchemaFromApi } from '../get-schema-from-api.js'
 import { JsonResult, type RequestAction } from '../request-action-implementation.js'
+import type { RestApiImplementation } from '../rest-api-runtime.js'
 
 export type GetSchemaResult = ReturnType<typeof getSchemaFromApi>
 

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

@@ -1,42 +1,35 @@
 import { getPort } from '@furystack/core/port-generator'
-import { Injector } from '@furystack/inject'
-import { getDataSetFor } from '@furystack/repository'
+import { createInjector } from '@furystack/inject'
 import type { PatchEndpoint } from '@furystack/rest'
 import { usingAsync } from '@furystack/utils'
 import { describe, expect, it } from 'vitest'
 import { useRestService } from '../helpers.js'
 import { createPatchEndpoint } from './create-patch-endpoint.js'
-import { MockClass, setupContext } from './utils.js'
+import type { MockClass } from './utils.js'
+import { MockDataSet, setupContext } from './utils.js'
 
 describe('createPatchEndpoint', () => {
-  it('Should update the entity and report the success', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('updates the entity and responds 200', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ PATCH: { '/:id': PatchEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          PATCH: {
-            '/:id': createPatchEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { PATCH: { '/:id': createPatchEndpoint(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: 'PATCH',
         body: JSON.stringify({ value: 'updated' }),
       })
       expect(response.status).toBe(200)
-      const body = (await response.json()) as { value: string }
-      expect(body).toEqual({})
-      const updated = await getDataSetFor(i, MockClass, 'id').get(i, 'mock')
-      expect(updated?.value).toBe('updated')
+      expect(await response.json()).toEqual({})
+      expect((await dataSet.get(i, 'mock'))?.value).toBe('updated')
     })
   })
 })

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

@@ -1,37 +1,26 @@
-import type { Constructable } from '@furystack/inject'
-import type { PatchEndpoint } from '@furystack/rest'
-import '@furystack/repository'
-import type { RequestAction } from '../request-action-implementation.js'
-import { JsonResult } from '../request-action-implementation.js'
-import { getRepository } from '@furystack/repository'
 import type { WithOptionalId } from '@furystack/core'
+import type { DataSetToken } from '@furystack/repository'
+import type { PatchEndpoint } from '@furystack/rest'
 import { readPostBody } from '../read-post-body.js'
+import { JsonResult, type RequestAction } from '../request-action-implementation.js'
 
 /**
- * Creates a PATCH endpoint for updating entities
- * @param options The options for endpoint creation
- * @param options.model The Model class
- * @param options.primaryKey The field name that is used as primary key on the model
- * @returns a boolean that indicates the success
+ * Creates a PATCH endpoint that applies a partial update to an entity
+ * identified by the URL's `:id` parameter. The DataSet is resolved from the
+ * supplied {@link DataSetToken}.
  */
 export const createPatchEndpoint = <
   T extends object,
   TPrimaryKey extends keyof T,
   TWritableData = WithOptionalId<T, TPrimaryKey>,
->(options: {
-  model: Constructable<T>
-  primaryKey: TPrimaryKey
-}) => {
-  const endpoint: RequestAction<PatchEndpoint<T, TPrimaryKey, TWritableData>> = async ({
-    injector,
-    request,
-    getUrlParams,
-  }) => {
+>(
+  dataSet: DataSetToken<T, TPrimaryKey, TWritableData>,
+): RequestAction<PatchEndpoint<T, TPrimaryKey, TWritableData>> => {
+  return async ({ injector, request, getUrlParams }) => {
     const { id } = getUrlParams()
     const patchData = await readPostBody<T>(request)
-    const dataSet = getRepository(injector).getDataSetFor(options.model, options.primaryKey)
-    await dataSet.update(injector, id, patchData)
+    const ds = injector.get(dataSet)
+    await ds.update(injector, id, patchData)
     return JsonResult({})
   }
-  return endpoint
 }