@furystack/rest-service 12.3.5 → 14.0.0

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)
     }
@@ -58,39 +58,3 @@ export const CreateGetOpenApiDocumentAction = <T extends RestApiImplementation<R
     return JsonResult(cachedDoc, 200)
   }
 }
-
-/**
- * Generates a backward-compatible `/swagger.json` endpoint that serves the same OpenAPI document
- * as `CreateGetOpenApiDocumentAction` but includes `Deprecation` and `Link` headers
- * directing clients to use `/openapi.json` instead.
- *
- * @deprecated Use CreateGetOpenApiDocumentAction and `/openapi.json` instead.
- */
-export const CreateDeprecatedSwaggerRedirect = <T extends RestApiImplementation<RestApi>>(
-  api: T,
-  name = 'FuryStack API',
-  description = 'API documentation generated from FuryStack API schema',
-  version = '1.0.0',
-): RequestAction<{ result: OpenApiDocument }> => {
-  const { endpoints } = getSchemaFromApi({ api, name, description, version })
-  let cachedDoc: OpenApiDocument | undefined
-  return async ({ injector }) => {
-    if (!cachedDoc) {
-      const securitySchemes = getSecuritySchemesFromInjector(injector)
-      cachedDoc = buildOpenApiDoc(
-        endpoints,
-        name,
-        description,
-        version,
-        securitySchemes ? { securitySchemes } : undefined,
-      )
-    }
-    return JsonResult(cachedDoc, 200, {
-      Deprecation: 'true',
-      Link: '</openapi.json>; rel="successor-version"',
-    })
-  }
-}
-
-/** @deprecated Use CreateGetOpenApiDocumentAction instead */
-export const CreateGetSwaggerJsonAction = CreateGetOpenApiDocumentAction

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
 }

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/endpoint-generators/with-schema-and-openapi-action.ts

@@ -9,6 +9,3 @@ export type WithSchemaAndOpenApiAction<T extends RestApi> = T & {
     '/openapi.json': { result: OpenApiDocument; headers: { accept: 'application/json' } }
   }
 }
-
-/** @deprecated Use WithSchemaAndOpenApiAction instead */
-export type WithSchemaAndSwaggerAction<T extends RestApi> = WithSchemaAndOpenApiAction<T>

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 }