commit 7ed262bd8429da89222dc9af5b7d99fb661fdb43 · ptr.pet/barometer

proxy/bun.lock

···

       11
       11
        
               "@atcute/lexicons": "^1.1.0",

     

       12
       12
        
               "@atcute/tid": "^1.0.2",

     

       13
       13
        
               "barometer-lexicon": "file:../lib",

     

       14
       14
       +
               "parsimmon": "^1.18.1",

     

       14
       15
        
             },

     

       15
       16
        
             "devDependencies": {

     

       16
       17
        
               "@types/bun": "latest",

     

       18
       18
       +
               "@types/parsimmon": "^1.10.9",

     

       17
       19
        
               "concurrently": "^9.2.0",

     

       18
       20
        
             },

     

       19
       21
        
             "peerDependencies": {

     
···

       48
       50
        
       

     

       49
       51
        
           "@types/node": ["@types/node@24.0.13", "", { "dependencies": { "undici-types": "~7.8.0" } }, "sha512-Qm9OYVOFHFYg3wJoTSrz80hoec5Lia/dPp84do3X7dZvLikQvM1YpmvTBEdIr/e+U8HTkFjLHLnl78K/qjf+jQ=="],

     

       50
       52
        
       

     

       53
       53
       +
           "@types/parsimmon": ["@types/parsimmon@1.10.9", "", {}, "sha512-O2M2x1w+m7gWLen8i5DOy6tWRnbRcsW6Pke3j3HAsJUrPb4g0MgjksIUm2aqUtCYxy7Qjr3CzjjwQBzhiGn46A=="],

     

       54
       54
       +
       

     

       51
       55
        
           "@types/react": ["@types/react@19.1.8", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-AwAfQ2Wa5bCx9WP8nZL2uMZWod7J7/JSplxbTmBQ5ms6QpqNYm672H0Vu9ZVKVngQ+ii4R/byguVEUZQyeg44g=="],

     

       52
       56
        
       

     

       53
       57
        
           "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="],

     
···

       83
       87
        
           "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],

     

       84
       88
        
       

     

       85
       89
        
           "lodash": ["lodash@4.17.21", "", {}, "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="],

     

       90
       90
       +
       

     

       91
       91
       +
           "parsimmon": ["parsimmon@1.18.1", "", {}, "sha512-u7p959wLfGAhJpSDJVYXoyMCXWYwHia78HhRBWqk7AIbxdmlrfdp5wX0l3xv/iTSH5HvhN9K7o26hwwpgS5Nmw=="],

     

       86
       92
        
       

     

       87
       93
        
           "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="],

     

       88
       94

+4 -1

proxy/gen-routes.ts

···

       28
       28
        
       const indexContent = `// Auto-generated route index

     

       29
       29
        
       ${routeImports.join("\n")}

     

       30
       30
        
       

     

       31
       31
       -
       export const routes = {

     

       31
       31
       +
       export const routes: Record<

     

       32
       32
       +
         string,

     

       33
       33
       +
         Record<string, Bun.RouterTypes.RouteHandler<string>>

     

       34
       34
       +
       > = {

     

       32
       35
        
       ${routeMap.join(",\n")}

     

       33
       36
        
       };

     

       34
       37

+3 -1

proxy/package.json

···

       9
       9
        
         },

     

       10
       10
        
         "devDependencies": {

     

       11
       11
        
           "@types/bun": "latest",

     

       12
       12
       +
           "@types/parsimmon": "^1.10.9",

     

       12
       13
        
           "concurrently": "^9.2.0"

     

       13
       14
        
         },

     

       14
       15
        
         "peerDependencies": {

     
···

       21
       22
        
           "@atcute/identity-resolver": "^1.1.3",

     

       22
       23
        
           "@atcute/lexicons": "^1.1.0",

     

       23
       24
        
           "@atcute/tid": "^1.0.2",

     

       24
       24
       -
           "barometer-lexicon": "file:../lib"

     

       25
       25
       +
           "barometer-lexicon": "file:../lib",

     

       26
       26
       +
           "parsimmon": "^1.18.1"

     

       25
       27
        
         }

     

       26
       28
        
       }

+21 -7

proxy/src/index.ts

···

       1
       1
        
       import os from "os";

     

       2
       2
       -
       

     

       3
       2
        
       import { Client, CredentialManager } from "@atcute/client";

     

       4
       3
        
       import { getPdsEndpoint } from "@atcute/identity";

     

       5
       4
        
       import {

     
···

       9
       8
        
       } from "@atcute/identity-resolver";

     

       10
       9
        
       import { config } from "./config";

     

       11
       10
        
       import type {} from "@atcute/atproto";

     

       12
       12
       -
       import { getRecord, ok, putRecord, type Result } from "./utils";

     

       11
       11
       +
       import {

     

       12
       12
       +
         applyMiddleware,

     

       13
       13
       +
         applyMiddlewareAll,

     

       14
       14
       +
         getRecord,

     

       15
       15
       +
         log,

     

       16
       16
       +
         ok,

     

       17
       17
       +
         putRecord,

     

       18
       18
       +
         type Middleware,

     

       19
       19
       +
         type Result,

     

       20
       20
       +
       } from "./utils";

     

       13
       21
        
       import store from "./store";

     

       14
       22
        
       import routes from "./routes";

     

       15
       23
        
       

     
···

       36
       44
        
       // fetch host record for this host

     

       37
       45
        
       const maybeRecord = await getRecord(

     

       38
       46
        
         "systems.gaze.barometer.host",

     

       39
       39
       -
         os.hostname(),

     

       47
       47
       +
         store.hostname,

     

       40
       48
        
       );

     

       41
       49
        
       if (maybeRecord.ok) {

     

       42
       50
        
         store.host = maybeRecord.value;

     
···

       44
       52
        
       

     

       45
       53
        
       // if it doesnt exist we make a new one

     

       46
       54
        
       if (store.host === null) {

     

       47
       47
       -
         const hostname = os.hostname();

     

       48
       55
        
         await putRecord(

     

       49
       56
        
           {

     

       50
       57
        
             $type: "systems.gaze.barometer.host",

     

       51
       51
       -
             name: config.hostName ?? hostname,

     

       58
       58
       +
             name: config.hostName ?? store.hostname,

     

       52
       59
        
             description: config.hostDescription,

     

       53
       60
        
             os: os.platform(),

     

       54
       61
        
           },

     

       55
       55
       -
           hostname,

     

       62
       62
       +
           store.hostname,

     

       56
       63
        
         );

     

       57
       64
        
       }

     

       58
       65
        
       

     

       59
       59
       -
       const server = Bun.serve({ routes });

     

       66
       66
       +
       const traceRequest: Middleware = async (req) => {

     

       67
       67
       +
         const url = new URL(req.url);

     

       68
       68
       +
         log.info(`${req.method} ${url.pathname}`);

     

       69
       69
       +
         return req;

     

       70
       70
       +
       };

     

       71
       71
       +
       const server = Bun.serve({

     

       72
       72
       +
         routes: applyMiddlewareAll([traceRequest], routes),

     

       73
       73
       +
       });

     

       60
       74
        
       

     

       61
       75
        
       console.log(`server running on http://localhost:${server.port}`);

+4 -1

proxy/src/routes/index.ts

···

       2
       2
        
       import * as _healthRoute from "./_health";

     

       3
       3
        
       import * as pushRoute from "./push";

     

       4
       4
        
       

     

       5
       5
       -
       export const routes = {

     

       5
       5
       +
       export const routes: Record<

     

       6
       6
       +
         string,

     

       7
       7
       +
         Record<string, Bun.RouterTypes.RouteHandler<string>>

     

       8
       8
       +
       > = {

     

       6
       9
        
         "/_health": _healthRoute,

     

       7
       10
        
         "/push": pushRoute

     

       8
       11
        
       };

+77 -18

proxy/src/routes/push.ts

···

       1
       1
       -
       import { SystemsGazeBarometerState } from "barometer-lexicon";

     

       2
       1
        
       import { err, expect, getRecord, ok, putRecord, type Result } from "../utils";

     

       3
       2
        
       import { parseCanonicalResourceUri, safeParse } from "@atcute/lexicons";

     

       4
       4
       -
       import store from "../store";

     

       3
       3
       +
       import store, { type Service } from "../store";

     

       4
       4
       +
       import { systemctlShow } from "../systemd";

     

       5
       5
       +
       import { config } from "../config";

     

       6
       6
       +
       import { now as generateTid } from "@atcute/tid";

     

       7
       7
       +
       import * as v from "@atcute/lexicons/validations";

     

       8
       8
       +
       import type { SystemsGazeBarometerService } from "barometer-lexicon";

     

       9
       9
       +
       

     

       10
       10
       +
       // this is hacky but we want to make forService be optional so its okay

     

       11
       11
       +
       const StateSchemaSubset = v.record(

     

       12
       12
       +
         v.tidString(),

     

       13
       13
       +
         v.object({

     

       14
       14
       +
           $type: v.literal("systems.gaze.barometer.state"),

     

       15
       15
       +
           changedAt: v.datetimeString(),

     

       16
       16
       +
           forService: v.optional(v.resourceUriString()),

     

       17
       17
       +
           generatedBy: v.optional(v.resourceUriString()),

     

       18
       18
       +
           reason: v.optional(v.string()),

     

       19
       19
       +
           from: v.literalEnum([

     

       20
       20
       +
             "systems.gaze.barometer.status.degraded",

     

       21
       21
       +
             "systems.gaze.barometer.status.healthy",

     

       22
       22
       +
             "systems.gaze.barometer.status.unknown",

     

       23
       23
       +
           ]),

     

       24
       24
       +
           to: v.literalEnum([

     

       25
       25
       +
             "systems.gaze.barometer.status.degraded",

     

       26
       26
       +
             "systems.gaze.barometer.status.healthy",

     

       27
       27
       +
           ]),

     

       28
       28
       +
         }),

     

       29
       29
       +
       );

     

       5
       30
        
       

     

       6
       31
        
       interface PushRequest {

     

       7
       32
        
         serviceName?: string; // service manager service name

     

       8
       8
       -
         state: SystemsGazeBarometerState.Main;

     

       33
       33
       +
         state: v.InferOutput<typeof StateSchemaSubset>;

     

       9
       34
        
       }

     

       10
       35
        
       

     

       11
       36
        
       const parsePushRequest = (json: unknown): Result<PushRequest, string> => {

     
···

       16
       41
        
           return err("serviceName is not a string");

     

       17
       42
        
         }

     

       18
       43
        
         if ("state" in json) {

     

       19
       19
       -
           const parsed = safeParse(SystemsGazeBarometerState.mainSchema, json.state);

     

       44
       44
       +
           const parsed = safeParse(StateSchemaSubset, json.state);

     

       20
       45
        
           if (!parsed.ok) {

     

       21
       46
        
             return err(`state is invalid: ${parsed.message}`);

     

       22
       47
        
           }

     
···

       38
       63
        
         }

     

       39
       64
        
         const data = maybeData.value;

     

       40
       65
        
       

     

       41
       41
       -
         const serviceAtUri = expect(parseCanonicalResourceUri(data.state.forService));

     

       42
       42
       -
         let service = store.services.get(serviceAtUri.rkey);

     

       43
       43
       -
         if (!service) {

     

       44
       44
       -
           const serviceRecord = await getRecord(

     

       45
       45
       -
             "systems.gaze.barometer.service",

     

       46
       46
       -
             serviceAtUri.rkey,

     

       66
       66
       +
         let service: Service | undefined = undefined;

     

       67
       67
       +
         if (data.state.forService) {

     

       68
       68
       +
           const serviceAtUri = expect(

     

       69
       69
       +
             parseCanonicalResourceUri(data.state.forService),

     

       47
       70
        
           );

     

       48
       48
       -
           if (!serviceRecord.ok) {

     

       71
       71
       +
           service = store.services.get(serviceAtUri.rkey);

     

       72
       72
       +
           if (!service) {

     

       73
       73
       +
             let serviceRecord = await getRecord(

     

       74
       74
       +
               "systems.gaze.barometer.service",

     

       75
       75
       +
               serviceAtUri.rkey,

     

       76
       76
       +
             );

     

       77
       77
       +
             if (!serviceRecord.ok) {

     

       78
       78
       +
               return badRequest({

     

       79
       79
       +
                 msg: `service was not found or is invalid: ${serviceRecord.error}`,

     

       80
       80
       +
               });

     

       81
       81
       +
             }

     

       82
       82
       +
             service = {

     

       83
       83
       +
               record: serviceRecord.value,

     

       84
       84
       +
               checks: new Map(),

     

       85
       85
       +
             };

     

       86
       86
       +
             store.services.set(serviceAtUri.rkey, service);

     

       87
       87
       +
           }

     

       88
       88
       +
         } else if (data.serviceName) {

     

       89
       89
       +
           const serviceInfo = await systemctlShow(data.serviceName);

     

       90
       90
       +
           if (serviceInfo.ok) {

     

       91
       91
       +
             const record: SystemsGazeBarometerService.Main = {

     

       92
       92
       +
               $type: "systems.gaze.barometer.service",

     

       93
       93
       +
               name: data.serviceName,

     

       94
       94
       +
               description: serviceInfo.value.description,

     

       95
       95
       +
               hostedBy: `at://${config.repoDid}/systems.gaze.barometer.host/${store.hostname}`,

     

       96
       96
       +
             };

     

       97
       97
       +
             const rkey = generateTid();

     

       98
       98
       +
             const putAt = await putRecord(record, rkey);

     

       99
       99
       +
             data.state.forService = putAt.uri;

     

       100
       100
       +
             service = {

     

       101
       101
       +
               record,

     

       102
       102
       +
               checks: new Map(),

     

       103
       103
       +
             };

     

       104
       104
       +
             store.services.set(rkey, service);

     

       105
       105
       +
           } else {

     

       49
       106
        
             return badRequest({

     

       50
       50
       -
               msg: `service was not found or is invalid: ${serviceRecord.error}`,

     

       107
       107
       +
               msg: `could not fetch service from systemd: ${serviceInfo.error}`,

     

       51
       108
        
             });

     

       52
       109
        
           }

     

       53
       53
       -
           service = {

     

       54
       54
       -
             record: serviceRecord.value,

     

       55
       55
       -
             checks: new Map(),

     

       56
       56
       -
           };

     

       57
       57
       -
           store.services.set(serviceAtUri.rkey, service);

     

       110
       110
       +
         } else {

     

       111
       111
       +
           return badRequest({

     

       112
       112
       +
             msg: `either 'state.forService' or 'serviceName' must be provided`,

     

       113
       113
       +
           });

     

       58
       114
        
         }

     

       59
       115
        
       

     

       60
       116
        
         if (data.state.generatedBy) {

     
···

       79
       135
        
           }

     

       80
       136
        
         }

     

       81
       137
        
       

     

       82
       82
       -
         const result = await putRecord(data.state);

     

       138
       138
       +
         const result = await putRecord(

     

       139
       139
       +
           { ...data.state, forService: data.state.forService! },

     

       140
       140
       +
           generateTid(),

     

       141
       141
       +
         );

     

       83
       142
        
         return new Response(JSON.stringify({ cid: result.cid, uri: result.uri }));

     

       84
       143
        
       };

+5 -2

proxy/src/store.ts

···

       1
       1
       +
       import os from "os";

     

       1
       2
        
       import type { RecordKey } from "@atcute/lexicons";

     

       2
       3
        
       import type {

     

       3
       4
        
         SystemsGazeBarometerCheck,

     
···

       5
       6
        
         SystemsGazeBarometerService,

     

       6
       7
        
       } from "barometer-lexicon";

     

       7
       8
        
       

     

       8
       8
       -
       interface Check {

     

       9
       9
       +
       export interface Check {

     

       9
       10
        
         record: SystemsGazeBarometerCheck.Main;

     

       10
       11
        
       }

     

       11
       11
       -
       interface Service {

     

       12
       12
       +
       export interface Service {

     

       12
       13
        
         checks: Map<RecordKey, Check>;

     

       13
       14
        
         record: SystemsGazeBarometerService.Main;

     

       14
       15
        
       }

     
···

       16
       17
        
       class Store {

     

       17
       18
        
         services;

     

       18
       19
        
         host: SystemsGazeBarometerHost.Main | null;

     

       20
       20
       +
         hostname: string;

     

       19
       21
        
       

     

       20
       22
        
         constructor() {

     

       21
       23
        
           this.services = new Map<RecordKey, Service>();

     

       22
       24
        
           this.host = null;

     

       25
       25
       +
           this.hostname = os.hostname();

     

       23
       26
        
         }

     

       24
       27
        
       }

     

       25
       28

+92

proxy/src/systemd.ts

···

       1
       1
       +
       import { spawn } from "bun";

     

       2
       2
       +
       import P from "parsimmon";

     

       3
       3
       +
       import { err, ok, type Result } from "./utils";

     

       4
       4
       +
       

     

       5
       5
       +
       interface SystemctlShowOutput {

     

       6
       6
       +
         [key: string]: string;

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       // Parsimmon parsers for systemctl output

     

       10
       10
       +
       const newline = P.string("\n");

     

       11
       11
       +
       const equals = P.string("=");

     

       12
       12
       +
       

     

       13
       13
       +
       // Key: anything except = and newline

     

       14
       14
       +
       const key = P.regexp(/[^=\n]+/).map((s) => s.trim());

     

       15
       15
       +
       

     

       16
       16
       +
       // Single line value: everything until newline (or end of input)

     

       17
       17
       +
       const singleLineValue = P.regexp(/[^\n]*/);

     

       18
       18
       +
       

     

       19
       19
       +
       // Continuation line: newline followed by whitespace and content

     

       20
       20
       +
       const continuationLine = P.seq(

     

       21
       21
       +
         newline,

     

       22
       22
       +
         P.regexp(/[ \t]*/), // optional whitespace

     

       23
       23
       +
         P.regexp(/[^\n]*/), // content

     

       24
       24
       +
       ).map(([, , content]) => "\n" + content);

     

       25
       25
       +
       

     

       26
       26
       +
       // Multi-line value: first line + any continuation lines

     

       27
       27
       +
       const multiLineValue = P.seq(singleLineValue, continuationLine.many()).map(

     

       28
       28
       +
         ([first, continuations]) => (first + continuations.join("")).trim(),

     

       29
       29
       +
       );

     

       30
       30
       +
       

     

       31
       31
       +
       // Key-value pair: key = value

     

       32
       32
       +
       const keyValuePair = P.seq(key, equals, multiLineValue).map(([k, , v]) => ({

     

       33
       33
       +
         key: k,

     

       34
       34
       +
         value: v,

     

       35
       35
       +
       }));

     

       36
       36
       +
       

     

       37
       37
       +
       // Empty line (just whitespace)

     

       38
       38
       +
       const emptyLine = P.regexp(/[ \t]*/).result(null);

     

       39
       39
       +
       

     

       40
       40
       +
       // A line is either a key-value pair or empty line

     

       41
       41
       +
       const line = P.alt(keyValuePair, emptyLine);

     

       42
       42
       +
       

     

       43
       43
       +
       // Complete systemctl output: lines separated by newlines, ending with optional newline

     

       44
       44
       +
       const systemctlOutput = P.seq(line.sepBy(newline), P.alt(newline, P.eof)).map(

     

       45
       45
       +
         ([lines]) =>

     

       46
       46
       +
           lines.filter((l): l is { key: string; value: string } => l !== null),

     

       47
       47
       +
       );

     

       48
       48
       +
       

     

       49
       49
       +
       const parseSystemctlOutput = (

     

       50
       50
       +
         output: string,

     

       51
       51
       +
       ): Result<SystemctlShowOutput, string> => {

     

       52
       52
       +
         const result = systemctlOutput.parse(output);

     

       53
       53
       +
       

     

       54
       54
       +
         if (!result.status) {

     

       55
       55
       +
           return err(

     

       56
       56
       +
             `Parse error at position ${result.index.offset}: ${result.expected.join(", ")}`,

     

       57
       57
       +
           );

     

       58
       58
       +
         }

     

       59
       59
       +
       

     

       60
       60
       +
         const kvMap: SystemctlShowOutput = {};

     

       61
       61
       +
       

     

       62
       62
       +
         for (const { key, value } of result.value) {

     

       63
       63
       +
           if (value.length > 0) {

     

       64
       64
       +
             kvMap[key.toLowerCase()] = value;

     

       65
       65
       +
           }

     

       66
       66
       +
         }

     

       67
       67
       +
       

     

       68
       68
       +
         return ok(kvMap);

     

       69
       69
       +
       };

     

       70
       70
       +
       

     

       71
       71
       +
       export const systemctlShow = async (

     

       72
       72
       +
         serviceName: string,

     

       73
       73
       +
       ): Promise<Result<SystemctlShowOutput, string>> => {

     

       74
       74
       +
         try {

     

       75
       75
       +
           const proc = spawn(["systemctl", "show", `${serviceName}.service`], {

     

       76
       76
       +
             stdout: "pipe",

     

       77
       77
       +
             stderr: "pipe",

     

       78
       78
       +
           });

     

       79
       79
       +
       

     

       80
       80
       +
           const output = await new Response(proc.stdout).text();

     

       81
       81
       +
           const exitCode = await proc.exited;

     

       82
       82
       +
       

     

       83
       83
       +
           if (exitCode !== 0) {

     

       84
       84
       +
             const error = await new Response(proc.stderr).text();

     

       85
       85
       +
             return err(`systemctl show failed with exit code ${exitCode}: ${error}`);

     

       86
       86
       +
           }

     

       87
       87
       +
       

     

       88
       88
       +
           return parseSystemctlOutput(output);

     

       89
       89
       +
         } catch (error) {

     

       90
       90
       +
           return err(`failed to execute systemctl show: ${error}`);

     

       91
       91
       +
         }

     

       92
       92
       +
       };

+51 -3

proxy/src/utils.ts

···

       2
       2
        
       import { schemas as BarometerSchemas } from "barometer-lexicon";

     

       3
       3
        
       import { config } from "./config";

     

       4
       4
        
       import { ok as clientOk } from "@atcute/client";

     

       5
       5
       -
       import { now as generateTid } from "@atcute/tid";

     

       6
       5
        
       import { atpClient } from ".";

     

       7
       6
        
       

     

       8
       7
        
       export type Result<T, E> =

     
···

       64
       63
        
         Collection extends keyof typeof BarometerSchemas,

     

       65
       64
        
       >(

     

       66
       65
        
         record: InferOutput<(typeof BarometerSchemas)[Collection]>,

     

       67
       67
       -
         rkey?: RecordKey,

     

       66
       66
       +
         rkey: RecordKey,

     

       68
       67
        
       ) => {

     

       69
       68
        
         return await clientOk(

     

       70
       69
        
           atpClient.post("com.atproto.repo.putRecord", {

     
···

       72
       71
        
               collection: record["$type"],

     

       73
       72
        
               repo: config.repoDid,

     

       74
       73
        
               record,

     

       75
       75
       -
               rkey: rkey ?? generateTid(),

     

       74
       74
       +
               rkey,

     

       76
       75
        
             },

     

       77
       76
        
           }),

     

       78
       77
        
         );

     

       79
       78
        
       };

     

       79
       79
       +
       

     

       80
       80
       +
       export const log = {

     

       81
       81
       +
         info: console.log,

     

       82
       82
       +
         warn: console.warn,

     

       83
       83
       +
         error: console.error,

     

       84
       84
       +
       };

     

       85
       85
       +
       

     

       86
       86
       +
       export type Middleware = (

     

       87
       87
       +
         req: Bun.BunRequest,

     

       88
       88
       +
       ) => Promise<Bun.BunRequest | Response>;

     

       89
       89
       +
       

     

       90
       90
       +
       export const applyMiddleware =

     

       91
       91
       +
         <T extends string>(

     

       92
       92
       +
           fns: Middleware[],

     

       93
       93
       +
           route: Bun.RouterTypes.RouteHandler<T>,

     

       94
       94
       +
         ): Bun.RouterTypes.RouteHandler<T> =>

     

       95
       95
       +
         async (req, srv) => {

     

       96
       96
       +
           for (const fn of fns) {

     

       97
       97
       +
             const result = await fn(req);

     

       98
       98
       +
             if (result instanceof Response) {

     

       99
       99
       +
               return result;

     

       100
       100
       +
             } else {

     

       101
       101
       +
               req = result;

     

       102
       102
       +
             }

     

       103
       103
       +
           }

     

       104
       104
       +
           return route(req, srv);

     

       105
       105
       +
         };

     

       106
       106
       +
       

     

       107
       107
       +
       type Routes = Record<

     

       108
       108
       +
         string,

     

       109
       109
       +
         Record<string, Bun.RouterTypes.RouteHandler<string>>

     

       110
       110
       +
       >;

     

       111
       111
       +
       export const applyMiddlewareAll = (

     

       112
       112
       +
         fns: Middleware[],

     

       113
       113
       +
         routes: Routes,

     

       114
       114
       +
       ): Routes => {

     

       115
       115
       +
         return Object.fromEntries(

     

       116
       116
       +
           Object.entries(routes).map(([path, route]) => {

     

       117
       117
       +
             return [

     

       118
       118
       +
               path,

     

       119
       119
       +
               Object.fromEntries(

     

       120
       120
       +
                 Object.entries(route).map(([method, handler]) => {

     

       121
       121
       +
                   return [method, applyMiddleware(fns, handler)];

     

       122
       122
       +
                 }),

     

       123
       123
       +
               ),

     

       124
       124
       +
             ];

     

       125
       125
       +
           }),

     

       126
       126
       +
         );

     

       127
       127
       +
       };