add createNotFoundEndpoint

pkg/main.ts

@@ -1,3 +1,4 @@
+export { createNotFoundEndpoint } from "../src/createNotFoundEndpoint/createNotFoundEndpoint";
 export { createPipeline } from "../src/createPipeline/createPipeline";
 export { createRequestHandler } from "../src/createRequestHandler/createRequestHandler";
 export { createServer } from "../src/createServer/createServer";
@@ -11,7 +12,7 @@ export { deserialize } from "../src/middlewares/deserialize/deserialize";
 export { finalize } from "../src/middlewares/finalize/finalize";
 export { isFinalized } from "../src/middlewares/finalize/helpers/isFinalized";
 export { handleValidationErrors } from "../src/middlewares/handleValidationErrors/handleValidationErrors";
-export { logger } from "../src/middlewares/logger";
+export { logger } from "../src/middlewares/logger/logger";
 export { notFound } from "../src/middlewares/notFound/notFound";
 export { serialize } from "../src/middlewares/serialize/serialize";
 export { withValidation } from "../src/middlewares/withValidation";

src/createNotFoundEndpoint/createNotFoundEndpoint.ts

@@ -0,0 +1,18 @@
+import { createPipeline } from "../createPipeline/createPipeline";
+import { HasPipeline } from "../helpers/types";
+import { LoggerParams } from "../middlewares/logger/helpers/types";
+import { logger } from "../middlewares/logger/logger";
+import { notFound } from "../middlewares/notFound/notFound";
+
+export function createNotFoundEndpoint(
+  params?: {
+    paths?: Array<string>;
+  } & LoggerParams
+): HasPipeline {
+  return {
+    pipeline: createPipeline(
+      notFound(...(params?.paths ?? [])),
+      logger(params)
+    ),
+  };
+}

src/createServer/createServer.ts

@@ -6,7 +6,6 @@ import { CreateServerParams, Server } from "./helpers/types";
 
 declare const Deno: any;
 
-// TODO can't we serve the notFound pipeline by default in here?
 export function createServer(params: CreateServerParams): Server {
   const finalParams: Required<CreateServerParams> = {
     hostname: params.hostname ?? "localhost",

src/helpers/testHelpers/mockEndpoint.ts

@@ -1,14 +1,13 @@
 import { vi } from "vitest";
 import { z } from "zod";
-import { createPipeline } from "../../createPipeline/createPipeline";
+import { createNotFoundEndpoint } from "../../createNotFoundEndpoint/createNotFoundEndpoint";
 import { BasePipelineContext } from "../../createPipeline/helpers/types";
 import { createRequestHandler } from "../../createRequestHandler/createRequestHandler";
 import {
   CreateResponse,
   postProcess,
 } from "../../createServer/helpers/postProcess";
 import { Endpoint } from "../../createValidatedEndpointFactory/helpers/types";
-import { notFound } from "../../middlewares/notFound/notFound";
 import { noopLogger } from "../noopLogger";
 import {
   EndpointDeclarationBase,
@@ -17,7 +16,7 @@ import {
   StatusCode,
 } from "../types";
 
-const notFoundEndpoint = { pipeline: createPipeline(notFound()) };
+const notFoundEndpoint = createNotFoundEndpoint();
 
 const createResponse: CreateResponse<Response, void> = (
   body,

src/middlewares/logger/helpers/types.ts

@@ -0,0 +1,7 @@
+import { Logger } from "../../../helpers/types";
+import { FinalizeContext } from "../../finalize/helpers/types";
+
+export type LoggerParams = {
+  logger?: Logger;
+  getLogStatement?: (context: FinalizeContext) => Promise<string>;
+};

src/middlewares/logger.ts → src/middlewares/logger/logger.ts

@@ -1,13 +1,12 @@
-import type { Middleware } from "../createPipeline/helpers/types";
-import { consoleLogger } from "../helpers/consoleLogger";
-import { getDefaultLogStatement } from "../helpers/getDefaultLogStatement";
-import { Logger } from "../helpers/types";
-import { FinalizeContext } from "./finalize/helpers/types";
+import type { Middleware } from "../../createPipeline/helpers/types";
+import { consoleLogger } from "../../helpers/consoleLogger";
+import { getDefaultLogStatement } from "../../helpers/getDefaultLogStatement";
+import { FinalizeContext } from "../finalize/helpers/types";
+import { LoggerParams } from "./helpers/types";
 
-export const logger = <PipelineContext extends FinalizeContext>(params?: {
-  logger?: Logger;
-  getLogStatement?: (context: FinalizeContext) => Promise<string>;
-}): Middleware<PipelineContext, PipelineContext> => {
+export const logger = <PipelineContext extends FinalizeContext>(
+  params?: LoggerParams
+): Middleware<PipelineContext, PipelineContext> => {
   const logger = params?.logger ?? consoleLogger;
   const getLogStatement = params?.getLogStatement ?? getDefaultLogStatement;