@furystack/rest-service 4.0.19

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

@@ -0,0 +1,25 @@
+import { Constructable } from '@furystack/inject'
+import { DeleteEndpoint } from '@furystack/rest'
+import '@furystack/repository'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * 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
+ */
+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 }) => {
+    const { id } = getUrlParams()
+    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+    await dataSet.remove(injector, id)
+    return JsonResult({}, 204)
+  }
+  return endpoint
+}

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

@@ -0,0 +1,164 @@
+import { usingAsync } from '@furystack/utils'
+import { Injector } from '@furystack/inject'
+import got from 'got'
+import { MockClass, setupContext } from './utils'
+import { createGetCollectionEndpoint } from './create-get-collection-endpoint'
+import { GetCollectionEndpoint, GetCollectionResult, serializeToQueryString } from '@furystack/rest'
+import { FindOptions } from '@furystack/core'
+
+const addMockEntities = async (i: Injector) =>
+  await i
+    .getDataSetFor(MockClass, 'id')
+    .add(
+      i,
+      { id: 'mock1', value: '4' },
+      { id: 'mock2', value: '3' },
+      { id: 'mock3', value: '2' },
+      { id: 'mock4', value: '1' },
+    )
+
+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> } }>({
+        root: '/api',
+        port: 1112,
+        api: {
+          GET: {
+            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      await addMockEntities(i)
+
+      const count = await i.getDataSetFor(MockClass, 'id').count(i)
+      const allEntities = await i.getDataSetFor(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)
+      expect(json.count).toBe(count)
+      expect(json.entries).toEqual(allEntities)
+    })
+  })
+
+  it('Should return entities in order', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      setupContext(i)
+      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        root: '/api',
+        port: 1113,
+        api: {
+          GET: {
+            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      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 response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+        method: 'GET',
+      })
+      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      expect(json.count).toBe(count)
+      expect(json.entries).toEqual(orderedEntities)
+    })
+  })
+
+  it('Should return entities with filtering', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      setupContext(i)
+      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        root: '/api',
+        port: 1113,
+        api: {
+          GET: {
+            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      await addMockEntities(i)
+      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = {
+        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)
+
+      expect(filteredEntities).not.toContainEqual({ id: 'mock2', value: '3' })
+
+      const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+        method: 'GET',
+      })
+      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      expect(json.count).toBe(count)
+      expect(json.entries).toEqual(filteredEntities)
+    })
+  })
+
+  it('Should return entities with selecting specific fields', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      setupContext(i)
+      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        root: '/api',
+        port: 1113,
+        api: {
+          GET: {
+            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      await addMockEntities(i)
+      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = {
+        select: ['id'],
+      }
+
+      const count = await i.getDataSetFor(MockClass, 'id').count(i, findOptions.filter)
+      const selectedEntities = await i.getDataSetFor(MockClass, 'id').find(i, findOptions)
+
+      selectedEntities.forEach((e) => expect(e.value).toBeUndefined())
+
+      const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+        method: 'GET',
+      })
+      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      expect(json.count).toBe(count)
+      expect(json.entries).toEqual(selectedEntities)
+    })
+  })
+
+  it('Should return entities with top/skip', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      setupContext(i)
+      await i.useRestService<{ GET: { '/entities': GetCollectionEndpoint<MockClass> } }>({
+        root: '/api',
+        port: 1113,
+        api: {
+          GET: {
+            '/entities': createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      await addMockEntities(i)
+      const findOptions: FindOptions<MockClass, Array<keyof MockClass>> = {
+        skip: 1,
+        top: 2,
+      }
+
+      const count = await i.getDataSetFor(MockClass, 'id').count(i, findOptions.filter)
+      const topSkipEntities = await i.getDataSetFor(MockClass, 'id').find(i, findOptions)
+
+      expect(topSkipEntities).not.toContainEqual({ id: 'mock1', value: '4' })
+      expect(topSkipEntities).not.toContainEqual({ id: 'mock4', value: '1' })
+
+      const response = await got(`http://127.0.0.1:1113/api/entities?${serializeToQueryString({ findOptions })}`, {
+        method: 'GET',
+      })
+      const json: GetCollectionResult<MockClass> = JSON.parse(response.body)
+      expect(json.count).toBe(count)
+      expect(json.entries).toEqual(topSkipEntities)
+    })
+  })
+})

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

@@ -0,0 +1,28 @@
+import { Constructable } from '@furystack/inject'
+import { GetCollectionEndpoint } from '@furystack/rest'
+import '@furystack/repository'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * 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
+ */
+export const createGetCollectionEndpoint = <T, TPrimaryKey extends keyof T>(options: {
+  model: Constructable<T>
+  primaryKey: TPrimaryKey
+}) => {
+  const endpoint: RequestAction<GetCollectionEndpoint<T>> = async ({ injector, getQuery }) => {
+    const { findOptions } = getQuery()
+    const dataSet = 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])
+
+    return JsonResult({ entries, count })
+  }
+  return endpoint
+}

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

@@ -0,0 +1,75 @@
+import { usingAsync } from '@furystack/utils'
+import { Injector } from '@furystack/inject'
+import { GetEntityEndpoint, serializeToQueryString } from '@furystack/rest'
+import got, { HTTPError } from 'got'
+import { MockClass, setupContext } from './utils'
+import { createGetEntityEndpoint } from './create-get-entity-endpoint'
+
+describe('createGetEntityEndpoint', () => {
+  it('Should return the entity', async () => {
+    await usingAsync(new Injector(), async (i) => {
+      setupContext(i)
+      await i.useRestService<{ GET: { '/:id': GetEntityEndpoint<MockClass, 'id'> } }>({
+        root: '/api',
+        port: 1113,
+        api: {
+          GET: {
+            '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      const mockEntity: MockClass = { id: 'mock', value: 'mock' }
+      await i.getDataSetFor(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)
+    })
+  })
+
+  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'> } }>({
+        root: '/api',
+        port: 1114,
+        api: {
+          GET: {
+            '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      const mockEntity: MockClass = { id: 'mock', value: 'mock' }
+      await i.getDataSetFor(MockClass, 'id').add(i, mockEntity)
+
+      const response = await got(`http://127.0.0.1:1114/api/mock?${serializeToQueryString({ select: ['id'] })}`, {
+        method: 'GET',
+      })
+      expect(JSON.parse(response.body)).toStrictEqual({ id: mockEntity.id })
+    })
+  })
+
+  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'> } }>({
+        root: '/api',
+        port: 1115,
+        api: {
+          GET: {
+            '/:id': createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      await new Promise<void>((resolve, reject) => {
+        got(`http://127.0.0.1:1115/api/mock`, { method: 'GET' })
+          .then(() => reject('Should throw'))
+          .catch((err) => {
+            const e: HTTPError = err
+            expect(e.response.statusCode).toBe(404)
+            expect(JSON.parse(e.response.body as string).message).toBe('Entity not found')
+            resolve()
+          })
+      })
+    })
+  })
+})

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

@@ -0,0 +1,29 @@
+import { Constructable } from '@furystack/inject'
+import { RequestError, GetEntityEndpoint } from '@furystack/rest'
+import '@furystack/repository'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * 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
+ */
+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 }) => {
+    const { id } = getUrlParams()
+    const { select } = getQuery()
+    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+    const entry = await dataSet.get(injector, id, select)
+    if (!entry) {
+      throw new RequestError('Entity not found', 404)
+    }
+    return JsonResult(entry)
+  }
+  return endpoint
+}

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

@@ -0,0 +1,36 @@
+import { usingAsync } from '@furystack/utils'
+import { Injector } from '@furystack/inject'
+import { PatchEndpoint } from '@furystack/rest'
+import { createPatchEndpoint } from './create-patch-endpoint'
+import got from 'got'
+import { MockClass, setupContext } from './utils'
+
+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'> } }>({
+        root: '/api',
+        port: 1116,
+        api: {
+          PATCH: {
+            '/:id': createPatchEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      await i.getDataSetFor(MockClass, 'id').add(i, { id: 'mock', value: 'mock' })
+
+      const countBeforeDelete = await i.getDataSetFor(MockClass, 'id').count(i)
+      expect(countBeforeDelete).toBe(1)
+
+      const response = await got('http://127.0.0.1:1116/api/mock', {
+        method: 'PATCH',
+        body: JSON.stringify({ value: 'updated' }),
+      })
+      expect(response.statusCode).toBe(200)
+      expect(response.body).toBe('{}')
+      const updated = await i.getDataSetFor(MockClass, 'id').get(i, 'mock')
+      expect(updated?.value).toBe('updated')
+    })
+  })
+})

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

@@ -0,0 +1,27 @@
+import { Constructable } from '@furystack/inject'
+import { PatchEndpoint } from '@furystack/rest'
+import '@furystack/repository'
+import '../incoming-message-extensions'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+
+/**
+ * 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
+ */
+export const createPatchEndpoint = <T extends object, TPrimaryKey extends keyof T>(options: {
+  model: Constructable<T>
+  primaryKey: TPrimaryKey
+}) => {
+  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)
+    await dataSet.update(injector, id, patchData)
+    return JsonResult({})
+  }
+  return endpoint
+}

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

@@ -0,0 +1,32 @@
+import { usingAsync } from '@furystack/utils'
+import { Injector } from '@furystack/inject'
+import { PostEndpoint } from '@furystack/rest'
+import { createPostEndpoint } from './create-post-endpoint'
+import got from 'got'
+import { MockClass, setupContext } from './utils'
+
+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'> } }>({
+        root: '/api',
+        port: 1117,
+        api: {
+          POST: {
+            '/:id': createPostEndpoint({ model: MockClass, primaryKey: 'id' }),
+          },
+        },
+      })
+      const entityToPost = { id: 'mock', value: 'posted' }
+      const response = await got('http://127.0.0.1:1117/api/mock', {
+        method: 'POST',
+        body: JSON.stringify(entityToPost),
+      })
+      expect(response.statusCode).toBe(201)
+      expect(JSON.parse(response.body)).toStrictEqual(entityToPost)
+      const posted = await i.getDataSetFor(MockClass, 'id').get(i, entityToPost.id)
+      expect(posted?.value).toBe('posted')
+    })
+  })
+})

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

@@ -0,0 +1,30 @@
+import { Constructable } from '@furystack/inject'
+import { RequestError, PostEndpoint } from '@furystack/rest'
+import '@furystack/repository'
+import '../incoming-message-extensions'
+import { JsonResult, RequestAction } from '../request-action-implementation'
+import { WithOptionalId } from '@furystack/core'
+/**
+ * Creates a POST endpoint for updating entities
+ *
+ * @param options The options for endpoint creation
+ * @param options.model The Model class
+ * @param options.primaryKey The field name used as primary key
+ * @returns a boolean that indicates the success
+ */
+export const createPostEndpoint = <T extends object, TPrimaryKey extends keyof T>(options: {
+  model: Constructable<T>
+  primaryKey: TPrimaryKey
+}) => {
+  const endpoint: RequestAction<PostEndpoint<T, TPrimaryKey>> = async ({ injector, request }) => {
+    const dataSet = injector.getDataSetFor(options.model, options.primaryKey)
+
+    const entityToCreate = await request.readPostBody<WithOptionalId<T, typeof dataSet['primaryKey']>>()
+    const { created } = await dataSet.add(injector, entityToCreate)
+    if (!created || !created.length) {
+      throw new RequestError('Entity not found', 404)
+    }
+    return JsonResult(created[0], 201)
+  }
+  return endpoint
+}