@event-driven-io/emmett-expressjs 0.43.0-beta.2 → 0.43.0-beta.21

package/dist/index.d.ts

@@ -1,23 +1,89 @@
-import express, { Request, Response, Router, Application, NextFunction } from 'express';
-import http from 'http';
-import { ProblemDocument } from 'http-problem-details';
-import * as _event_driven_io_emmett from '@event-driven-io/emmett';
-import { Brand, Event, TestEventStream, EventStore } from '@event-driven-io/emmett';
-import supertest, { Test, Response as Response$1 } from 'supertest';
-import TestAgent from 'supertest/lib/agent';
+import express, { Application, NextFunction, Request, Response, Router } from "express";
+import http from "http";
+import { Brand, Event, EventStore, InMemoryEventStore, TestEventStream } from "@event-driven-io/emmett";
+import { ProblemDocument } from "http-problem-details";
+import supertest, { Response as Response$1, Test } from "supertest";
+import TestAgent from "supertest/lib/agent.js";
 
+//#region ../almanac/dist/meter-CY9GTIM8.d.ts
+//#region src/meters/meter.d.ts
+type Counter = {
+  add(value: number, attributes?: Record<string, unknown>): void;
+};
+type Histogram = {
+  record(value: number, attributes?: Record<string, unknown>): void;
+};
+type Gauge = {
+  record(value: number, attributes?: Record<string, unknown>): void;
+};
+type Meter = {
+  counter(name: string): Counter;
+  histogram(name: string): Histogram;
+  gauge(name: string): Gauge;
+};
+//#endregion
+//#region ../almanac/dist/tracer-DJWFmYul.d.ts
+//#region src/tracers/span.d.ts
+type SpanEventLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+type SpanContext = {
+  traceId: string;
+  spanId: string;
+};
+type SpanLink = SpanContext & {
+  attributes?: Record<string, unknown>;
+};
+type ActiveSpan = {
+  setAttributes(attrs: Record<string, unknown>): void;
+  spanContext(): SpanContext;
+  addLink(link: SpanLink): void;
+  addEvent(name: string, attributes?: Record<string, unknown>, level?: SpanEventLevel): void;
+  recordException(error: Error | string): void;
+};
+type StartSpanOptions = {
+  parent?: SpanContext;
+  attributes?: Record<string, unknown>;
+  links?: SpanLink[];
+  propagation?: TracePropagation;
+  sampleRate?: number;
+};
+//#endregion
+//#region src/tracers/tracer.d.ts
+type TracePropagation = 'links' | 'propagate';
+type Tracer = {
+  startSpan<T>(name: string, fn: (span: ActiveSpan) => Promise<T>, options?: StartSpanOptions): Promise<T>;
+};
+//#endregion
+//#region ../almanac/dist/index.d.ts
+type AttributeTarget = 'mainSpan' | 'currentSpan' | 'both'; //#endregion
+//#region src/meters/compositeMeter.d.ts
+//#endregion
+//#region src/configuration/options.d.ts
+declare const defaultPrefix: "almanac";
+type Sampler = {
+  shouldSample(name: string, attributes?: Record<string, unknown>): boolean;
+};
+type ObservabilityConfig<Prefix extends string = typeof defaultPrefix> = {
+  tracer?: Tracer;
+  meter?: Meter;
+  propagation?: TracePropagation;
+  attributeTarget?: AttributeTarget;
+  attributePrefix?: Prefix;
+  sampler?: Sampler;
+};
+//#endregion
+//#region src/etag.d.ts
 declare const HeaderNames: {
-    IF_MATCH: string;
-    IF_NOT_MATCH: string;
-    ETag: string;
+  IF_MATCH: string;
+  IF_NOT_MATCH: string;
+  ETag: string;
 };
 type WeakETag = Brand<`W/${string}`, 'ETag'>;
 type ETag = Brand<string, 'ETag'>;
 declare const WeakETagRegex: RegExp;
 declare const enum ETagErrors {
-    WRONG_WEAK_ETAG_FORMAT = "WRONG_WEAK_ETAG_FORMAT",
-    MISSING_IF_MATCH_HEADER = "MISSING_IF_MATCH_HEADER",
-    MISSING_IF_NOT_MATCH_HEADER = "MISSING_IF_NOT_MATCH_HEADER"
+  WRONG_WEAK_ETAG_FORMAT = "WRONG_WEAK_ETAG_FORMAT",
+  MISSING_IF_MATCH_HEADER = "MISSING_IF_MATCH_HEADER",
+  MISSING_IF_NOT_MATCH_HEADER = "MISSING_IF_NOT_MATCH_HEADER"
 }
 declare const isWeakETag: (etag: ETag) => etag is WeakETag;
 declare const getWeakETagValue: (etag: ETag) => string;
@@ -26,60 +92,68 @@ declare const getETagFromIfMatch: (request: Request) => ETag;
 declare const getETagFromIfNotMatch: (request: Request) => ETag;
 declare const setETag: (response: Response, etag: ETag) => void;
 declare const getETagValueFromIfMatch: (request: Request) => string;
-
+//#endregion
+//#region src/responses.d.ts
 type ErrorToProblemDetailsMapping = (error: Error, request: Request) => ProblemDocument | undefined;
 type HttpResponseOptions = {
-    body?: unknown;
-    location?: string;
-    eTag?: ETag;
+  body?: unknown;
+  location?: string;
+  eTag?: ETag;
 };
 declare const DefaultHttpResponseOptions: HttpResponseOptions;
 type HttpProblemResponseOptions = {
-    location?: string;
-    eTag?: ETag;
+  location?: string;
+  eTag?: ETag;
 } & Omit<HttpResponseOptions, 'body'> & ({
-    problem: ProblemDocument;
+  problem: ProblemDocument;
 } | {
-    problemDetails: string;
+  problemDetails: string;
 });
 declare const DefaultHttpProblemResponseOptions: HttpProblemResponseOptions;
 type CreatedHttpResponseOptions = ({
-    createdId: string;
+  createdId: string;
 } | {
-    createdId?: string;
-    url: string;
+  createdId?: string;
+  url: string;
 }) & HttpResponseOptions;
-declare const sendCreated: (response: Response, { eTag, ...options }: CreatedHttpResponseOptions) => void;
+declare const sendCreated: (response: Response, {
+  eTag,
+  ...options
+}: CreatedHttpResponseOptions) => void;
 type AcceptedHttpResponseOptions = {
-    location: string;
+  location: string;
 } & HttpResponseOptions;
 declare const sendAccepted: (response: Response, options: AcceptedHttpResponseOptions) => void;
 type NoContentHttpResponseOptions = Omit<HttpResponseOptions, 'body'>;
+declare const sendNoContent: (response: Response, options?: NoContentHttpResponseOptions) => void;
 declare const send: (response: Response, statusCode: number, options?: HttpResponseOptions) => void;
 declare const sendProblem: (response: Response, statusCode: number, options?: HttpProblemResponseOptions) => void;
-
+//#endregion
+//#region src/application.d.ts
 type WebApiSetup = (router: Router) => void;
 type ApplicationOptions = {
-    apis: WebApiSetup[];
-    mapError?: ErrorToProblemDetailsMapping;
-    enableDefaultExpressEtag?: boolean;
-    disableJsonMiddleware?: boolean;
-    disableUrlEncodingMiddleware?: boolean;
-    disableProblemDetailsMiddleware?: boolean;
+  apis: WebApiSetup[];
+  mapError?: ErrorToProblemDetailsMapping;
+  enableDefaultExpressEtag?: boolean;
+  disableJsonMiddleware?: boolean;
+  disableUrlEncodingMiddleware?: boolean;
+  disableProblemDetailsMiddleware?: boolean;
+  observability?: ObservabilityConfig<string>;
 };
 declare const getApplication: (options: ApplicationOptions) => express.Application;
 type StartApiOptions = {
-    port?: number;
+  port?: number;
 };
 declare const startAPI: (app: Application, options?: StartApiOptions) => http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
-
+//#endregion
+//#region src/handler.d.ts
+type HttpResponse = (response: Response) => void;
 type HttpHandler<RequestType extends Request> = (request: RequestType) => Promise<HttpResponse> | HttpResponse;
 declare const on: <RequestType extends Request>(handle: HttpHandler<RequestType>) => (request: RequestType, response: Response, _next: NextFunction) => Promise<void>;
 declare const OK: (options?: HttpResponseOptions) => HttpResponse;
 declare const Created: (options: CreatedHttpResponseOptions) => HttpResponse;
 declare const Accepted: (options: AcceptedHttpResponseOptions) => HttpResponse;
 declare const NoContent: (options?: NoContentHttpResponseOptions) => HttpResponse;
-type HttpResponse = (response: Response) => void;
 declare const HttpResponse: (statusCode: number, options?: HttpResponseOptions) => HttpResponse;
 declare const BadRequest: (options?: HttpProblemResponseOptions) => HttpResponse;
 declare const Forbidden: (options?: HttpProblemResponseOptions) => HttpResponse;
@@ -87,7 +161,8 @@ declare const NotFound: (options?: HttpProblemResponseOptions) => HttpResponse;
 declare const Conflict: (options?: HttpProblemResponseOptions) => HttpResponse;
 declare const PreconditionFailed: (options: HttpProblemResponseOptions) => HttpResponse;
 declare const HttpProblem: (statusCode: number, options?: HttpProblemResponseOptions) => HttpResponse;
-
+//#endregion
+//#region src/testing/apiSpecification.d.ts
 type TestRequest = (request: TestAgent<supertest.Test>) => Test;
 declare const existingStream: <EventType extends Event = Event>(streamId: string, events: EventType[]) => TestEventStream<EventType>;
 type ResponseAssert = (response: Response$1) => boolean | void;
@@ -95,30 +170,44 @@ type ApiSpecificationAssert<EventType extends Event = Event> = TestEventStream<E
 declare const expect: <EventType extends Event = Event>(streamId: string, events: EventType[]) => TestEventStream<EventType>;
 declare const expectNewEvents: <EventType extends Event = Event>(streamId: string, events: EventType[]) => TestEventStream<EventType>;
 declare const expectResponse: <Body = unknown>(statusCode: number, options?: {
-    body?: Body;
-    headers?: {
-        [index: string]: string;
-    };
+  body?: Body;
+  headers?: {
+    [index: string]: string;
+  };
 }) => (response: Response$1) => void;
 declare const expectError: (errorCode: number, problemDetails?: Partial<ProblemDocument>) => (response: Response$1) => void;
 type ApiSpecification<EventType extends Event = Event> = (...givenStreams: TestEventStream<EventType>[]) => {
-    when: (setupRequest: TestRequest) => {
-        then: (verify: ApiSpecificationAssert<EventType>) => Promise<void>;
-    };
+  when: (setupRequest: TestRequest) => {
+    then: (verify: ApiSpecificationAssert<EventType>) => Promise<void>;
+  };
 };
+declare function apiSpecificationFor<EventType extends Event = Event, Store extends EventStore = EventStore>(options: {
+  getEventStore: () => Store;
+  getApplication: (eventStore: Store) => Application;
+}): ApiSpecification<EventType>;
+/** @deprecated Use `ApiSpecification.for({ getEventStore, getApplication })` instead */
+declare function apiSpecificationFor<EventType extends Event = Event, Store extends EventStore = EventStore>(getEventStore: () => Store, getApplication: (eventStore: Store) => Application): ApiSpecification<EventType>;
 declare const ApiSpecification: {
-    for: <EventType extends Event = Event, Store extends EventStore = EventStore<_event_driven_io_emmett.AnyRecordedMessageMetadata>>(getEventStore: () => Store, getApplication: (eventStore: Store) => Application) => ApiSpecification<EventType>;
+  for: typeof apiSpecificationFor;
 };
-
+//#endregion
+//#region src/testing/apiE2ESpecification.d.ts
 type E2EResponseAssert = (response: Response$1) => boolean | void;
 type ApiE2ESpecificationAssert = [E2EResponseAssert];
 type ApiE2ESpecification = (...givenRequests: TestRequest[]) => {
-    when: (setupRequest: TestRequest) => {
-        then: (verify: ApiE2ESpecificationAssert) => Promise<void>;
-    };
+  when: (setupRequest: TestRequest) => {
+    then: (verify: ApiE2ESpecificationAssert) => Promise<void>;
+  };
 };
+declare function apiE2ESpecificationFor<Store extends EventStore = InMemoryEventStore>(options: {
+  getEventStore?: () => Store;
+  getApplication: (eventStore: Store) => Application;
+}): ApiE2ESpecification;
+/** @deprecated Use `ApiE2ESpecification.for({ getEventStore, getApplication })` instead */
+declare function apiE2ESpecificationFor<Store extends EventStore = InMemoryEventStore>(getEventStore: () => Store, getApplication: (eventStore: Store) => Application): ApiE2ESpecification;
 declare const ApiE2ESpecification: {
-    for: <Store extends EventStore = EventStore<_event_driven_io_emmett.AnyRecordedMessageMetadata>>(getEventStore: () => Store, getApplication: (eventStore: Store) => Application) => ApiE2ESpecification;
+  for: typeof apiE2ESpecificationFor;
 };
-
-export { Accepted, type AcceptedHttpResponseOptions, ApiE2ESpecification, type ApiE2ESpecificationAssert, ApiSpecification, type ApiSpecificationAssert, type ApplicationOptions, BadRequest, Conflict, Created, type CreatedHttpResponseOptions, DefaultHttpProblemResponseOptions, DefaultHttpResponseOptions, type E2EResponseAssert, type ETag, ETagErrors, type ErrorToProblemDetailsMapping, Forbidden, HeaderNames, type HttpHandler, HttpProblem, type HttpProblemResponseOptions, HttpResponse, type HttpResponseOptions, NoContent, type NoContentHttpResponseOptions, NotFound, OK, PreconditionFailed, type ResponseAssert, type StartApiOptions, type TestRequest, type WeakETag, WeakETagRegex, type WebApiSetup, existingStream, expect, expectError, expectNewEvents, expectResponse, getApplication, getETagFromIfMatch, getETagFromIfNotMatch, getETagValueFromIfMatch, getWeakETagValue, isWeakETag, on, send, sendAccepted, sendCreated, sendProblem, setETag, startAPI, toWeakETag };
+//#endregion
+export { Accepted, AcceptedHttpResponseOptions, ApiE2ESpecification, ApiE2ESpecificationAssert, ApiSpecification, ApiSpecificationAssert, ApplicationOptions, BadRequest, Conflict, Created, CreatedHttpResponseOptions, DefaultHttpProblemResponseOptions, DefaultHttpResponseOptions, E2EResponseAssert, ETag, ETagErrors, ErrorToProblemDetailsMapping, Forbidden, HeaderNames, HttpHandler, HttpProblem, HttpProblemResponseOptions, HttpResponse, HttpResponseOptions, NoContent, NoContentHttpResponseOptions, NotFound, OK, PreconditionFailed, ResponseAssert, StartApiOptions, TestRequest, WeakETag, WeakETagRegex, WebApiSetup, existingStream, expect, expectError, expectNewEvents, expectResponse, getApplication, getETagFromIfMatch, getETagFromIfNotMatch, getETagValueFromIfMatch, getWeakETagValue, isWeakETag, on, send, sendAccepted, sendCreated, sendNoContent, sendProblem, setETag, startAPI, toWeakETag };
+//# sourceMappingURL=index.d.ts.map