commit bf0bc92e2a672173dd8888110998c2d88dc1a889 · ptr.pet/barometer

+39 -17

proxy/src/index.ts

···

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

     

       10
        
       import {

     

       11
        
         parseCanonicalResourceUri,

     

       12
       -
         parseResourceUri,

     

       13
        
         type RecordKey,

     

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

     

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

     

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

     

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

     

       18
        
       import {

     

       19
        
         SystemsGazeBarometerState,

     

       20
        
         SystemsGazeBarometerHost,

     

       21
        
         SystemsGazeBarometerService,

     

       22
        
         SystemsGazeBarometerCheck,

     

       23
        
       } from "barometer-lexicon";

     

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

     

       25
        
       

     

       26
        
       interface Check {

     

       27
        
         record: SystemsGazeBarometerCheck.Main;

     
···

       75
        
           hostname,

     

       76
        
         );

     

       77
        
       }

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       78
        
       

     

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

     

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

     
···

       83
        
         routes: {

     

       84
        
           "/push": {

     

       85
        
             POST: async (req) => {

     

       86
       -
               const maybeState = safeParse(

     

       87
       -
                 SystemsGazeBarometerState.mainSchema,

     

       88
       -
                 await req.json(),

     

       89
       -
               );

     

       90
       -
               if (!maybeState.ok) {

     

       91
        
                 return badRequest({

     

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

     

       93
       -
                   issues: maybeState.issues,

     

       94
        
                 });

     

       95
        
               }

     

       96
       -
               const state = maybeState.value;

     

       97
        
       

     

       98
        
               const serviceAtUri = expect(

     

       99
       -
                 parseCanonicalResourceUri(state.forService),

     

       100
        
               );

     

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

     

       102
        
               if (!service) {

     
···

       105
        
                   serviceAtUri.rkey,

     

       106
        
                 );

     

       107
        
                 if (!serviceRecord.ok) {

     

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

     

       0
        
       
     

       0
        
       
     

       109
        
                 }

     

       110
        
                 service = {

     

       111
        
                   record: serviceRecord.value,

     
···

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

     

       115
        
               }

     

       116
        
       

     

       117
       -
               if (state.generatedBy) {

     

       118
        
                 const checkAtUri = expect(

     

       119
       -
                   parseCanonicalResourceUri(state.generatedBy),

     

       120
        
                 );

     

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

     

       122
        
                 if (!check) {

     
···

       125
        
                     checkAtUri.rkey,

     

       126
        
                   );

     

       127
        
                   if (!checkRecord.ok) {

     

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

     

       0
        
       
     

       0
        
       
     

       129
        
                   }

     

       130
        
                   check = {

     

       131
        
                     record: checkRecord.value,

     
···

       134
        
                 }

     

       135
        
               }

     

       136
        
       

     

       137
       -
               const result = await putRecord(state);

     

       138
        
               return new Response(

     

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

     

       140
        
               );

···

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

     

       10
        
       import {

     

       11
        
         parseCanonicalResourceUri,

     

       0
        
       
     

       12
        
         type RecordKey,

     

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

     

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

     

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

     

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

     

       17
        
       import {

     

       18
        
         SystemsGazeBarometerState,

     

       19
        
         SystemsGazeBarometerHost,

     

       20
        
         SystemsGazeBarometerService,

     

       21
        
         SystemsGazeBarometerCheck,

     

       22
        
       } from "barometer-lexicon";

     

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

     

       24
        
       

     

       25
        
       interface Check {

     

       26
        
         record: SystemsGazeBarometerCheck.Main;

     
···

       74
        
           hostname,

     

       75
        
         );

     

       76
        
       }

     

       77
       +
       

     

       78
       +
       interface PushRequest {

     

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

     

       80
       +
         state: SystemsGazeBarometerState.Main;

     

       81
       +
       }

     

       82
       +
       

     

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

     

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

     

       85
       +
           return err("invalid request");

     

       86
       +
         }

     

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

     

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

     

       89
       +
         }

     

       90
       +
         if ("state" in json) {

     

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

     

       92
       +
           if (!parsed.ok) {

     

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

     

       94
       +
           }

     

       95
       +
         } else {

     

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

     

       97
       +
         }

     

       98
       +
         return ok(json as PushRequest);

     

       99
       +
       };

     

       100
        
       

     

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

     

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

     
···

       105
        
         routes: {

     

       106
        
           "/push": {

     

       107
        
             POST: async (req) => {

     

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

     

       109
       +
               if (!maybeData.ok) {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       110
        
                 return badRequest({

     

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

     

       0
        
       
     

       112
        
                 });

     

       113
        
               }

     

       114
       +
               const data = maybeData.value;

     

       115
        
       

     

       116
        
               const serviceAtUri = expect(

     

       117
       +
                 parseCanonicalResourceUri(data.state.forService),

     

       118
        
               );

     

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

     

       120
        
               if (!service) {

     
···

       123
        
                   serviceAtUri.rkey,

     

       124
        
                 );

     

       125
        
                 if (!serviceRecord.ok) {

     

       126
       +
                   return badRequest({

     

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

     

       128
       +
                   });

     

       129
        
                 }

     

       130
        
                 service = {

     

       131
        
                   record: serviceRecord.value,

     
···

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

     

       135
        
               }

     

       136
        
       

     

       137
       +
               if (data.state.generatedBy) {

     

       138
        
                 const checkAtUri = expect(

     

       139
       +
                   parseCanonicalResourceUri(data.state.generatedBy),

     

       140
        
                 );

     

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

     

       142
        
                 if (!check) {

     
···

       145
        
                     checkAtUri.rkey,

     

       146
        
                   );

     

       147
        
                   if (!checkRecord.ok) {

     

       148
       +
                     return badRequest({

     

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

     

       150
       +
                     });

     

       151
        
                   }

     

       152
        
                   check = {

     

       153
        
                     record: checkRecord.value,

     
···

       156
        
                 }

     

       157
        
               }

     

       158
        
       

     

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

     

       160
        
               return new Response(

     

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

     

       162
        
               );

+11 -7

proxy/src/utils.ts

···

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

     

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

     

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

     

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

     

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

     

       6
        
       import { atpClient } from ".";

     

       7
        
       

     
···

       14
        
             ok: false;

     

       15
        
             error: E;

     

       16
        
           };

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
       

     

       18
        
       export const expect = <T, E>(

     

       19
        
         v: Result<T, E>,

     
···

       41
        
           },

     

       42
        
         });

     

       43
        
         if (!maybeRecord.ok) {

     

       44
       -
           return {

     

       45
       -
             ok: false,

     

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

     

       47
       -
           };

     

       48
        
         }

     

       49
        
         const maybeTyped = safeParse(

     

       50
        
           BarometerSchemas[collection],

     

       51
        
           maybeRecord.data.value,

     

       52
        
         );

     

       53
        
         if (!maybeTyped.ok) {

     

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

     

       55
        
         }

     

       56
        
         return maybeTyped;

     

       57
        
       };

     
···

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

     

       63
        
         rkey?: RecordKey,

     

       64
        
       ) => {

     

       65
       -
         return await ok(

     

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

     

       67
        
             input: {

     

       68
        
               collection: record["$type"],

···

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

     

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

     

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

     

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

     

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

     

       6
        
       import { atpClient } from ".";

     

       7
        
       

     
···

       14
        
             ok: false;

     

       15
        
             error: E;

     

       16
        
           };

     

       17
       +
       

     

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

     

       19
       +
         return { ok: true, value };

     

       20
       +
       };

     

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

     

       22
       +
         return { ok: false, error };

     

       23
       +
       };

     

       24
        
       

     

       25
        
       export const expect = <T, E>(

     

       26
        
         v: Result<T, E>,

     
···

       48
        
           },

     

       49
        
         });

     

       50
        
         if (!maybeRecord.ok) {

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       52
        
         }

     

       53
        
         const maybeTyped = safeParse(

     

       54
        
           BarometerSchemas[collection],

     

       55
        
           maybeRecord.data.value,

     

       56
        
         );

     

       57
        
         if (!maybeTyped.ok) {

     

       58
       +
           return err(maybeTyped.message);

     

       59
        
         }

     

       60
        
         return maybeTyped;

     

       61
        
       };

     
···

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

     

       67
        
         rkey?: RecordKey,

     

       68
        
       ) => {

     

       69
       +
         return await clientOk(

     

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

     

       71
        
             input: {

     

       72
        
               collection: record["$type"],