Even more manual types

.gitignore

@@ -1,8 +1,5 @@
 .husky/_
-packages/fetch-error-handler/**/*.d.*
 packages/logger/**/*.d.*
-packages/middleware-log-errors/**/*.d.*
-packages/middleware-render-error-info/**/*.d.*
 coverage
 node_modules/
 resources/logos/dist

jsconfig.build.json

@@ -8,9 +8,6 @@
 		"removeComments": true
 	},
 	"include": [
-		"packages/fetch-error-handler/**/*.js",
-		"packages/logger/**/*.js",
-		"packages/middleware-log-errors/**/*.js",
-		"packages/middleware-render-error-info/**/*.js"
+		"packages/logger/**/*.js"
 	]
 }

jsconfig.json

@@ -24,6 +24,7 @@
 		"**/test/**/*"
 	],
 	"include": [
-		"**/*.js"
+		"**/*.js",
+		"**/*.d.ts"
 	]
 }

package.json

@@ -60,7 +60,7 @@
   "lint-staged": {
     "**/*.js": [
       "eslint --fix",
-      "prettier --write"
+      "prettier '**/*.{js,ts}' --write"
     ]
   }
 }

packages/app-info/types/index.d.ts

@@ -14,34 +14,34 @@ declare module '@dotcom-reliability-kit/app-info' {
 
 	export type SemanticConventions = {
 		cloud: {
-			provider?: string,
-			region?: string
-		},
+			provider?: string;
+			region?: string;
+		};
 		deployment: {
-			environment: string
-		},
+			environment: string;
+		};
 		service: {
-			name?: string
-			version?: string,
+			name?: string;
+			version?: string;
 			instance: {
-				id: string
-			}
-		}
+				id: string;
+			};
+		};
 	};
 
 	type appInfo = {
-		systemCode: typeof systemCode,
-		processType: typeof processType,
-		commitHash: typeof commitHash,
-		environment: typeof environment,
-		region: typeof region,
-		releaseDate: typeof releaseDate,
-		releaseVersion: typeof releaseVersion,
-		cloudProvider: typeof cloudProvider,
-		herokuAppId: typeof herokuAppId,
-		herokuDynoId: typeof herokuDynoId,
-		instanceId: typeof instanceId,
-		semanticConventions: SemanticConventions
+		systemCode: typeof systemCode;
+		processType: typeof processType;
+		commitHash: typeof commitHash;
+		environment: typeof environment;
+		region: typeof region;
+		releaseDate: typeof releaseDate;
+		releaseVersion: typeof releaseVersion;
+		cloudProvider: typeof cloudProvider;
+		herokuAppId: typeof herokuAppId;
+		herokuDynoId: typeof herokuDynoId;
+		instanceId: typeof instanceId;
+		semanticConventions: SemanticConventions;
 	};
 
 	export default appInfo;

packages/fetch-error-handler/.npmignore

@@ -1,5 +1,3 @@
-!*.d.ts
-!*.d.ts.map
 CHANGELOG.md
 docs
 test

packages/fetch-error-handler/package.json

@@ -14,7 +14,8 @@
     "node": "18.x || 20.x || 22.x",
     "npm": "8.x || 9.x || 10.x"
   },
-  "main": "lib",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
   "dependencies": {
     "@dotcom-reliability-kit/errors": "^3.1.1"
   },

packages/fetch-error-handler/types/index.d.ts

@@ -0,0 +1,28 @@
+import { Writable } from 'stream';
+
+declare module '@dotcom-reliability-kit/fetch-error-handler' {
+	export type ErrorHandlerOptions = {
+		upstreamSystemCode?: string;
+	};
+
+	type NodeFetchResponseBody = {
+		pipe?: (stream: Writable) => void;
+	};
+
+	type FetchResponse = {
+		ok: boolean;
+		status: number;
+		url: string;
+		body: NodeFetchResponseBody | ReadableStream<Uint8Array> | null;
+	};
+
+	export type FetchErrorHandler = <Response extends FetchResponse>(
+		fetchPromise: Response | Promise<Response>
+	) => Promise<Response>;
+
+	export function createFetchErrorHandler(
+		options?: ErrorHandlerOptions
+	): FetchErrorHandler;
+
+	export const handleFetchErrors: FetchErrorHandler;
+}

packages/middleware-log-errors/.npmignore

@@ -1,5 +1,3 @@
-!*.d.ts
-!*.d.ts.map
 CHANGELOG.md
 docs
 test

packages/middleware-log-errors/lib/index.js

@@ -3,34 +3,11 @@ const {
 	logRecoverableError
 } = require('@dotcom-reliability-kit/log-error');
 
-/**
- * @callback ErrorLoggingFilter
- * @param {any} error
- *     The error that will be logged.
- * @param {import('express').Request} request
- *     The Express request that resulted in the error.
- * @returns {boolean | void}
- *     Returns `true` if the error should be logged.
- */
-
-/**
- * @typedef {object} ErrorLoggingOptions
- * @property {string[]} [includeHeaders]
- *     An array of request headers to include in the log.
- * @property {ErrorLoggingFilter} [filter]
- *     A filter function to determine whether an error should be logged.
- * @property {import('@dotcom-reliability-kit/log-error').Logger & {[key: string]: any}} [logger]
- *     The logger to use to output errors. Defaults to Reliability Kit logger.
- */
-
 /**
  * Create a middleware function to log errors.
  *
- * @public
- * @param {ErrorLoggingOptions} [options]
- *     Options to configure the middleware.
+ * @param {import('@dotcom-reliability-kit/middleware-log-errors').ErrorLoggingOptions} [options]
  * @returns {import('express').ErrorRequestHandler}
- *     Returns error logging middleware.
  */
 function createErrorLoggingMiddleware(options = {}) {
 	// Validate the included headers (this stops the request serializer from erroring

packages/middleware-log-errors/package.json

@@ -14,7 +14,8 @@
     "node": "18.x || 20.x || 22.x",
     "npm": "8.x || 9.x || 10.x"
   },
-  "main": "lib",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
   "dependencies": {
     "@dotcom-reliability-kit/log-error": "^4.1.3"
   },

packages/middleware-log-errors/types/index.d.ts

@@ -0,0 +1,22 @@
+import { ErrorRequestHandler, Request } from 'express';
+import { Logger } from '@dotcom-reliability-kit/logger';
+
+declare module '@dotcom-reliability-kit/middleware-log-errors' {
+	export type ErrorLoggingFilter = (
+		error: any,
+		request: Request
+	) => boolean | void;
+
+	export type ErrorLoggingOptions = {
+		filter?: ErrorLoggingFilter;
+		includeHeaders?: string[];
+		logger?: Logger & { [key: string]: any };
+	};
+
+	declare function createErrorLoggingMiddleware(
+		options?: ErrorLoggingOptions
+	): ErrorRequestHandler;
+
+	export default createErrorLoggingMiddleware;
+	export = createErrorLoggingMiddleware;
+}

packages/middleware-render-error-info/.npmignore

@@ -1,5 +1,3 @@
-!*.d.ts
-!*.d.ts.map
 CHANGELOG.md
 docs
 test

packages/middleware-render-error-info/lib/index.js

@@ -4,20 +4,11 @@ const renderErrorPage = require('./render-error-page');
 const serializeError = require('@dotcom-reliability-kit/serialize-error');
 const { STATUS_CODES } = require('node:http');
 
-/**
- * @typedef {object} ErrorRenderingOptions
- * @property {import('@dotcom-reliability-kit/log-error').Logger & {[key: string]: any}} [logger]
- *     The logger to use to output errors. Defaults to Reliability Kit logger.
- */
-
 /**
  * Create a middleware function to render an error info page.
  *
- * @public
- * @param {ErrorRenderingOptions} [options]
- *     Options to configure the middleware.
+ * @param {import('@dotcom-reliability-kit/middleware-render-error-info').ErrorRenderingOptions} [options]
  * @returns {import('express').ErrorRequestHandler}
- *     Returns error info rendering middleware.
  */
 function createErrorRenderingMiddleware(options = {}) {
 	return function errorRenderingMiddleware(error, request, response, next) {

packages/middleware-render-error-info/package.json

@@ -14,7 +14,8 @@
     "node": "18.x || 20.x || 22.x",
     "npm": "8.x || 9.x || 10.x"
   },
-  "main": "lib",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
   "dependencies": {
     "@dotcom-reliability-kit/app-info": "^3.2.0",
     "@dotcom-reliability-kit/log-error": "^4.1.3",

packages/middleware-render-error-info/types/index.d.ts

@@ -0,0 +1,15 @@
+import { ErrorRequestHandler } from 'express';
+import { Logger } from '@dotcom-reliability-kit/logger';
+
+declare module '@dotcom-reliability-kit/middleware-render-error-info' {
+	export type ErrorRenderingOptions = {
+		logger?: Logger & { [key: string]: any };
+	};
+
+	declare function createErrorRenderingMiddleware(
+		options?: ErrorRenderingOptions
+	): ErrorRequestHandler;
+
+	export default createErrorRenderingMiddleware;
+	export = createErrorRenderingMiddleware;
+}

scripts/clean-generated-types.sh

@@ -1,6 +1,3 @@
 #!/usr/bin/env bash
 
-find ./packages/fetch-error-handler -name "*.d.ts*" | xargs -r rm
 find ./packages/logger -name "*.d.ts*" | xargs -r rm
-find ./packages/middleware-log-errors -name "*.d.ts*" | xargs -r rm
-find ./packages/middleware-render-error-info -name "*.d.ts*" | xargs -r rm

test/modules/js-commonjs-uncompiled/index.js

@@ -6,6 +6,8 @@ const { Logger, transforms } = require('@dotcom-reliability-kit/logger');
 const serializeError = require('@dotcom-reliability-kit/serialize-error');
 const serializeRequest = require('@dotcom-reliability-kit/serialize-request');
 const registerCrashHandler = require('@dotcom-reliability-kit/crash-handler');
+const renderErrorInfoPage = require('@dotcom-reliability-kit/middleware-render-error-info');
+const createErrorLogger = require('@dotcom-reliability-kit/middleware-log-errors');
 
 /**
  * @typedef {object} TypeTests
@@ -46,4 +48,14 @@ serializeRequest({ url: 'https://example.com' });
 // Test that crash handler works
 registerCrashHandler({ process, logger: logger1 || logger2 });
 
+// Test that error rendering middleware works
+renderErrorInfoPage({ logger: logger1 || logger2 });
+
+// Test that error logging works
+createErrorLogger({
+	filter: () => true,
+	includeHeaders: ['example'],
+	logger: logger1 || logger2
+});
+
 console.log('OK');

test/modules/js-esm-sucrase/index.js

@@ -6,6 +6,8 @@ import { Logger, transforms } from '@dotcom-reliability-kit/logger';
 import serializeError from '@dotcom-reliability-kit/serialize-error';
 import serializeRequest from '@dotcom-reliability-kit/serialize-request';
 import registerCrashHandler from '@dotcom-reliability-kit/crash-handler';
+import renderErrorInfoPage from '@dotcom-reliability-kit/middleware-render-error-info';
+import createErrorLogger from '@dotcom-reliability-kit/middleware-log-errors';
 
 /**
  * @typedef {object} TypeTests
@@ -46,4 +48,14 @@ serializeRequest({ url: 'https://example.com' });
 // Test that crash handler works
 registerCrashHandler({ process, logger: logger1 || logger2 });
 
+// Test that error rendering middleware works
+renderErrorInfoPage({ logger: logger1 || logger2 });
+
+// Test that error logging works
+createErrorLogger({
+	filter: () => true,
+	includeHeaders: ['example'],
+	logger: logger1 || logger2
+});
+
 console.log('OK');

test/modules/js-esm-uncompiled/index.js

@@ -6,6 +6,8 @@ import { Logger, transforms } from '@dotcom-reliability-kit/logger';
 import serializeError from '@dotcom-reliability-kit/serialize-error';
 import serializeRequest from '@dotcom-reliability-kit/serialize-request';
 import registerCrashHandler from '@dotcom-reliability-kit/crash-handler';
+import renderErrorInfoPage from '@dotcom-reliability-kit/middleware-render-error-info';
+import createErrorLogger from '@dotcom-reliability-kit/middleware-log-errors';
 
 /**
  * @typedef {object} TypeTests
@@ -46,4 +48,14 @@ serializeRequest({ url: 'https://example.com' });
 // Test that crash handler works
 registerCrashHandler({ process, logger: logger1 || logger2 });
 
+// Test that error rendering middleware works
+renderErrorInfoPage({ logger: logger1 || logger2 });
+
+// Test that error logging works
+createErrorLogger({
+	filter: () => true,
+	includeHeaders: ['example'],
+	logger: logger1 || logger2
+});
+
 console.log('OK');

test/modules/ts-commonjs/index.ts

@@ -6,6 +6,8 @@ const { Logger, transforms } = require('@dotcom-reliability-kit/logger');
 const serializeError = require('@dotcom-reliability-kit/serialize-error');
 const serializeRequest = require('@dotcom-reliability-kit/serialize-request');
 const registerCrashHandler = require('@dotcom-reliability-kit/crash-handler');
+const renderErrorInfoPage = require('@dotcom-reliability-kit/middleware-render-error-info');
+const createErrorLogger = require('@dotcom-reliability-kit/middleware-log-errors');
 
 type TypeTests = {
 	// @ts-ignore TODO this isn't working correctly and we'll need
@@ -17,11 +19,11 @@ type TypeTests = {
 	// to rethink the way we build our type definitions in order to
 	// support TypeScript written as CommonJS properly.
 	logger2: Logger;
-	
+
 	// These test that appInfo can be imported either
 	// as a default or named exports
-	environment1: string,
-	environment2: string
+	environment1: string;
+	environment2: string;
 };
 
 const result: TypeTests = {
@@ -54,4 +56,14 @@ serializeRequest({ url: 'https://example.com' });
 // Test that crash handler works
 registerCrashHandler({ process, logger: logger1 || logger2 });
 
+// Test that error rendering middleware works
+renderErrorInfoPage({ logger: logger1 || logger2 });
+
+// Test that error logging works
+createErrorLogger({
+	filter: () => true,
+	includeHeaders: ['example'],
+	logger: logger1 || logger2
+});
+
 console.log('OK');