+25

lib/src/index.ts

··· 1 1 + import { 2 2 + SystemsGazeBarometerCheck, 3 3 + SystemsGazeBarometerHost, 4 4 + SystemsGazeBarometerService, 5 5 + SystemsGazeBarometerState, 6 6 + } from "./lexicons/index.js"; 7 7 + 1 8 export * from "./lexicons/index.js"; 9 9 + 10 10 + export const schemas = { 11 11 + "systems.gaze.barometer.host": SystemsGazeBarometerHost.mainSchema, 12 12 + "systems.gaze.barometer.service": SystemsGazeBarometerService.mainSchema, 13 13 + "systems.gaze.barometer.check": SystemsGazeBarometerCheck.mainSchema, 14 14 + "systems.gaze.barometer.state": SystemsGazeBarometerState.mainSchema, 15 15 + }; 16 16 + export const nsid = < 17 17 + T extends 18 18 + | typeof SystemsGazeBarometerHost 19 19 + | typeof SystemsGazeBarometerService 20 20 + | typeof SystemsGazeBarometerCheck 21 21 + | typeof SystemsGazeBarometerState, 22 22 + >( 23 23 + lex: T, 24 24 + ): (typeof schemas)[typeof lex.mainSchema.object.shape.$type.expected] => { 25 25 + return schemas[lex.mainSchema.object.shape.$type.expected]; 26 26 + };

+8 -3

proxy/src/config.ts

··· 4 4 interface Config { 5 5 repoDid: AtprotoDid; 6 6 appPass: string; 7 7 + hostName?: string; 8 8 + hostDescription?: string; 7 9 } 8 10 11 11 + const required = (value: unknown) => typeof value !== "undefined"; 12 12 + 9 13 const getConfig = (prefix: string): Config => { 10 14 const get = <Value>( 11 15 name: string, 12 12 - check: (value: unknown) => boolean = (value) => 13 13 - typeof value !== "undefined", 16 16 + check: (value: unknown) => boolean = () => true, 14 17 ): Value => { 15 18 const value = env[`${prefix}${name}`]; 16 19 if (check(value)) { ··· 20 23 }; 21 24 return { 22 25 repoDid: get("REPO_DID", isDid), 23 23 - appPass: get("APP_PASSWORD"), 26 26 + appPass: get("APP_PASSWORD", required), 27 27 + hostName: get("HOST_NAME"), 28 28 + hostDescription: get("HOST_DESCRIPTION"), 24 29 }; 25 30 }; 26 31

+97 -28

proxy/src/index.ts

··· 1 1 - import { 2 2 - Client, 3 3 - CredentialManager, 4 4 - ok, 5 5 - simpleFetchHandler, 6 6 - } from "@atcute/client"; 1 1 + import os from "os"; 2 2 + 3 3 + import { Client, CredentialManager } from "@atcute/client"; 7 4 import { getPdsEndpoint } from "@atcute/identity"; 8 5 import { 9 6 CompositeDidDocumentResolver, 10 7 PlcDidDocumentResolver, 11 8 WebDidDocumentResolver, 12 9 } from "@atcute/identity-resolver"; 13 13 - import { isDid, type AtprotoDid } from "@atcute/lexicons/syntax"; 10 10 + import { 11 11 + parseCanonicalResourceUri, 12 12 + parseResourceUri, 13 13 + type RecordKey, 14 14 + } from "@atcute/lexicons/syntax"; 14 15 import { config } from "./config"; 15 16 import type {} from "@atcute/atproto"; 16 16 - import {} from "barometer-lexicon"; 17 17 - import { SystemsGazeBarometerState } from "barometer-lexicon"; 18 18 - import { now as generateTid } from "@atcute/tid"; 19 19 - import { is, safeParse } from "@atcute/lexicons"; 17 17 + import { safeParse } from "@atcute/lexicons"; 18 18 + import { 19 19 + SystemsGazeBarometerState, 20 20 + SystemsGazeBarometerHost, 21 21 + SystemsGazeBarometerService, 22 22 + SystemsGazeBarometerCheck, 23 23 + } from "barometer-lexicon"; 24 24 + import { expect, getRecord, putRecord } from "./utils"; 25 25 + 26 26 + interface Check { 27 27 + record: SystemsGazeBarometerCheck.Main; 28 28 + } 29 29 + interface Service { 30 30 + checks: Map<RecordKey, Check>; 31 31 + record: SystemsGazeBarometerService.Main; 32 32 + } 33 33 + const services = new Map<RecordKey, Service>(); 34 34 + let host: SystemsGazeBarometerHost.Main | null = null; 20 35 21 36 const docResolver = new CompositeDidDocumentResolver({ 22 37 methods: { ··· 36 51 identifier: config.repoDid, 37 52 password: config.appPass, 38 53 }); 39 39 - const atpClient = new Client({ handler: creds }); 54 54 + export const atpClient = new Client({ handler: creds }); 55 55 + 56 56 + // fetch host record for this host 57 57 + const maybeRecord = await getRecord( 58 58 + "systems.gaze.barometer.host", 59 59 + os.hostname(), 60 60 + ); 61 61 + if (maybeRecord.ok) { 62 62 + host = maybeRecord.value; 63 63 + } 64 64 + 65 65 + // if it doesnt exist we make a new one 66 66 + if (host === null) { 67 67 + const hostname = os.hostname(); 68 68 + await putRecord( 69 69 + { 70 70 + $type: "systems.gaze.barometer.host", 71 71 + name: config.hostName ?? hostname, 72 72 + description: config.hostDescription, 73 73 + os: os.platform(), 74 74 + }, 75 75 + hostname, 76 76 + ); 77 77 + } 40 78 79 79 + const badRequest = <Error extends { msg: string }>(error: Error) => { 80 80 + return new Response(JSON.stringify(error), { status: 400 }); 81 81 + }; 41 82 const server = Bun.serve({ 42 83 routes: { 43 84 "/push": { ··· 47 88 await req.json(), 48 89 ); 49 90 if (!maybeState.ok) { 50 50 - return new Response( 51 51 - JSON.stringify({ 52 52 - msg: `invalid state: ${maybeState.message}`, 53 53 - issues: maybeState.issues, 54 54 - }), 55 55 - { status: 400 }, 56 56 - ); 91 91 + return badRequest({ 92 92 + msg: `invalid state: ${maybeState.message}`, 93 93 + issues: maybeState.issues, 94 94 + }); 57 95 } 58 96 const state = maybeState.value; 59 59 - const result = await ok( 60 60 - atpClient.post("com.atproto.repo.putRecord", { 61 61 - input: { 62 62 - collection: state.$type, 63 63 - record: state, 64 64 - repo: config.repoDid, 65 65 - rkey: generateTid(), 66 66 - }, 67 67 - }), 97 97 + 98 98 + const serviceAtUri = expect( 99 99 + parseCanonicalResourceUri(state.forService), 68 100 ); 101 101 + let service = services.get(serviceAtUri.rkey); 102 102 + if (!service) { 103 103 + const serviceRecord = await getRecord( 104 104 + "systems.gaze.barometer.service", 105 105 + serviceAtUri.rkey, 106 106 + ); 107 107 + if (!serviceRecord.ok) { 108 108 + return badRequest({ msg: "service was not found" }); 109 109 + } 110 110 + service = { 111 111 + record: serviceRecord.value, 112 112 + checks: new Map(), 113 113 + }; 114 114 + services.set(serviceAtUri.rkey, service); 115 115 + } 116 116 + 117 117 + if (state.generatedBy) { 118 118 + const checkAtUri = expect( 119 119 + parseCanonicalResourceUri(state.generatedBy), 120 120 + ); 121 121 + let check = service.checks.get(checkAtUri.rkey); 122 122 + if (!check) { 123 123 + let checkRecord = await getRecord( 124 124 + "systems.gaze.barometer.check", 125 125 + checkAtUri.rkey, 126 126 + ); 127 127 + if (!checkRecord.ok) { 128 128 + return badRequest({ msg: "check record not found" }); 129 129 + } 130 130 + check = { 131 131 + record: checkRecord.value, 132 132 + }; 133 133 + service.checks.set(checkAtUri.rkey, check); 134 134 + } 135 135 + } 136 136 + 137 137 + const result = await putRecord(state); 69 138 return new Response( 70 139 JSON.stringify({ cid: result.cid, uri: result.uri }), 71 140 );

+75

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"; 5 5 + import { now as generateTid } from "@atcute/tid"; 6 6 + import { atpClient } from "."; 7 7 + 8 8 + export type Result<T, E> = 9 9 + | { 10 10 + ok: true; 11 11 + value: T; 12 12 + } 13 13 + | { 14 14 + ok: false; 15 15 + error: E; 16 16 + }; 17 17 + 18 18 + export const expect = <T, E>( 19 19 + v: Result<T, E>, 20 20 + msg: string = "expected result to not be error", 21 21 + ) => { 22 22 + if (v.ok) { 23 23 + return v.value; 24 24 + } 25 25 + throw msg; 26 26 + }; 27 27 + 28 28 + export const getRecord = async < 29 29 + Collection extends keyof typeof BarometerSchemas, 30 30 + >( 31 31 + collection: Collection, 32 32 + rkey: RecordKey, 33 33 + ): Promise< 34 34 + Result<InferOutput<(typeof BarometerSchemas)[Collection]>, string> 35 35 + > => { 36 36 + let maybeRecord = await atpClient.get("com.atproto.repo.getRecord", { 37 37 + params: { 38 38 + collection, 39 39 + repo: config.repoDid, 40 40 + rkey, 41 41 + }, 42 42 + }); 43 43 + if (!maybeRecord.ok) { 44 44 + return { 45 45 + ok: false, 46 46 + error: maybeRecord.data.message ?? maybeRecord.data.error, 47 47 + }; 48 48 + } 49 49 + const maybeTyped = safeParse( 50 50 + BarometerSchemas[collection], 51 51 + maybeRecord.data.value, 52 52 + ); 53 53 + if (!maybeTyped.ok) { 54 54 + return { ok: false, error: maybeTyped.message }; 55 55 + } 56 56 + return maybeTyped; 57 57 + }; 58 58 + 59 59 + export const putRecord = async < 60 60 + Collection extends keyof typeof BarometerSchemas, 61 61 + >( 62 62 + record: InferOutput<(typeof BarometerSchemas)[Collection]>, 63 63 + rkey?: RecordKey, 64 64 + ) => { 65 65 + return await ok( 66 66 + atpClient.post("com.atproto.repo.putRecord", { 67 67 + input: { 68 68 + collection: record["$type"], 69 69 + repo: config.repoDid, 70 70 + record, 71 71 + rkey: rkey ?? generateTid(), 72 72 + }, 73 73 + }), 74 74 + ); 75 75 + };