@furystack/rest-service 13.0.0 → 14.1.0

package/src/user-resolution-cache.ts

@@ -0,0 +1,164 @@
+import type { User } from '@furystack/core'
+import { Cache } from '@furystack/cache'
+import { defineService, type Token } from '@furystack/inject'
+import type { IncomingMessage } from 'http'
+import type { AuthenticationProvider } from './authentication-providers/authentication-provider.js'
+import {
+  DEFAULT_USER_CACHE_CAPACITY,
+  DEFAULT_USER_CACHE_TTL_MS,
+  HttpAuthenticationSettings,
+} from './http-authentication-settings.js'
+import type { HttpUserContext } from './http-user-context.js'
+import { userCacheTag, type UserCacheTag } from './identity-cache-keys.js'
+
+/**
+ * Singleton TTL cache that memoizes successful identity resolutions across
+ * requests within a single process.
+ *
+ * Cache keys are produced by the configured {@link AuthenticationProvider}s
+ * via their `getCacheKey` method (e.g. cookie-auth keys by session id). The
+ * cache's `load` callback runs the same provider chain that
+ * {@link HttpUserContext.authenticateRequest} would run — it is supplied via
+ * an internal "loader" registered when the {@link HttpUserContext} is
+ * resolved.
+ *
+ * Entries expire after `HttpAuthenticationSettings.userCacheTtlMs`; capacity
+ * is bounded by `HttpAuthenticationSettings.userCacheCapacity`. Setting the
+ * TTL to `0` disables caching (the loader runs on every call).
+ *
+ * **Multi-node note:** session invalidation on one instance does not
+ * propagate to siblings — the TTL bounds the staleness window. Apps that
+ * need stricter freshness must shorten the TTL or invalidate explicitly via
+ * {@link UserResolutionCache.invalidate} /
+ * {@link UserResolutionCache.invalidateByUser}.
+ */
+export interface UserResolutionCache extends Disposable {
+  /**
+   * Returns the cached or freshly-resolved `User` for the supplied
+   * cache key. The `loader` is invoked on cache miss; concurrent calls for
+   * the same key dedupe to a single loader invocation.
+   */
+  resolve(cacheKey: string, loader: () => Promise<User>): Promise<User>
+  /** Drops a single cache entry. No-op when the key is unknown. */
+  invalidate(cacheKey: string): void
+  /**
+   * Drops every cached entry that resolved to `username`, regardless of
+   * which {@link AuthenticationProvider}'s key originally populated it.
+   * Backed by the cache's reverse tag index — no per-call O(n) scan.
+   *
+   * Use after role / password / account-state changes that must take
+   * effect immediately on the next request, instead of waiting for the
+   * TTL window to elapse.
+   */
+  invalidateByUser(username: string): void
+  /** Drops every cached entry. */
+  invalidateAll(): void
+  /** Returns the current entry count (for diagnostics / tests). */
+  readonly size: number
+}
+
+class UserResolutionCacheImpl implements UserResolutionCache {
+  private readonly loaders = new Map<string, () => Promise<User>>()
+  private readonly cache: Cache<User, [string], UserCacheTag> | null
+
+  constructor(ttlMs: number, capacity: number) {
+    if (ttlMs <= 0) {
+      this.cache = null
+      return
+    }
+    this.cache = new Cache<User, [string], UserCacheTag>({
+      load: (cacheKey) => {
+        const loader = this.loaders.get(cacheKey)
+        if (!loader) {
+          // The loader is only registered for the duration of a `resolve()`
+          // call. A reload triggered via `cache.get(key)` outside that call
+          // (e.g. from `getObservable`) would have no loader; refuse the
+          // load instead of caching `null`.
+          return Promise.reject(new Error(`No loader registered for cache key '${cacheKey}'`))
+        }
+        return loader()
+      },
+      cacheTimeMs: ttlMs,
+      capacity,
+      getKey: (cacheKey) => cacheKey,
+      getTags: (user) => [userCacheTag(user.username)],
+    })
+  }
+
+  public async resolve(cacheKey: string, loader: () => Promise<User>): Promise<User> {
+    if (!this.cache) {
+      return loader()
+    }
+    this.loaders.set(cacheKey, loader)
+    try {
+      return await this.cache.get(cacheKey)
+    } finally {
+      // Loader is per-request; clearing prevents the cache from re-running it
+      // out-of-band when the entry transitions to obsolete and a sibling call
+      // queries `getObservable`.
+      this.loaders.delete(cacheKey)
+    }
+  }
+
+  public invalidate(cacheKey: string): void {
+    this.cache?.remove(cacheKey)
+  }
+
+  public invalidateByUser(username: string): void {
+    this.cache?.removeByTag(userCacheTag(username))
+  }
+
+  public invalidateAll(): void {
+    this.cache?.flushAll()
+  }
+
+  public get size(): number {
+    return this.cache?.getCount() ?? 0
+  }
+
+  public [Symbol.dispose](): void {
+    this.cache?.[Symbol.dispose]()
+    this.loaders.clear()
+  }
+}
+
+/**
+ * DI token for the singleton {@link UserResolutionCache}. Resolved lazily
+ * by {@link HttpUserContext}; sized from {@link HttpAuthenticationSettings}.
+ */
+export const UserResolutionCache: Token<UserResolutionCache, 'singleton'> = defineService({
+  name: 'furystack/rest-service/UserResolutionCache',
+  lifetime: 'singleton',
+  factory: ({ inject, onDispose }): UserResolutionCache => {
+    const settings = inject(HttpAuthenticationSettings)
+    const ttlMs = settings.userCacheTtlMs ?? DEFAULT_USER_CACHE_TTL_MS
+    const capacity = settings.userCacheCapacity ?? DEFAULT_USER_CACHE_CAPACITY
+    const impl = new UserResolutionCacheImpl(ttlMs, capacity)
+    onDispose(() => {
+      // eslint-disable-next-line furystack/prefer-using-wrapper -- onDispose is the teardown hook
+      impl[Symbol.dispose]()
+    })
+    return impl
+  },
+})
+
+/**
+ * Resolves the configured cache key for the supplied request by walking the
+ * authentication providers in order and returning the first non-null key.
+ *
+ * Returns `null` when no provider opts in to caching (e.g. Basic Auth, or
+ * an anonymous request). The caller should bypass the cache in that case.
+ *
+ * Exported so plugins / tests can derive the same key the cache uses.
+ */
+export const resolveUserCacheKey = (
+  settings: HttpAuthenticationSettings,
+  request: Pick<IncomingMessage, 'headers'>,
+): string | null => {
+  for (const provider of settings.authenticationProviders) {
+    if (!provider.getCacheKey) continue
+    const key = provider.getCacheKey(request)
+    if (key) return key
+  }
+  return null
+}

package/src/user-store.spec.ts

@@ -0,0 +1,86 @@
+import { InMemoryStore, User } from '@furystack/core'
+import { createInjector } from '@furystack/inject'
+import { usingAsync } from '@furystack/utils'
+import { describe, expect, it } from 'vitest'
+import { DefaultSession } from './models/default-session.js'
+import {
+  HttpAuthenticationStoreNotConfiguredError,
+  SessionDataSet,
+  SessionStore,
+  UserDataSet,
+  UserStore,
+} from './user-store.js'
+
+describe('UserStore', () => {
+  it('exposes the User model and username primary key on the token', () => {
+    expect(UserStore.model).toBe(User)
+    expect(UserStore.primaryKey).toBe('username')
+    expect(UserStore.lifetime).toBe('singleton')
+  })
+
+  it('throws HttpAuthenticationStoreNotConfiguredError when resolved without an override', async () => {
+    await usingAsync(createInjector(), async (injector) => {
+      expect(() => injector.get(UserStore)).toThrow(HttpAuthenticationStoreNotConfiguredError)
+      expect(() => injector.get(UserStore)).toThrow(/UserStore.*not been configured/)
+    })
+  })
+
+  it('returns the bound implementation after rebinding the token', async () => {
+    await usingAsync(createInjector(), async (injector) => {
+      const impl = new InMemoryStore({ model: User, primaryKey: 'username' })
+      injector.bind(UserStore, () => impl)
+      expect(injector.get(UserStore)).toBe(impl)
+    })
+  })
+})
+
+describe('SessionStore', () => {
+  it('exposes the DefaultSession model and sessionId primary key on the token', () => {
+    expect(SessionStore.model).toBe(DefaultSession)
+    expect(SessionStore.primaryKey).toBe('sessionId')
+    expect(SessionStore.lifetime).toBe('singleton')
+  })
+
+  it('throws HttpAuthenticationStoreNotConfiguredError when resolved without an override', async () => {
+    await usingAsync(createInjector(), async (injector) => {
+      expect(() => injector.get(SessionStore)).toThrow(HttpAuthenticationStoreNotConfiguredError)
+      expect(() => injector.get(SessionStore)).toThrow(/SessionStore.*not been configured/)
+    })
+  })
+
+  it('returns the bound implementation after rebinding the token', async () => {
+    await usingAsync(createInjector(), async (injector) => {
+      const impl = new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' })
+      injector.bind(SessionStore, () => impl)
+      expect(injector.get(SessionStore)).toBe(impl)
+    })
+  })
+})
+
+describe('UserDataSet / SessionDataSet', () => {
+  it('mirror the backing store metadata onto the data-set token', () => {
+    expect(UserDataSet.model).toBe(User)
+    expect(UserDataSet.primaryKey).toBe('username')
+    expect(SessionDataSet.model).toBe(DefaultSession)
+    expect(SessionDataSet.primaryKey).toBe('sessionId')
+  })
+
+  it('resolves through the bound store implementation', async () => {
+    await usingAsync(createInjector(), async (injector) => {
+      injector.bind(UserStore, () => new InMemoryStore({ model: User, primaryKey: 'username' }))
+      const dataSet = injector.get(UserDataSet)
+      await dataSet.add(injector, { username: 'alice', roles: [] })
+      const result = await dataSet.get(injector, 'alice')
+      expect(result?.username).toBe('alice')
+    })
+  })
+})
+
+describe('HttpAuthenticationStoreNotConfiguredError', () => {
+  it('embeds the store name in the message and sets the error name', () => {
+    const error = new HttpAuthenticationStoreNotConfiguredError('SomeStore')
+    expect(error.name).toBe('HttpAuthenticationStoreNotConfiguredError')
+    expect(error.message).toContain("'SomeStore'")
+    expect(error).toBeInstanceOf(Error)
+  })
+})

package/src/user-store.ts

@@ -0,0 +1,69 @@
+import { defineStore, type StoreToken, User } from '@furystack/core'
+import { defineDataSet, type DataSetToken } from '@furystack/repository'
+import type { HttpUserContext } from './http-user-context.js'
+import { DefaultSession } from './models/default-session.js'
+
+/**
+ * Error thrown by the default factories of {@link UserStore} and
+ * {@link SessionStore} when they are resolved without a caller-provided
+ * override. Users and sessions must outlive a process restart, so the
+ * rest-service refuses to silently fall back to an in-memory store.
+ */
+export class HttpAuthenticationStoreNotConfiguredError extends Error {
+  constructor(storeName: string) {
+    super(
+      `HTTP authentication store '${storeName}' has not been configured. Bind a persistent PhysicalStore before resolving the HttpUserContext.`,
+    )
+    this.name = 'HttpAuthenticationStoreNotConfiguredError'
+  }
+}
+
+/**
+ * Store token for persisted {@link User} records. Applications must bind
+ * this token to a persistent implementation before resolving
+ * {@link HttpUserContext} (or any service that derives from it).
+ *
+ * @example
+ * ```ts
+ * injector.bind(UserStore, () => myPersistentUserStore)
+ * ```
+ */
+export const UserStore: StoreToken<User, 'username'> = defineStore({
+  name: 'furystack/rest-service/UserStore',
+  model: User,
+  primaryKey: 'username',
+  factory: () => {
+    throw new HttpAuthenticationStoreNotConfiguredError('UserStore')
+  },
+})
+
+/**
+ * Store token for persisted {@link DefaultSession} records. Shares the
+ * throw-by-default contract with {@link UserStore}.
+ */
+export const SessionStore: StoreToken<DefaultSession, 'sessionId'> = defineStore({
+  name: 'furystack/rest-service/SessionStore',
+  model: DefaultSession,
+  primaryKey: 'sessionId',
+  factory: () => {
+    throw new HttpAuthenticationStoreNotConfiguredError('SessionStore')
+  },
+})
+
+/**
+ * Data set token over {@link UserStore}. Consumers of the authentication
+ * subsystem (cookie login, JWT authentication plugins, `HttpUserContext`)
+ * route all user I/O through this dataset.
+ */
+export const UserDataSet: DataSetToken<User, 'username'> = defineDataSet({
+  name: 'furystack/rest-service/UserDataSet',
+  store: UserStore,
+})
+
+/**
+ * Data set token over {@link SessionStore}.
+ */
+export const SessionDataSet: DataSetToken<DefaultSession, 'sessionId'> = defineDataSet({
+  name: 'furystack/rest-service/SessionDataSet',
+  store: SessionStore,
+})

package/src/validate.integration.spec.ts

@@ -1,10 +1,17 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import { getStoreManager, InMemoryStore, User } from '@furystack/core'
+/* eslint-disable @typescript-eslint/no-unnecessary-type-assertion -- false positives: `client` is typed for a narrow `RestApi`; casts to `ReturnType<typeof createClient<...>>` widen it so this test can exercise endpoints (e.g. `/openapi.json`) the production type intentionally hides */
+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 { createInjector } from '@furystack/inject'
 import type { OpenApiDocument, WithSchemaAction } from '@furystack/rest'
 import { createClient, ResponseError } from '@furystack/rest-client-fetch'
+import {
+  PasswordCredential,
+  PasswordCredentialStore,
+  PasswordResetToken,
+  PasswordResetTokenStore,
+  usePasswordPolicy,
+} from '@furystack/security'
 import { usingAsync } from '@furystack/utils'
 import type Ajv from 'ajv'
 import { describe, expect, it } from 'vitest'
@@ -13,10 +20,11 @@ import { createGetCollectionEndpoint } from './endpoint-generators/create-get-co
 import { createGetEntityEndpoint } from './endpoint-generators/create-get-entity-endpoint.js'
 import { createPatchEndpoint } from './endpoint-generators/create-patch-endpoint.js'
 import { createPostEndpoint } from './endpoint-generators/create-post-endpoint.js'
-import { MockClass } from './endpoint-generators/utils.js'
+import { MockDataSet, setupContext } from './endpoint-generators/utils.js'
 import { useHttpAuthentication, useRestService } from './helpers.js'
 import { DefaultSession } from './models/default-session.js'
 import { JsonResult } from './request-action-implementation.js'
+import { SessionStore, UserStore } from './user-store.js'
 import type { ValidationApi } from './validate.integration.schema.js'
 import schema from './validate.integration.spec.schema.json' with { type: 'json' }
 import { Validate } from './validate.js'
@@ -28,15 +36,12 @@ const description = crypto.randomUUID()
 const version = crypto.randomUUID()
 
 const createValidateApi = async (options = { enableGetSchema: false }) => {
-  const injector = new Injector()
+  const injector = createInjector()
   const port = getPort()
 
-  getStoreManager(injector).addStore(new InMemoryStore({ model: User, primaryKey: 'username' }))
-  getStoreManager(injector).addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
-  getStoreManager(injector).addStore(new InMemoryStore({ model: MockClass, primaryKey: 'id' }))
-  getRepository(injector).createDataSet(MockClass, 'id')
-  getRepository(injector).createDataSet(User, 'username')
-  getRepository(injector).createDataSet(DefaultSession, 'sessionId')
+  injector.bind(UserStore, () => new InMemoryStore({ model: UserModel, primaryKey: 'username' }))
+  injector.bind(SessionStore, () => new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
+  setupContext(injector)
 
   const api = await useRestService<ValidationApi>({
     injector,
@@ -61,11 +66,11 @@ const createValidateApi = async (options = { enableGetSchema: false }) => {
         '/mock': Validate({
           schema,
           schemaName: 'GetMockCollectionEndpoint',
-        })(createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' })),
+        })(createGetCollectionEndpoint(MockDataSet)),
         '/mock/:id': Validate({
           schema,
           schemaName: 'GetMockEntityEndpoint',
-        })(createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' })),
+        })(createGetEntityEndpoint(MockDataSet)),
       },
       POST: {
         '/validate-body': Validate({
@@ -78,19 +83,19 @@ const createValidateApi = async (options = { enableGetSchema: false }) => {
         '/mock': Validate({
           schema,
           schemaName: 'PostMockEndpoint',
-        })(createPostEndpoint({ model: MockClass, primaryKey: 'id' })),
+        })(createPostEndpoint(MockDataSet)),
       },
       PATCH: {
         '/mock/:id': Validate({
           schema,
           schemaName: 'PatchMockEndpoint',
-        })(createPatchEndpoint({ model: MockClass, primaryKey: 'id' })),
+        })(createPatchEndpoint(MockDataSet)),
       },
       DELETE: {
         '/mock/:id': Validate({
           schema,
           schemaName: 'DeleteMockEndpoint',
-        })(createDeleteEndpoint({ model: MockClass, primaryKey: 'id' })),
+        })(createDeleteEndpoint(MockDataSet)),
       },
     },
     port,
@@ -447,16 +452,22 @@ describe('Validation integration tests', () => {
 
   describe('OpenAPI security schemes from authentication providers', () => {
     const createApiWithAuth = async () => {
-      const injector = new Injector()
+      const injector = createInjector()
       const port = getPort()
 
-      getStoreManager(injector).addStore(new InMemoryStore({ model: User, primaryKey: 'username' }))
-      getStoreManager(injector).addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
-      getStoreManager(injector).addStore(new InMemoryStore({ model: MockClass, primaryKey: 'id' }))
-      getRepository(injector).createDataSet(MockClass, 'id')
-      getRepository(injector).createDataSet(User, 'username')
-      getRepository(injector).createDataSet(DefaultSession, 'sessionId')
-
+      injector.bind(UserStore, () => new InMemoryStore({ model: UserModel, primaryKey: 'username' }))
+      injector.bind(SessionStore, () => new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }))
+      injector.bind(
+        PasswordCredentialStore,
+        () => new InMemoryStore({ model: PasswordCredential, primaryKey: 'userName' }),
+      )
+      injector.bind(
+        PasswordResetTokenStore,
+        () => new InMemoryStore({ model: PasswordResetToken, primaryKey: 'token' }),
+      )
+      setupContext(injector)
+
+      usePasswordPolicy(injector)
       useHttpAuthentication(injector)
 
       await useRestService<ValidationApi>({
@@ -477,10 +488,10 @@ describe('Validation integration tests', () => {
               JsonResult({ ...headers }),
             ),
             '/mock': Validate({ schema, schemaName: 'GetMockCollectionEndpoint' })(
-              createGetCollectionEndpoint({ model: MockClass, primaryKey: 'id' }),
+              createGetCollectionEndpoint(MockDataSet),
             ),
             '/mock/:id': Validate({ schema, schemaName: 'GetMockEntityEndpoint' })(
-              createGetEntityEndpoint({ model: MockClass, primaryKey: 'id' }),
+              createGetEntityEndpoint(MockDataSet),
             ),
           },
           POST: {
@@ -488,19 +499,13 @@ describe('Validation integration tests', () => {
               const body = await getBody()
               return JsonResult({ ...body })
             }),
-            '/mock': Validate({ schema, schemaName: 'PostMockEndpoint' })(
-              createPostEndpoint({ model: MockClass, primaryKey: 'id' }),
-            ),
+            '/mock': Validate({ schema, schemaName: 'PostMockEndpoint' })(createPostEndpoint(MockDataSet)),
           },
           PATCH: {
-            '/mock/:id': Validate({ schema, schemaName: 'PatchMockEndpoint' })(
-              createPatchEndpoint({ model: MockClass, primaryKey: 'id' }),
-            ),
+            '/mock/:id': Validate({ schema, schemaName: 'PatchMockEndpoint' })(createPatchEndpoint(MockDataSet)),
           },
           DELETE: {
-            '/mock/:id': Validate({ schema, schemaName: 'DeleteMockEndpoint' })(
-              createDeleteEndpoint({ model: MockClass, primaryKey: 'id' }),
-            ),
+            '/mock/:id': Validate({ schema, schemaName: 'DeleteMockEndpoint' })(createDeleteEndpoint(MockDataSet)),
           },
         },
         port,

package/src/validate.ts

@@ -1,9 +1,7 @@
 import type { ActionResult, RequestAction, RequestActionOptions } from './request-action-implementation.js'
+import type { SchemaValidationError } from './schema-validator/schema-validation-error.js'
 import { SchemaValidator } from './schema-validator/schema-validator.js'
 
-/**
- * Represents a JSON Schema definition structure
- */
 type JsonSchemaDefinition = {
   required?: string[]
   additionalProperties?: boolean
@@ -17,22 +15,26 @@ type JsonSchemaDefinition = {
   [key: string]: unknown
 }
 
-/**
- * Represents a JSON Schema with definitions
- */
 type JsonSchemaWithDefinitions = {
   definitions: Record<string, JsonSchemaDefinition>
 }
 
+/**
+ * Wraps a {@link RequestAction} with JSON Schema validation. The wrapper
+ * pre-validates `query`, `body`, `url` and `headers` against the named
+ * schema entry, throws {@link SchemaValidationError} on failure (caught by
+ * `ErrorAction` to return 400), then forwards the validated values to the
+ * inner action.
+ *
+ * The wrapped function exposes `schema` and `schemaName` so OpenAPI
+ * generators can reflect on the action without re-parsing the source.
+ *
+ * `furystack/rest-action-validate-wrapper` enforces this on REST actions.
+ */
 export const Validate =
   <TSchema extends JsonSchemaWithDefinitions>(validationOptions: {
-    /**
-     * The Schema object
-     */
     schema: TSchema
-    /**
-     * Entity key from the JSON Schema object
-     */
+    /** Entry under `schema.definitions` describing this endpoint's request shape. */
     schemaName: keyof TSchema['definitions']
   }) =>
   <T extends { result: unknown }>(

package/esm/api-manager.d.ts

@@ -1,104 +0,0 @@
-import type { Injector } from '@furystack/inject';
-import type { Method, RestApi } from '@furystack/rest';
-import type { MatchFunction } from 'path-to-regexp';
-import type { CorsOptions } from './models/cors-options.js';
-import type { RequestAction } from './request-action-implementation.js';
-import type { OnRequest } from './server-manager.js';
-import './server-response-extensions.js';
-export type RestApiImplementation<T extends RestApi> = {
-    [TMethod in keyof T]: {
-        [TUrl in keyof T[TMethod]]: T[TMethod][TUrl] extends {
-            result: unknown;
-        } ? RequestAction<T[TMethod][TUrl]> : never;
-    };
-};
-export interface ImplementApiOptions<T extends RestApi> {
-    /**
-     * The structure of the implemented API.
-     */
-    api: RestApiImplementation<T>;
-    /**
-     * The Injector instance to use for dependency injection in the API actions.
-     */
-    injector: Injector;
-    /**
-     * The host name for the API Server. If not provided, the default host (ServerManager.DEFAULT_HOST) will be used.
-     */
-    hostName?: string;
-    /**
-     * The root path for the API. This will be prepended to all API paths.
-     */
-    root: string;
-    /**
-     * The port on which the API server will listen.
-     */
-    port: number;
-    /**
-     * CORS options to configure Cross-Origin Resource Sharing for the API.
-     */
-    cors?: CorsOptions;
-    /**
-     * An optional function to deserialize query parameters from the URL.
-     * This function should take a query string (e.g., "?key=value") and return an object with the parsed parameters.
-     * If not provided, the default deserialization will be used.
-     */
-    deserializeQueryParams?: (param: string) => any;
-    /**
-     * Adds an additional 'GET /schema' endpoint that returns the schema definitions of the API.
-     * Also adds a 'GET /openapi.json' endpoint that returns the API schema in OpenAPI 3.1 format.
-     */
-    enableGetSchema?: boolean;
-    /**
-     * Optional name for the API, used in the generated schema.
-     * This can be useful for documentation or identification purposes.
-     */
-    name?: string;
-    /**
-     * Optional description for the API, used in the generated schema.
-     * This can provide additional context or information about the API's purpose.
-     */
-    description?: string;
-    /**
-     * Optional version for the API, used in the generated schema.
-     * This can help in versioning the API and tracking changes over time.
-     */
-    version?: string;
-}
-export type NewCompiledApiEntry = {
-    method: Method;
-    fullPath: string;
-    matcher: MatchFunction<Partial<Record<string, string | string[]>>>;
-    action: RequestAction<any>;
-};
-export type NewCompiledApi = {
-    [K in Method]?: NewCompiledApiEntry[];
-};
-export type OnRequestOptions = OnRequest & {
-    compiledApi: NewCompiledApi;
-    hostName?: string;
-    port: number;
-    rootApiPath: string;
-    injector: Injector;
-    cors?: CorsOptions;
-    supportedMethods: string[];
-    deserializeQueryParams?: (param: string) => Record<string, unknown>;
-};
-export declare class ApiManager {
-    private getSuportedMethods;
-    private compileApi;
-    addApi<T extends RestApi>({ api, hostName, port, root, cors, injector, deserializeQueryParams, enableGetSchema, name, description, version, }: ImplementApiOptions<T>): Promise<{
-        shouldExec: (msg: OnRequest) => boolean;
-        onRequest: (msg: OnRequest) => Promise<void>;
-    }>;
-    shouldExecRequest(options: {
-        method?: Method;
-        url?: string;
-        rootApiPath: string;
-        supportedMethods: Method[];
-    }): boolean;
-    private getActionFromEndpoint;
-    private executeAction;
-    private onMessage;
-    private readonly serverManager;
-}
-//# sourceMappingURL=api-manager.d.ts.map

package/esm/api-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-manager.d.ts","sourceRoot":"","sources":["../src/api-manager.ts"],"names":[],"mappings":"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"}