chore: add eslint

Author: skoshx

packages/core/eslint.config.js

@@ -0,0 +1,11 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+import prettier from "eslint-plugin-prettier/recommended"
+
+export default [
+  {languageOptions: { globals: globals.browser }},
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  prettier,
+];

packages/core/package.json

@@ -39,13 +39,15 @@
 		"zod": "^3.22.4"
 	},
 	"devDependencies": {
+		"@eslint/js": "^9.0.0",
 		"@types/node": "^18.16.0",
 		"@typescript-eslint/eslint-plugin": "^7.0.2",
-		"eslint": "^8.56.0",
-		"eslint-config-prettier": "^8.8.0",
+		"eslint": "^8.57.0",
+		"eslint-config-prettier": "^8.10.0",
 		"eslint-plugin-prettier": "^5.1.3",
+		"globals": "^15.0.0",
 		"typescript": "^5.3.3",
-		"typescript-eslint": "^7.0.2",
+		"typescript-eslint": "^7.6.0",
 		"unbuild": "^2.0.0",
 		"vite": "^5.1.4",
 		"vitest": "^1.3.1"

packages/core/src/index.ts

@@ -1,6 +1,12 @@
 import { z } from "zod"
 import { baseLogSchema } from "./schemas"
-import { catchUncaughtAction, catchUncaughtRoute } from "./request-utils"
+import {
+  catchUncaughtAction,
+  catchUncaughtRoute,
+  json,
+  redirect,
+  response,
+} from "./request-utils"
 import { buildJsonLog, buildTextLog } from "./utils"
 
 export type FlytrapLogsOptions = {
@@ -71,7 +77,7 @@ export function createFlytrapLogger<T>({
     method: "GET",
   } satisfies z.infer<typeof baseLogSchema>
 
-  let logs: Array<Partial<Log>> = [defaultLog as Log]
+  const logs: Array<Partial<Log>> = [defaultLog as Log]
 
   // Function defintions
   function getContext() {
@@ -125,12 +131,27 @@ export function createFlytrapLogger<T>({
       fn: T,
       options?: Partial<z.infer<typeof baseLogSchema>>
     ) {
+      // @ts-expect-error
       return catchUncaughtAction(fn, addContext, flush, options)
     },
     catchUncaughtRoute<T extends { params: Record<string, unknown> }>(
-      fn: (request: Request, context: T) => Promise<Response> | Response
+      fn: (request: Request, context: T) => Promise<Response> | Response,
+      options?: Partial<z.infer<typeof baseLogSchema>>
     ) {
-      return catchUncaughtRoute(fn, addContext, flush)
+      // @ts-expect-error
+      return catchUncaughtRoute(fn, addContext, flush, options)
+    },
+    response(body: BodyInit, opts: ResponseInit = {}) {
+      // @ts-expect-error
+      return response(body, opts, addContext)
+    },
+    json(data: any, opts: ResponseInit = {}) {
+      // @ts-expect-error
+      return json(data, opts, addContext)
+    },
+    redirect(url: string | URL, status?: number) {
+      // @ts-expect-error
+      return redirect(url, status, addContext)
     },
   }
 }

packages/core/src/request-utils.ts

@@ -1,4 +1,3 @@
-import { createFlytrapLogger } from "./index"
 import { serializeError } from "serialize-error"
 import { baseLogSchema } from "./schemas"
 import { z } from "zod"
@@ -8,7 +7,7 @@ import { AddContextFn, FlushFn } from "./types"
 export function response(
   body: BodyInit,
   opts: ResponseInit = {},
-  addContext: ReturnType<typeof createFlytrapLogger>["addContext"]
+  addContext: AddContextFn<z.infer<typeof baseLogSchema>>
 ) {
   addContext({
     res: parseJsonOrPassthrough(body),
@@ -18,15 +17,40 @@ export function response(
   return new Response(body, opts)
 }
 
+export function json(
+  data: any,
+  opts: ResponseInit = {},
+  addContext: AddContextFn<z.infer<typeof baseLogSchema>>
+) {
+  addContext({
+    res: data,
+    http_status: opts.status ?? 200,
+  })
+  return Response.json(data, opts)
+}
+
+export function redirect(
+  url: string | URL,
+  status: number = 302,
+  addContext: AddContextFn<z.infer<typeof baseLogSchema>>
+) {
+  addContext({
+    http_status: status,
+  })
+  return Response.redirect(url, status)
+}
+
 export function catchUncaughtRoute<
-  T extends { params: Record<string, unknown> }
+  T extends { params: Record<string, unknown> },
 >(
   fn: (request: Request, context: T) => Promise<Response> | Response,
   addContext: AddContextFn<z.infer<typeof baseLogSchema>>,
-  flush: FlushFn
+  flush: FlushFn,
+  options?: Partial<z.infer<typeof baseLogSchema>>
 ): (request: Request, context: T) => Promise<Response> {
   return async (request: Request, context: T) => {
     const t0 = Date.now()
+    if (options) addContext(options)
     try {
       addContext({
         req_headers: headersToRecord(request.headers),