commit bf0bc92e2a672173dd8888110998c2d88dc1a889 · ptr.pet/barometer

+39 -17

proxy/src/index.ts

···

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

     

       10
       10
        
       import {

     

       11
       11
        
         parseCanonicalResourceUri,

     

       12
       12
       -
         parseResourceUri,

     

       13
       12
        
         type RecordKey,

     

       14
       13
        
       } from "@atcute/lexicons/syntax";

     

       15
       14
        
       import { config } from "./config";

     

       16
       15
        
       import type {} from "@atcute/atproto";

     

       17
       17
       -
       import { safeParse } from "@atcute/lexicons";

     

       16
       16
       +
       import { is, safeParse } from "@atcute/lexicons";

     

       18
       17
        
       import {

     

       19
       18
        
         SystemsGazeBarometerState,

     

       20
       19
        
         SystemsGazeBarometerHost,

     

       21
       20
        
         SystemsGazeBarometerService,

     

       22
       21
        
         SystemsGazeBarometerCheck,

     

       23
       22
        
       } from "barometer-lexicon";

     

       24
       24
       -
       import { expect, getRecord, putRecord } from "./utils";

     

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

     

       25
       24
        
       

     

       26
       25
        
       interface Check {

     

       27
       26
        
         record: SystemsGazeBarometerCheck.Main;

     
···

       75
       74
        
           hostname,

     

       76
       75
        
         );

     

       77
       76
        
       }

     

       77
       77
       +
       

     

       78
       78
       +
       interface PushRequest {

     

       79
       79
       +
         serviceName?: string; // service manager service name

     

       80
       80
       +
         state: SystemsGazeBarometerState.Main;

     

       81
       81
       +
       }

     

       82
       82
       +
       

     

       83
       83
       +
       const parsePushRequest = (json: unknown): Result<PushRequest, string> => {

     

       84
       84
       +
         if (typeof json !== "object" || json === null) {

     

       85
       85
       +
           return err("invalid request");

     

       86
       86
       +
         }

     

       87
       87
       +
         if ("serviceName" in json && typeof json.serviceName !== "string") {

     

       88
       88
       +
           return err("serviceName is not a string");

     

       89
       89
       +
         }

     

       90
       90
       +
         if ("state" in json) {

     

       91
       91
       +
           const parsed = safeParse(SystemsGazeBarometerState.mainSchema, json.state);

     

       92
       92
       +
           if (!parsed.ok) {

     

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

     

       94
       94
       +
           }

     

       95
       95
       +
         } else {

     

       96
       96
       +
           return err("state not found");

     

       97
       97
       +
         }

     

       98
       98
       +
         return ok(json as PushRequest);

     

       99
       99
       +
       };

     

       78
       100
        
       

     

       79
       101
        
       const badRequest = <Error extends { msg: string }>(error: Error) => {

     

       80
       102
        
         return new Response(JSON.stringify(error), { status: 400 });

     
···

       83
       105
        
         routes: {

     

       84
       106
        
           "/push": {

     

       85
       107
        
             POST: async (req) => {

     

       86
       86
       -
               const maybeState = safeParse(

     

       87
       87
       -
                 SystemsGazeBarometerState.mainSchema,

     

       88
       88
       -
                 await req.json(),

     

       89
       89
       -
               );

     

       90
       90
       -
               if (!maybeState.ok) {

     

       108
       108
       +
               const maybeData = parsePushRequest(await req.json());

     

       109
       109
       +
               if (!maybeData.ok) {

     

       91
       110
        
                 return badRequest({

     

       92
       92
       -
                   msg: `invalid state: ${maybeState.message}`,

     

       93
       93
       -
                   issues: maybeState.issues,

     

       111
       111
       +
                   msg: `invalid request: ${maybeData.error}`,

     

       94
       112
        
                 });

     

       95
       113
        
               }

     

       96
       96
       -
               const state = maybeState.value;

     

       114
       114
       +
               const data = maybeData.value;

     

       97
       115
        
       

     

       98
       116
        
               const serviceAtUri = expect(

     

       99
       99
       -
                 parseCanonicalResourceUri(state.forService),

     

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

     

       100
       118
        
               );

     

       101
       119
        
               let service = services.get(serviceAtUri.rkey);

     

       102
       120
        
               if (!service) {

     
···

       105
       123
        
                   serviceAtUri.rkey,

     

       106
       124
        
                 );

     

       107
       125
        
                 if (!serviceRecord.ok) {

     

       108
       108
       -
                   return badRequest({ msg: "service was not found" });

     

       126
       126
       +
                   return badRequest({

     

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

     

       128
       128
       +
                   });

     

       109
       129
        
                 }

     

       110
       130
        
                 service = {

     

       111
       131
        
                   record: serviceRecord.value,

     
···

       114
       134
        
                 services.set(serviceAtUri.rkey, service);

     

       115
       135
        
               }

     

       116
       136
        
       

     

       117
       117
       -
               if (state.generatedBy) {

     

       137
       137
       +
               if (data.state.generatedBy) {

     

       118
       138
        
                 const checkAtUri = expect(

     

       119
       119
       -
                   parseCanonicalResourceUri(state.generatedBy),

     

       139
       139
       +
                   parseCanonicalResourceUri(data.state.generatedBy),

     

       120
       140
        
                 );

     

       121
       141
        
                 let check = service.checks.get(checkAtUri.rkey);

     

       122
       142
        
                 if (!check) {

     
···

       125
       145
        
                     checkAtUri.rkey,

     

       126
       146
        
                   );

     

       127
       147
        
                   if (!checkRecord.ok) {

     

       128
       128
       -
                     return badRequest({ msg: "check record not found" });

     

       148
       148
       +
                     return badRequest({

     

       149
       149
       +
                       msg: `check record not found or is invalid: ${checkRecord.error}`,

     

       150
       150
       +
                     });

     

       129
       151
        
                   }

     

       130
       152
        
                   check = {

     

       131
       153
        
                     record: checkRecord.value,

     
···

       134
       156
        
                 }

     

       135
       157
        
               }

     

       136
       158
        
       

     

       137
       137
       -
               const result = await putRecord(state);

     

       159
       159
       +
               const result = await putRecord(data.state);

     

       138
       160
        
               return new Response(

     

       139
       161
        
                 JSON.stringify({ cid: result.cid, uri: result.uri }),

     

       140
       162
        
               );

+11 -7

proxy/src/utils.ts

···

       1
       1
        
       import { safeParse, type InferOutput, type RecordKey } from "@atcute/lexicons";

     

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

     

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

     

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

     

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

     

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

     

       6
       6
        
       import { atpClient } from ".";

     

       7
       7
        
       

     
···

       14
       14
        
             ok: false;

     

       15
       15
        
             error: E;

     

       16
       16
        
           };

     

       17
       17
       +
       

     

       18
       18
       +
       export const ok = <T, E>(value: T): Result<T, E> => {

     

       19
       19
       +
         return { ok: true, value };

     

       20
       20
       +
       };

     

       21
       21
       +
       export const err = <T, E>(error: E): Result<T, E> => {

     

       22
       22
       +
         return { ok: false, error };

     

       23
       23
       +
       };

     

       17
       24
        
       

     

       18
       25
        
       export const expect = <T, E>(

     

       19
       26
        
         v: Result<T, E>,

     
···

       41
       48
        
           },

     

       42
       49
        
         });

     

       43
       50
        
         if (!maybeRecord.ok) {

     

       44
       44
       -
           return {

     

       45
       45
       -
             ok: false,

     

       46
       46
       -
             error: maybeRecord.data.message ?? maybeRecord.data.error,

     

       47
       47
       -
           };

     

       51
       51
       +
           return err(maybeRecord.data.message ?? maybeRecord.data.error);

     

       48
       52
        
         }

     

       49
       53
        
         const maybeTyped = safeParse(

     

       50
       54
        
           BarometerSchemas[collection],

     

       51
       55
        
           maybeRecord.data.value,

     

       52
       56
        
         );

     

       53
       57
        
         if (!maybeTyped.ok) {

     

       54
       54
       -
           return { ok: false, error: maybeTyped.message };

     

       58
       58
       +
           return err(maybeTyped.message);

     

       55
       59
        
         }

     

       56
       60
        
         return maybeTyped;

     

       57
       61
        
       };

     
···

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

     

       63
       67
        
         rkey?: RecordKey,

     

       64
       68
        
       ) => {

     

       65
       65
       -
         return await ok(

     

       69
       69
       +
         return await clientOk(

     

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

     

       67
       71
        
             input: {

     

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