commit f6eac27310a526ca82b2267cb91b9c61883d0c78 · ptr.pet/barometer

+25

lib/src/index.ts

···

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1
        
       export * from "./lexicons/index.js";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0

···

       1
       +
       import {

     

       2
       +
         SystemsGazeBarometerCheck,

     

       3
       +
         SystemsGazeBarometerHost,

     

       4
       +
         SystemsGazeBarometerService,

     

       5
       +
         SystemsGazeBarometerState,

     

       6
       +
       } from "./lexicons/index.js";

     

       7
       +
       

     

       8
        
       export * from "./lexicons/index.js";

     

       9
       +
       

     

       10
       +
       export const schemas = {

     

       11
       +
         "systems.gaze.barometer.host": SystemsGazeBarometerHost.mainSchema,

     

       12
       +
         "systems.gaze.barometer.service": SystemsGazeBarometerService.mainSchema,

     

       13
       +
         "systems.gaze.barometer.check": SystemsGazeBarometerCheck.mainSchema,

     

       14
       +
         "systems.gaze.barometer.state": SystemsGazeBarometerState.mainSchema,

     

       15
       +
       };

     

       16
       +
       export const nsid = <

     

       17
       +
         T extends

     

       18
       +
           | typeof SystemsGazeBarometerHost

     

       19
       +
           | typeof SystemsGazeBarometerService

     

       20
       +
           | typeof SystemsGazeBarometerCheck

     

       21
       +
           | typeof SystemsGazeBarometerState,

     

       22
       +
       >(

     

       23
       +
         lex: T,

     

       24
       +
       ): (typeof schemas)[typeof lex.mainSchema.object.shape.$type.expected] => {

     

       25
       +
         return schemas[lex.mainSchema.object.shape.$type.expected];

     

       26
       +
       };

+8 -3

proxy/src/config.ts

···

       4
        
       interface Config {

     

       5
        
         repoDid: AtprotoDid;

     

       6
        
         appPass: string;

     

       0
        
       
     

       0
        
       
     

       7
        
       }

     

       8
        
       

     

       0
        
       
     

       0
        
       
     

       9
        
       const getConfig = (prefix: string): Config => {

     

       10
        
         const get = <Value>(

     

       11
        
           name: string,

     

       12
       -
           check: (value: unknown) => boolean = (value) =>

     

       13
       -
             typeof value !== "undefined",

     

       14
        
         ): Value => {

     

       15
        
           const value = env[`${prefix}${name}`];

     

       16
        
           if (check(value)) {

     
···

       20
        
         };

     

       21
        
         return {

     

       22
        
           repoDid: get("REPO_DID", isDid),

     

       23
       -
           appPass: get("APP_PASSWORD"),

     

       0
        
       
     

       0
        
       
     

       24
        
         };

     

       25
        
       };

     

       26

···

       4
        
       interface Config {

     

       5
        
         repoDid: AtprotoDid;

     

       6
        
         appPass: string;

     

       7
       +
         hostName?: string;

     

       8
       +
         hostDescription?: string;

     

       9
        
       }

     

       10
        
       

     

       11
       +
       const required = (value: unknown) => typeof value !== "undefined";

     

       12
       +
       

     

       13
        
       const getConfig = (prefix: string): Config => {

     

       14
        
         const get = <Value>(

     

       15
        
           name: string,

     

       16
       +
           check: (value: unknown) => boolean = () => true,

     

       0
        
       
     

       17
        
         ): Value => {

     

       18
        
           const value = env[`${prefix}${name}`];

     

       19
        
           if (check(value)) {

     
···

       23
        
         };

     

       24
        
         return {

     

       25
        
           repoDid: get("REPO_DID", isDid),

     

       26
       +
           appPass: get("APP_PASSWORD", required),

     

       27
       +
           hostName: get("HOST_NAME"),

     

       28
       +
           hostDescription: get("HOST_DESCRIPTION"),

     

       29
        
         };

     

       30
        
       };

     

       31

+97 -28

proxy/src/index.ts

···

       1
       -
       import {

     

       2
       -
         Client,

     

       3
       -
         CredentialManager,

     

       4
       -
         ok,

     

       5
       -
         simpleFetchHandler,

     

       6
       -
       } from "@atcute/client";

     

       7
        
       import { getPdsEndpoint } from "@atcute/identity";

     

       8
        
       import {

     

       9
        
         CompositeDidDocumentResolver,

     

       10
        
         PlcDidDocumentResolver,

     

       11
        
         WebDidDocumentResolver,

     

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

     

       13
       -
       import { isDid, type AtprotoDid } from "@atcute/lexicons/syntax";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

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

     

       16
       -
       import {} from "barometer-lexicon";

     

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

     

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

     

       19
       -
       import { is, safeParse } from "@atcute/lexicons";

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       20
        
       

     

       21
        
       const docResolver = new CompositeDidDocumentResolver({

     

       22
        
         methods: {

     
···

       36
        
         identifier: config.repoDid,

     

       37
        
         password: config.appPass,

     

       38
        
       });

     

       39
       -
       const atpClient = new Client({ handler: creds });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       40
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       41
        
       const server = Bun.serve({

     

       42
        
         routes: {

     

       43
        
           "/push": {

     
···

       47
        
                 await req.json(),

     

       48
        
               );

     

       49
        
               if (!maybeState.ok) {

     

       50
       -
                 return new Response(

     

       51
       -
                   JSON.stringify({

     

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

     

       53
       -
                     issues: maybeState.issues,

     

       54
       -
                   }),

     

       55
       -
                   { status: 400 },

     

       56
       -
                 );

     

       57
        
               }

     

       58
        
               const state = maybeState.value;

     

       59
       -
               const result = await ok(

     

       60
       -
                 atpClient.post("com.atproto.repo.putRecord", {

     

       61
       -
                   input: {

     

       62
       -
                     collection: state.$type,

     

       63
       -
                     record: state,

     

       64
       -
                     repo: config.repoDid,

     

       65
       -
                     rkey: generateTid(),

     

       66
       -
                   },

     

       67
       -
                 }),

     

       68
        
               );

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       69
        
               return new Response(

     

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

     

       71
        
               );

···

       1
       +
       import os from "os";

     

       2
       +
       

     

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

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

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

     

       5
        
       import {

     

       6
        
         CompositeDidDocumentResolver,

     

       7
        
         PlcDidDocumentResolver,

     

       8
        
         WebDidDocumentResolver,

     

       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;

     

       28
       +
       }

     

       29
       +
       interface Service {

     

       30
       +
         checks: Map<RecordKey, Check>;

     

       31
       +
         record: SystemsGazeBarometerService.Main;

     

       32
       +
       }

     

       33
       +
       const services = new Map<RecordKey, Service>();

     

       34
       +
       let host: SystemsGazeBarometerHost.Main | null = null;

     

       35
        
       

     

       36
        
       const docResolver = new CompositeDidDocumentResolver({

     

       37
        
         methods: {

     
···

       51
        
         identifier: config.repoDid,

     

       52
        
         password: config.appPass,

     

       53
        
       });

     

       54
       +
       export const atpClient = new Client({ handler: creds });

     

       55
       +
       

     

       56
       +
       // fetch host record for this host

     

       57
       +
       const maybeRecord = await getRecord(

     

       58
       +
         "systems.gaze.barometer.host",

     

       59
       +
         os.hostname(),

     

       60
       +
       );

     

       61
       +
       if (maybeRecord.ok) {

     

       62
       +
         host = maybeRecord.value;

     

       63
       +
       }

     

       64
       +
       

     

       65
       +
       // if it doesnt exist we make a new one

     

       66
       +
       if (host === null) {

     

       67
       +
         const hostname = os.hostname();

     

       68
       +
         await putRecord(

     

       69
       +
           {

     

       70
       +
             $type: "systems.gaze.barometer.host",

     

       71
       +
             name: config.hostName ?? hostname,

     

       72
       +
             description: config.hostDescription,

     

       73
       +
             os: os.platform(),

     

       74
       +
           },

     

       75
       +
           hostname,

     

       76
       +
         );

     

       77
       +
       }

     

       78
        
       

     

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

     

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

     

       81
       +
       };

     

       82
        
       const server = Bun.serve({

     

       83
        
         routes: {

     

       84
        
           "/push": {

     
···

       88
        
                 await req.json(),

     

       89
        
               );

     

       90
        
               if (!maybeState.ok) {

     

       91
       +
                 return badRequest({

     

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

     

       93
       +
                   issues: maybeState.issues,

     

       94
       +
                 });

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       95
        
               }

     

       96
        
               const state = maybeState.value;

     

       97
       +
       

     

       98
       +
               const serviceAtUri = expect(

     

       99
       +
                 parseCanonicalResourceUri(state.forService),

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       100
        
               );

     

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

     

       102
       +
               if (!service) {

     

       103
       +
                 const serviceRecord = await getRecord(

     

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

     

       105
       +
                   serviceAtUri.rkey,

     

       106
       +
                 );

     

       107
       +
                 if (!serviceRecord.ok) {

     

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

     

       109
       +
                 }

     

       110
       +
                 service = {

     

       111
       +
                   record: serviceRecord.value,

     

       112
       +
                   checks: new Map(),

     

       113
       +
                 };

     

       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) {

     

       123
       +
                   let checkRecord = await getRecord(

     

       124
       +
                     "systems.gaze.barometer.check",

     

       125
       +
                     checkAtUri.rkey,

     

       126
       +
                   );

     

       127
       +
                   if (!checkRecord.ok) {

     

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

     

       129
       +
                   }

     

       130
       +
                   check = {

     

       131
       +
                     record: checkRecord.value,

     

       132
       +
                   };

     

       133
       +
                   service.checks.set(checkAtUri.rkey, check);

     

       134
       +
                 }

     

       135
       +
               }

     

       136
       +
       

     

       137
       +
               const result = await putRecord(state);

     

       138
        
               return new Response(

     

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

     

       140
        
               );

+75

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
       +
       

     

       8
       +
       export type Result<T, E> =

     

       9
       +
         | {

     

       10
       +
             ok: true;

     

       11
       +
             value: T;

     

       12
       +
           }

     

       13
       +
         | {

     

       14
       +
             ok: false;

     

       15
       +
             error: E;

     

       16
       +
           };

     

       17
       +
       

     

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

     

       19
       +
         v: Result<T, E>,

     

       20
       +
         msg: string = "expected result to not be error",

     

       21
       +
       ) => {

     

       22
       +
         if (v.ok) {

     

       23
       +
           return v.value;

     

       24
       +
         }

     

       25
       +
         throw msg;

     

       26
       +
       };

     

       27
       +
       

     

       28
       +
       export const getRecord = async <

     

       29
       +
         Collection extends keyof typeof BarometerSchemas,

     

       30
       +
       >(

     

       31
       +
         collection: Collection,

     

       32
       +
         rkey: RecordKey,

     

       33
       +
       ): Promise<

     

       34
       +
         Result<InferOutput<(typeof BarometerSchemas)[Collection]>, string>

     

       35
       +
       > => {

     

       36
       +
         let maybeRecord = await atpClient.get("com.atproto.repo.getRecord", {

     

       37
       +
           params: {

     

       38
       +
             collection,

     

       39
       +
             repo: config.repoDid,

     

       40
       +
             rkey,

     

       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
       +
       };

     

       58
       +
       

     

       59
       +
       export const putRecord = async <

     

       60
       +
         Collection extends keyof typeof BarometerSchemas,

     

       61
       +
       >(

     

       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"],

     

       69
       +
               repo: config.repoDid,

     

       70
       +
               record,

     

       71
       +
               rkey: rkey ?? generateTid(),

     

       72
       +
             },

     

       73
       +
           }),

     

       74
       +
         );

     

       75
       +
       };