@furystack/rest-service 13.0.0 → 14.0.0

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

@@ -1,27 +1,23 @@
 import { getPort } from '@furystack/core/port-generator'
-import { Injector } from '@furystack/inject'
-import { getDataSetFor } from '@furystack/repository'
+import { createInjector } from '@furystack/inject'
 import type { PostEndpoint } from '@furystack/rest'
 import { usingAsync } from '@furystack/utils'
 import { describe, expect, it } from 'vitest'
 import { useRestService } from '../helpers.js'
 import { createPostEndpoint } from './create-post-endpoint.js'
-import { MockClass, setupContext } from './utils.js'
+import type { MockClass } from './utils.js'
+import { MockDataSet, MockStore, setupContext } from './utils.js'
 
 describe('createPostEndpoint', () => {
-  it('Should create the entity and report the success', async () => {
-    await usingAsync(new Injector(), async (i) => {
+  it('creates the entity and responds 201', async () => {
+    await usingAsync(createInjector(), async (i) => {
       setupContext(i)
       const port = getPort()
       await useRestService<{ POST: { '/': PostEndpoint<MockClass, 'id'> } }>({
         injector: i,
         root: '/api',
         port,
-        api: {
-          POST: {
-            '/': createPostEndpoint({ model: MockClass, primaryKey: 'id' }),
-          },
-        },
+        api: { POST: { '/': createPostEndpoint(MockDataSet) } },
       })
       const entityToPost = { id: 'mock', value: 'posted' }
       const response = await fetch(`http://127.0.0.1:${port}/api`, {
@@ -29,10 +25,45 @@ describe('createPostEndpoint', () => {
         body: JSON.stringify(entityToPost),
       })
       expect(response.status).toBe(201)
-      const body = (await response.json()) as { id: string; value: string }
-      expect(body).toEqual(entityToPost)
-      const posted = await getDataSetFor(i, MockClass, 'id').get(i, entityToPost.id)
-      expect(posted?.value).toBe('posted')
+      expect(await response.json()).toEqual(entityToPost)
+      expect((await i.get(MockDataSet).get(i, entityToPost.id))?.value).toBe('posted')
+    })
+  })
+
+  it('responds 404 when the underlying data set returned no created entity', async () => {
+    await usingAsync(createInjector(), async (i) => {
+      setupContext(i)
+      // Swap the dataset binding for a stub whose `add` comes back empty --
+      // this is the only way to exercise the `!created.length` branch.
+      i.bind(MockDataSet, () => ({ add: async () => ({ created: [] as MockClass[] }) }) as never)
+      const port = getPort()
+      await useRestService<{ POST: { '/': PostEndpoint<MockClass, 'id'> } }>({
+        injector: i,
+        root: '/api',
+        port,
+        api: { POST: { '/': createPostEndpoint(MockDataSet) } },
+      })
+      const response = await fetch(`http://127.0.0.1:${port}/api`, {
+        method: 'POST',
+        body: JSON.stringify({ id: 'mock', value: 'x' }),
+      })
+      expect(response.status).toBe(404)
+      expect(await response.json()).toEqual({ message: 'Entity not found' })
+    })
+  })
+})
+
+describe('endpoint-generators/utils', () => {
+  it('MockStore throws from its default factory when setupContext was not called', async () => {
+    await usingAsync(createInjector(), async (i) => {
+      expect(() => i.get(MockStore)).toThrow(/MockStore is not configured/)
+    })
+  })
+
+  it('setupContext binds MockStore in-memory so the default factory is bypassed', async () => {
+    await usingAsync(createInjector(), async (i) => {
+      setupContext(i)
+      expect(i.get(MockStore)).toBeDefined()
     })
   })
 })

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

@@ -1,39 +1,29 @@
-import type { Constructable } from '@furystack/inject'
+import type { WithOptionalId } from '@furystack/core'
+import type { DataSetToken } from '@furystack/repository'
 import type { PostEndpoint } from '@furystack/rest'
 import { RequestError } from '@furystack/rest'
-import '@furystack/repository'
-import type { RequestAction } from '../request-action-implementation.js'
-import { JsonResult } from '../request-action-implementation.js'
-import type { WithOptionalId } from '@furystack/core'
-import { getRepository } from '@furystack/repository'
 import { readPostBody } from '../read-post-body.js'
+import { JsonResult, type RequestAction } from '../request-action-implementation.js'
+
 /**
- * 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
+ * Creates a POST endpoint that inserts a new entity into the DataSet
+ * resolved from `dataSet`. Returns `201 Created` on success; throws a
+ * `RequestError(404)` when the underlying store returns no created entity.
  */
 export const createPostEndpoint = <
   T extends object,
   TPrimaryKey extends keyof T,
   TWritableData = WithOptionalId<T, TPrimaryKey>,
->(options: {
-  model: Constructable<T>
-  primaryKey: TPrimaryKey
-}) => {
-  const endpoint: RequestAction<PostEndpoint<T, TPrimaryKey, TWritableData>> = async ({ injector, request }) => {
-    const dataSet = getRepository(injector).getDataSetFor<T, TPrimaryKey, TWritableData>(
-      options.model,
-      options.primaryKey,
-    )
-
+>(
+  dataSet: DataSetToken<T, TPrimaryKey, TWritableData>,
+): RequestAction<PostEndpoint<T, TPrimaryKey, TWritableData>> => {
+  return async ({ injector, request }) => {
+    const ds = injector.get(dataSet)
     const entityToCreate = await readPostBody<TWritableData>(request)
-    const { created } = await dataSet.add(injector, entityToCreate)
+    const { created } = await ds.add(injector, entityToCreate)
     if (!created || !created.length) {
       throw new RequestError('Entity not found', 404)
     }
     return JsonResult(created[0], 201)
   }
-  return endpoint
 }

package/src/endpoint-generators/utils.ts

@@ -1,37 +1,45 @@
+import { defineStore, InMemoryStore, User } from '@furystack/core'
 import type { Injector } from '@furystack/inject'
-import { addStore, InMemoryStore, User } from '@furystack/core'
+import { defineDataSet } from '@furystack/repository'
 import { DefaultSession } from '../models/default-session.js'
-import '@furystack/repository'
-import '../helpers.js'
-import { getRepository } from '@furystack/repository'
+import { SessionStore, UserStore } from '../user-store.js'
 
+/**
+ * Mock entity used by endpoint-generator specs.
+ */
 export class MockClass {
   declare id: string
   declare value: string
 }
 
-export const setupContext = (i: Injector) => {
-  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')
-    .createDataSet(User, 'username')
-    .createDataSet(DefaultSession, 'sessionId')
+/**
+ * Store token for {@link MockClass}. The default factory throws so each spec
+ * explicitly opts into an in-memory backing via `setupContext`.
+ */
+export const MockStore = defineStore({
+  name: 'test/MockStore',
+  model: MockClass,
+  primaryKey: 'id',
+  factory: () => {
+    throw new Error('MockStore is not configured in this injector')
+  },
+})
+
+/**
+ * Data set token over {@link MockStore}.
+ */
+export const MockDataSet = defineDataSet({
+  name: 'test/MockDataSet',
+  store: MockStore,
+})
+
+/**
+ * Binds in-memory implementations of {@link UserStore}, {@link SessionStore}
+ * and {@link MockStore} on the provided injector. Endpoint-generator specs
+ * and integration tests call this at setup time.
+ */
+export const setupContext = (i: Injector): void => {
+  i.bind(UserStore, () => new InMemoryStore({ model: User, primaryKey: 'username' }))
+  i.bind(SessionStore, () => new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
+  i.bind(MockStore, () => new InMemoryStore({ model: MockClass, primaryKey: 'id' }))
 }

package/src/get-schema-from-api.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest'
-import type { RestApiImplementation } from './api-manager.js'
 import { defaultSchema, getSchemaFromApi } from './get-schema-from-api.js'
+import type { RestApiImplementation } from './rest-api-runtime.js'
 import { JsonResult, type RequestAction } from './request-action-implementation.js'
 import validationSchema from './validate.integration.spec.schema.json' with { type: 'json' }
 import { Validate } from './validate.js'

package/src/get-schema-from-api.ts

@@ -1,6 +1,6 @@
 import type { ApiEndpointDefinition, ApiEndpointSchema, Method, RestApi, Schema } from '@furystack/rest'
-import type { RestApiImplementation } from './api-manager.js'
 import type { RequestAction } from './request-action-implementation.js'
+import type { RestApiImplementation } from './rest-api-runtime.js'
 
 export const defaultSchema: Schema = {
   definitions: {

package/src/helpers.spec.ts

@@ -1,56 +1,57 @@
-import { InMemoryStore, User, addStore } from '@furystack/core'
+import type { User } from '@furystack/core'
+import { InMemoryStore, User as UserModel } from '@furystack/core'
 import { getPort } from '@furystack/core/port-generator'
-import { Injector } from '@furystack/inject'
-import { getRepository } from '@furystack/repository'
-import { PasswordCredential, PasswordResetToken, usePasswordPolicy } from '@furystack/security'
+import { createInjector, type Injector } from '@furystack/inject'
+import {
+  PasswordCredential,
+  PasswordCredentialStore,
+  PasswordResetToken,
+  PasswordResetTokenStore,
+  usePasswordPolicy,
+} from '@furystack/security'
 import { usingAsync } from '@furystack/utils'
 import { describe, expect, it } from 'vitest'
-import { ApiManager } from './api-manager.js'
 import { useHttpAuthentication, useProxy, useRestService, useStaticFiles } from './helpers.js'
 import { HttpAuthenticationSettings } from './http-authentication-settings.js'
+import { HttpServerPoolToken } from './http-server-pool.js'
 import { DefaultSession } from './models/default-session.js'
-import { ProxyManager } from './proxy-manager.js'
-import { StaticServerManager } from './static-server-manager.js'
+import { SessionStore, UserStore } from './user-store.js'
 
 const setupAuthStores = (i: Injector) => {
-  addStore(i, new InMemoryStore({ model: User, primaryKey: 'username' }))
-    .addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
-    .addStore(new InMemoryStore({ model: PasswordCredential, primaryKey: 'userName' }))
-    .addStore(new InMemoryStore({ model: PasswordResetToken, primaryKey: 'token' }))
-  const repo = getRepository(i)
-  repo.createDataSet(User, 'username')
-  repo.createDataSet(DefaultSession, 'sessionId')
-  repo.createDataSet(PasswordCredential, 'userName')
-  repo.createDataSet(PasswordResetToken, 'token')
+  i.bind(UserStore, () => new InMemoryStore({ model: UserModel, primaryKey: 'username' }))
+  i.bind(SessionStore, () => new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
+  i.bind(PasswordCredentialStore, () => new InMemoryStore({ model: PasswordCredential, primaryKey: 'userName' }))
+  i.bind(PasswordResetTokenStore, () => new InMemoryStore({ model: PasswordResetToken, primaryKey: 'token' }))
   usePasswordPolicy(i)
 }
 
-describe('Injector extensions', () => {
+describe('rest-service setup helpers', () => {
   describe('useHttpAuthentication', () => {
-    it('Should set up HTTP Authentication', async () => {
-      await usingAsync(new Injector(), async (i) => {
+    it('binds HttpAuthenticationSettings on the injector', async () => {
+      await usingAsync(createInjector(), async (i) => {
         setupAuthStores(i)
         useHttpAuthentication(i)
-        expect(i.cachedSingletons.get(HttpAuthenticationSettings)).toBeDefined()
+        const settings = i.get(HttpAuthenticationSettings)
+        expect(settings).toBeDefined()
       })
     })
 
-    it('Should register basic-auth and cookie-auth providers by default', async () => {
-      await usingAsync(new Injector(), async (i) => {
+    it('registers basic-auth and cookie-auth providers by default', async () => {
+      await usingAsync(createInjector(), async (i) => {
         setupAuthStores(i)
         useHttpAuthentication(i)
-        const settings = i.getInstance(HttpAuthenticationSettings)
+        const settings = i.get(HttpAuthenticationSettings)
         const providerNames = settings.authenticationProviders.map((p) => p.name)
         expect(providerNames).toContain('basic-auth')
         expect(providerNames).toContain('cookie-auth')
       })
     })
 
-    it('Should not register basic-auth provider when disabled', async () => {
-      await usingAsync(new Injector(), async (i) => {
+    it('omits the basic-auth provider when enableBasicAuth is false', async () => {
+      await usingAsync(createInjector(), async (i) => {
         setupAuthStores(i)
         useHttpAuthentication(i, { enableBasicAuth: false })
-        const settings = i.getInstance(HttpAuthenticationSettings)
+        const settings = i.get(HttpAuthenticationSettings)
         const providerNames = settings.authenticationProviders.map((p) => p.name)
         expect(providerNames).not.toContain('basic-auth')
         expect(providerNames).toContain('cookie-auth')
@@ -59,41 +60,50 @@ describe('Injector extensions', () => {
   })
 
   describe('useRestService()', () => {
-    it('Should set up a REST service', async () => {
-      await usingAsync(new Injector(), async (i) => {
+    it('acquires a pooled HTTP server and attaches a serverApi', async () => {
+      await usingAsync(createInjector(), async (i) => {
         const port = getPort()
-
-        await useRestService({ injector: i, api: {}, root: '/', port })
-        expect(i.cachedSingletons.get(ApiManager)).toBeDefined()
+        const serverApi = await useRestService({ injector: i, api: {}, root: '/', port })
+        expect(serverApi).toBeDefined()
+        const pool = i.get(HttpServerPoolToken)
+        const record = await pool.acquire({ port })
+        expect(record.apis).toContain(serverApi)
       })
     })
   })
 
   describe('useStaticFiles()', () => {
-    it('Should set up a static file server', async () => {
-      await usingAsync(new Injector(), async (i) => {
+    it('attaches a static-file serverApi to the pooled HTTP server', async () => {
+      await usingAsync(createInjector(), async (i) => {
         const port = getPort()
-
-        await useStaticFiles({ injector: i, baseUrl: '/', path: '.', port })
-        expect(i.cachedSingletons.get(StaticServerManager)).toBeDefined()
+        const serverApi = await useStaticFiles({ injector: i, baseUrl: '/', path: '.', port })
+        expect(serverApi).toBeDefined()
+        const pool = i.get(HttpServerPoolToken)
+        const record = await pool.acquire({ port })
+        expect(record.apis).toContain(serverApi)
       })
     })
   })
 
   describe('useProxy()', () => {
-    it('Should set up a proxy server', async () => {
-      await usingAsync(new Injector(), async (i) => {
+    it('attaches a proxy serverApi to the pooled HTTP server', async () => {
+      await usingAsync(createInjector(), async (i) => {
         const sourcePort = getPort()
         const targetPort = getPort()
-
-        await useProxy({
+        const serverApi = await useProxy({
           injector: i,
           sourceBaseUrl: '/api',
           targetBaseUrl: `http://localhost:${targetPort}`,
           sourcePort,
         })
-        expect(i.cachedSingletons.get(ProxyManager)).toBeDefined()
+        expect(serverApi).toBeDefined()
+        const pool = i.get(HttpServerPoolToken)
+        const record = await pool.acquire({ port: sourcePort })
+        expect(record.apis).toContain(serverApi)
       })
     })
   })
 })
+
+// Re-export to keep ESLint happy about unused User import elsewhere.
+export type { User }